11. Java常用类

1. Scanner类

1.1 基本语法

java.util.Scanner 是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。

Scanner s = new Scanner(System.in);

1.2 next方法

import java.util.Scanner; 

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据  

    //next方式接收字符串
        System.out.println("next方式接收:");
        // 判断是否还有输入
        if(scan.hasNext()){
          String str1 = scan.next();
          System.out.println("输入的数据为:"+str1);
        }  

    }
}

输出结果:

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收:
rimi com
输入的数据为:rimi

可以看到 com 字符串并未输出

1.3 nextLine方法

import java.util.Scanner; 

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据  

    //nextLine方式接收字符串
        System.out.println("nextLine方式接收:");
        // 判断是否还有输入
        if(scan.hasNextLine()){
          String str2 = scan.nextLine();
          System.out.println("输入的数据为:"+str2);
        }  

    }
}

执行以上程序输出结果为:

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收:
rimi com
输入的数据为:rimi com

可以看到 com 字符串输出。

1.4 next与nextLine()的区别

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。

nextLine():

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

1.5 使用Scanner输入多种数据类型

如果要输入 int 或 float 类型的数据,在 Scanner 类中也有支持,但是在输入之前最好先使用 hasNextXxx() 方法进行验证,再使用 nextXxx() 来读取

import java.util.Scanner;  

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据
        int i = 0 ;
        float f = 0.0f ;
        System.out.print("输入整数:");
        if(scan.hasNextInt()){
      // 判断输入的是否是整数
            i = scan.nextInt() ;
      // 接收整数
            System.out.println("整数数据:" + i) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是整数!") ;
        }
        System.out.print("输入小数:");
        if(scan.hasNextFloat()){
      // 判断输入的是否是小数
            f = scan.nextFloat() ;
      // 接收小数
            System.out.println("小数数据:" + f) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是小数!") ;
        }
    }
}

输出结果:

$ javac ScannerDemo.java
$ java ScannerDemo
输入整数:12
整数数据:12
输入小数:1.2
小数数据:1.2

1.6 练习

1. 请输入需要累加的整数,直到输入 0 结束累加。

2. Number和Math类

2.1 什么是包装类

一般地,当需要使用数字的时候,我们通常使用内置数据类型,如:byte、int、long、double 等

int a = 5000;
float b = 13.65f;
byte c = 0x4a;

然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情形。为了解决这个问题,Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。

这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类。相似的,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

public class Test{

   public static void main(String args[]){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x);
   }
}

当 x 被赋为整型值时,由于x是一个对象,所以编译器要对x进行装箱。然后,为了使x能进行加运算,所以要对x进行拆箱。

关于拆箱封箱

/**
*
* java中的自动装箱与拆箱
* 简单一点说,装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据类型。
*/
public class NumberDemo {
    public static void main(String[] args) {
        /*
        Integer i1 = 128;  // 装箱,相当于 Integer.valueOf(128);
        int t = i1; //相当于 i1.intValue() 拆箱
        System.out.println(t);
        */

        /*
        对于–128到127(默认是127)之间的值,被装箱后,会被放在内存里进行重用
        但是如果超出了这个值,系统会重新new 一个对象
        */
        Integer i1 = 200;
        Integer i2 = 200;

        /*
        注意 == 与 equals的区别
        == 它比较的是对象的地址
        equlas 比较的是对象的内容
        */
        if(i1==i2) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

2.2 Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用。

public class Test {
    public static void main (String []args)
    {
        System.out.println("90 度的正弦值:" + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值:" + Math.cos(0));
        System.out.println("60度的正切值:" + Math.tan(Math.PI/3));
        System.out.println("1的反正切值: " + Math.atan(1));
        System.out.println("π/2的角度值:" + Math.toDegrees(Math.PI/2));
        System.out.println(Math.PI);
    }
}

结果如下:

90 度的正弦值:1.0
0度的余弦值:1.0
60度的正切值:1.7320508075688767
1的反正切值: 0.7853981633974483
π/2的角度值:90.0
3.141592653589793

2.3 number和Math类的方法

1   xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2   compareTo()
将number对象与参数比较。
3   equals()
判断number对象是否与参数相等。
4   valueOf()
返回一个 Number 对象指定的内置数据类型
5   toString()
以字符串形式返回值。
6   parseInt()
将字符串解析为int类型。
7   abs()
返回参数的绝对值。
8   ceil()
对整形变量向左取整,返回类型为double型。
9   floor()
对整型变量向右取整。返回类型为double类型。
10  rint()
返回与参数最接近的整数。返回类型为double。
11  round()
返回一个最接近的int、long型值。
12  min()
返回两个参数中的最小值。
13  max()
返回两个参数中的最大值。
14  exp()
返回自然数底数e的参数次方。
15  log()
返回参数的自然数底数的对数值。
16  pow()
返回第一个参数的第二个参数次方。
17  sqrt()
求参数的算术平方根。
18  sin()
求指定double类型参数的正弦值。
19  cos()
求指定double类型参数的余弦值。
20  tan()
求指定double类型参数的正切值。
21  asin()
求指定double类型参数的反正弦值。
22  acos()
求指定double类型参数的反余弦值。
23  atan()
求指定double类型参数的反正切值。
24  atan2()
将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25  toDegrees()
将参数转化为角度。
26  toRadians()
将角度转换为弧度。
27  random()
返回一个随机数。

举例

    /**
     * abs求绝对值
     */
    System.out.println(Math.abs(-10.4));    //10.4
    System.out.println(Math.abs(10.1));     //10.1  

    /**
     * ceil天花板的意思,就是返回大的值,注意一些特殊值
     */
    System.out.println(Math.ceil(-10.1));   //-10.0
    System.out.println(Math.ceil(10.7));    //11.0
    System.out.println(Math.ceil(-0.7));    //-0.0
    System.out.println(Math.ceil(0.0));     //0.0
    System.out.println(Math.ceil(-0.0));    //-0.0  

    /**
     * floor地板的意思,就是返回小的值
     */
    System.out.println(Math.floor(-10.1));  //-11.0
    System.out.println(Math.floor(10.7));   //10.0
    System.out.println(Math.floor(-0.7));   //-1.0
    System.out.println(Math.floor(0.0));    //0.0
    System.out.println(Math.floor(-0.0));   //-0.0  

    /**
     * max 两个中返回大的值,min和它相反,就不举例了
     */
    System.out.println(Math.max(-10.1, -10));   //-10.0
    System.out.println(Math.max(10.7, 10));     //10.7
    System.out.println(Math.max(0.0, -0.0));    //0.0  

    /**
     * random 取得一个大于或者等于0.0小于不等于1.0的随机数
     */
    System.out.println(Math.random());  //0.08417657924317234
    System.out.println(Math.random());  //0.43527904004403717  

    /**
     * rint 四舍五入,返回double值
     * 注意.5的时候会取偶数
     */
    System.out.println(Math.rint(10.1));    //10.0
    System.out.println(Math.rint(10.7));    //11.0
    System.out.println(Math.rint(11.5));    //12.0
    System.out.println(Math.rint(10.5));    //10.0
    System.out.println(Math.rint(10.51));   //11.0
    System.out.println(Math.rint(-10.5));   //-10.0
    System.out.println(Math.rint(-11.5));   //-12.0
    System.out.println(Math.rint(-10.51));  //-11.0
    System.out.println(Math.rint(-10.6));   //-11.0
    System.out.println(Math.rint(-10.2));   //-10.0  

    /**
     * round 四舍五入,float时返回int值,double时返回long值
     */
    System.out.println(Math.round(10.1));   //10
    System.out.println(Math.round(10.7));   //11
    System.out.println(Math.round(10.5));   //11
    System.out.println(Math.round(10.51));  //11
    System.out.println(Math.round(-10.5));  //-10
    System.out.println(Math.round(-10.51)); //-11
    System.out.println(Math.round(-10.6));  //-11
    System.out.println(Math.round(-10.2));  //-10

3. Character类

3.1 Character类的用法

Character 类用于对单个字符进行操作。

Character 类在对象中包装一个基本类型 char 的值

// 单个字符
char ch = ‘a‘;

// Unicode 字符表示形式
char uniChar = ‘\u039A‘; 

// 字符数组
char[] charArray ={ ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘ };

// 包装类 Character
Character ch = new Character(‘a‘);

在某些情况下,Java编译器会自动创建一个Character对象。

例如,将一个char类型的参数传递给需要一个Character类型参数的方法时,那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱,反过来称为拆箱。

public static void main(String[] args) {
    // 原始字符 ‘a‘ 装箱到 Character 对象 character 中
    Character character = ‘a‘;
    // 原始字符 ‘x‘ 用 test 方法装箱
    // 返回拆箱的值到 ch
    char ch = test(‘x‘);
}
public static char test(Character c) {
    return c;
}

3.2 转义序列

前面有反斜杠(\)的字符代表转义字符,它对编译器来说是有特殊含义的。

\t  在文中该处插入一个tab键
\b  在文中该处插入一个后退键
\n  在文中该处换行
\r  在文中该处插入回车
\f  在文中该处插入换页符
\‘  在文中该处插入单引号
\"  在文中该处插入双引号
\\  在文中该处插入反斜杠

3.3 Character类的方法

1   isLetter()  是否是一个字母
2   isDigit()   是否是一个数字字符
3   isWhitespace()  是否是一个空格
4   isUpperCase()   是否是大写字母
5   isLowerCase()   是否是小写字母
6   toUpperCase()   指定字母的大写形式
7   toLowerCase()   指定字母的小写形式
8   toString()  返回字符的字符串形式,字符串的长度仅为1

4. String类

字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。

4.1 创建字符串

创建字符串最简单的方式如下:

String greeting = "睿峰科技";

在代码中遇到字符串常量时,这里的值是 "睿峰科技"",编译器会使用该值创建一个 String 对象。 和其它对象一样,可以使用关键字和构造方法来创建 String 对象。 String 类有 11 种构造方法,这些方法提供不同的参数来初始化字符串,比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] nameArray = { ‘r‘, ‘i‘, ‘m‘, ‘i‘};
      String nameString = new String(nameArray);
      System.out.println(nameString);
   }
}

注意:String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了。

如果需要对字符串做很多修改,那么应该选择使用 StringBuffer & StringBuilder 类。

String 类是不可改变的解析,例如:

String s = "Google";
System.out.println("s = " + s);

s = "Rimi";
System.out.println("s = " + s);

结果为:

Google
Rimi

从结果上看是改变了,但为什么门说String对象是不可变的呢?

原因在于实例中的 s 只是一个 String 对象的引用,并不是对象本身,当执行 s = "Rimi"; 创建了一个新的对象 "Rimi",而原来的 "Google" 还存在于内存中。

4.2 字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法,它返回字符串对象包含的字符数。

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.rimiedu.com";
        int len = site.length();
        System.out.println( "睿峰教育网址长度 : " + len );
   }
}

4.3 连接字符串

String 类提供了连接两个字符串的方法:

string1.concat(string2);

更常用的是使用‘+‘操作符来连接字符串,如:

"Hello," + " rimi" + "!"

4.4 常用String类方法

1.字符串比较

compareTo
compareToIgnoreCase(//忽略大小写)

2.查找字符串最后一次出现的位置

lastIndexOf

3.截取字符串出现

substring

4.字符串替换

replace
replaceFirst
replaceAll

5.字符串反转

StringBuffer

6.字符串查找

indexOf

7.字符串分割

split

8.字符串小写转大写

toUpperCase

9.测试两个字符串区域是否相等

//参数说明:自己的起始位置,比较的 String, 比较的 String 的起始位置,比较长度。
regionMatches(11, second_str, 12, 9);
regionMatches(true, 11, second_str, 12, 9); //第一个参数 true 表示忽略大小写区别

10.字符串性能比较测试

System.currentTimeMillis(); //利用获取时间戳进行比较
//第一种创建形式
String s1 = "hello";
//第二种创建形式
String s2 = new String("hello");

11.字符串优化

1. 直接使用字符串
     String str  = "123";
     String str1 = "123";
2. 使用 new 关键字
     String str2 = new String("123");

字符串优化处理

12.连接字符串

字符串连接 - 使用 + 操作符

字符串连接 - 使用 StringBuffer/StringBuilder

StringBuffer
代码示例:
   StringBuilder sb = new StringBuilder ( "" );
        for ( int i= 0 ;i< 10 ;i++){
               sb.append(String.valueOf(i));
               System.out.println(sb+",");
               }

5. StringBuffer/StringBuilder类

当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的(不能同步访问)。

由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("睿峰官网:");
    sBuffer.append("www");
    sBuffer.append(".rimi");
    sBuffer.append(".com");
    System.out.println(sBuffer);
  }
}

StringBuffer方法:

1   public StringBuffer append(String s)    将指定的字符串追加到此字符序列。
2   public StringBuffer reverse()    将此字符序列用其反转形式取代。
3   public delete(int start, int end)   移除此序列的子字符串中的字符。
4   public insert(int offset, int i)    将 int 参数的字符串表示形式插入此序列中。
5   replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

Java 中 StringBuffer 和 String 是有一定的区别的

首先,String 是被 final 修饰的,他的长度是不可变的,就算调用 String 的 concat 方法,那也是把字符串拼接起来并重新创建一个对象,把拼接后的 String 的值赋给新创建的对象,

而 StringBuffer 的长度是可变的,调用StringBuffer 的 append 方法,来改变 StringBuffer 的长度,并且,相比较于 StringBuffer,String 一旦发生长度变化,是非常耗费内存的!


5. 数组类

java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的。

具有以下功能:

  • 给数组赋值:通过 fill 方法。
  • 对数组排序:通过 sort 方法,按升序。
  • 比较数组:通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

常用方法:

1   public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
2   public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3   public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4   public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

6. 时间日期

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数,该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

6.1 常用Date方法

1   boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2   boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3   Object clone( )
返回此对象的副本。
4   int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5   int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6   boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7   long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8   int hashCode( )
 返回此对象的哈希码值。
9   void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10  String toString( )
转换Date对象为String表示形式,并返回该字符串。

6.2 获取当前时间

Java中获取当前日期和时间很简单,使用 Date 对象的 toString() 方法来打印当前日期和时间

import java.util.Date;

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();

       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

6.3 日期比较

Java使用以下三种方法来比较两个日期:

  • 使用 getTime() 方法获取两个日期(自1970年1月1日经历的毫秒数值),然后比较这两个值。
  • 使用方法 before(),after() 和 equals()。例如,一个月的12号比18号早,则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
  • 使用 compareTo() 方法,它是由 Comparable 接口定义的,Date 类实现了这个接口。

6.4 使用 SimpleDateFormat 格式化日期

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行

import java.util.*;
import java.text.*;

public class DateDemo {
   public static void main(String args[]) {

      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd ‘at‘ hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

这一行代码确立了转换的格式,其中 yyyy 是完整的公元年,MM 是月份,dd 是日期,HH:mm:ss 是时、分、秒。

注意:有的格式大写,有的格式小写,例如 MM 是月份,mm 是分;HH 是 24 小时制,而 hh 是 12 小时制。

6.5 日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中,所有的 ASCII 字母被保留为模式字母,定义如下:

G   纪元标记    AD
y   四位年份    2001
M   月份  July or 07
d   一个月的日期  10
h    A.M./P.M. (1~12)格式小时   12
H   一天中的小时 (0~23)   22
m   分钟数 30
s   秒数  55
S   毫秒数 234
E   星期几 Tuesday
D   一年中的日子  360
F   一个月中第几周的周几  2 (second Wed. in July)
w   一年中第几周  40
W   一个月中第几周 1
a   A.M./P.M. 标记    PM
k   一天中的小时(1~24)    24
K    A.M./P.M. (0~11)格式小时   10
z   时区  Eastern Standard Time
‘   文字定界符   Delimiter
"   单引号 `

6.6 测量时间

System.currentTimeMillis(); //获取当前时间戳

import java.util.*;

public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

6.7 Calendar类

我们现在已经能够格式化并创建一个日期对象了,但是我们如何才能设置和获取日期数据的特定部分呢,比如说小时,日,或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。

Calendar类的功能要比Date类强大很多,而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可。

6.7.1 创建Calendar类对象

  1. 创建一个代表系统当前日期的Calendar对象

    Calendar c = Calendar.getInstance();//默认是当前日期

  2. 创建一个指定日期的Calendar对象

    使用Calendar类代表特定的时间,需要首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。

    //创建一个代表2009年6月12日的Calendar对象
    Calendar c1 = Calendar.getInstance();
    c1.set(2009, 6 - 1, 12);
    

6.7.2 Calendar类对象字段

Calendar类中用一下这些常量表示不同的意义,jdk内的很多类其实都是采用的这种思想

Calendar.YEAR   年份
Calendar.MONTH  月份
Calendar.DATE   日期
Calendar.DAY_OF_MONTH   日期,和上面的字段意义完全相同
Calendar.HOUR   12小时制的小时
Calendar.HOUR_OF_DAY    24小时制的小时
Calendar.MINUTE 分钟
Calendar.SECOND 秒
Calendar.DAY_OF_WEEK    星期几

6.7.3 Calendar类对象的获取

Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几(注意(这个与Date类是不同的):1代表星期日、2代表星期1、3代表星期二,以此类推)
int day = c1.get(Calendar.DAY_OF_WEEK);

html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video { margin: 0; padding: 0; border: 0 }
body { font-family: Helvetica, arial, freesans, clean, sans-serif; font-size: 14px; line-height: 1.6; color: #333; background-color: #fff; padding: 20px; max-width: 960px; margin: 0 auto }
body>*:first-child { margin-top: 0 !important }
body>*:last-child { margin-bottom: 0 !important }
p,blockquote,ul,ol,dl,table,pre { margin: 15px 0 }
h1,h2,h3,h4,h5,h6 { margin: 20px 0 10px; padding: 0; font-weight: bold }
h1 tt,h1 code,h2 tt,h2 code,h3 tt,h3 code,h4 tt,h4 code,h5 tt,h5 code,h6 tt,h6 code { font-size: inherit }
h1 { font-size: 28px; color: #000 }
h2 { font-size: 24px; border-bottom: 1px solid #ccc; color: #000 }
h3 { font-size: 18px }
h4 { font-size: 16px }
h5 { font-size: 14px }
h6 { color: #777; font-size: 14px }
body>h2:first-child,body>h1:first-child,body>h1:first-child+h2,body>h3:first-child,body>h4:first-child,body>h5:first-child,body>h6:first-child { margin-top: 0; padding-top: 0 }
a:first-child h1,a:first-child h2,a:first-child h3,a:first-child h4,a:first-child h5,a:first-child h6 { margin-top: 0; padding-top: 0 }
h1+p,h2+p,h3+p,h4+p,h5+p,h6+p { margin-top: 10px }
a { color: #4183C4; text-decoration: none }
a:hover { text-decoration: underline }
ul,ol { padding-left: 30px }
ul li>:first-child,ol li>:first-child,ul li ul:first-of-type,ol li ol:first-of-type,ul li ol:first-of-type,ol li ul:first-of-type { margin-top: 0px }
ul ul,ul ol,ol ol,ol ul { margin-bottom: 0 }
dl { padding: 0 }
dl dt { font-size: 14px; font-weight: bold; font-style: italic; padding: 0; margin: 15px 0 5px }
dl dt:first-child { padding: 0 }
dl dt>:first-child { margin-top: 0px }
dl dt>:last-child { margin-bottom: 0px }
dl dd { margin: 0 0 15px; padding: 0 15px }
dl dd>:first-child { margin-top: 0px }
dl dd>:last-child { margin-bottom: 0px }
pre,code,tt { font-size: 12px; font-family: Consolas, "Liberation Mono", Courier, monospace }
code,tt { margin: 0 0px; padding: 0px 0px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8 }
pre>code { margin: 0; padding: 0; white-space: pre; border: none; background: transparent }
pre { background-color: #f8f8f8; border: 1px solid #ccc; font-size: 13px; line-height: 19px; overflow: auto; padding: 6px 10px }
pre code,pre tt { background-color: transparent; border: none }
kbd { background-color: #DDDDDD; background-image: linear-gradient(#F1F1F1, #DDDDDD); background-repeat: repeat-x; border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD; border-style: solid; border-width: 1px; font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; line-height: 10px; padding: 1px 4px }
blockquote { border-left: 4px solid #DDD; padding: 0 15px; color: #777 }
blockquote>:first-child { margin-top: 0px }
blockquote>:last-child { margin-bottom: 0px }
hr { clear: both; margin: 15px 0; height: 0px; overflow: hidden; border: none; background: transparent; border-bottom: 4px solid #ddd; padding: 0 }
table th { font-weight: bold }
table th,table td { border: 1px solid #ccc; padding: 6px 13px }
table tr { border-top: 1px solid #ccc; background-color: #fff }
table tr:nth-child(2n) { background-color: #f8f8f8 }
img { max-width: 100% }

时间: 2024-10-25 19:17:28

11. Java常用类的相关文章

Java基础 —— Java常用类

Java常用类: java.lang包: java.lang.Object类: hashcode()方法:返回一段整型的哈希码,代表地址. toString()方法:返回父类名+"@"+哈希码(一般用于覆盖). equals()方法:返回"=="操作的布尔值(一般用于覆盖). finalize()方法:用于对象的销毁(不受人为控制,由JVM调用,遵从垃圾回收机制). clone()方法:用于对象之间的拷贝(深拷贝). getClass()方法:返回对象的字节码文件对

一大波Java来袭(三)Java常用类

本文简单介绍集中Java常用类 不同种类的工具用于处理不同的工作.比如:厨房中的工具用于烹饪:农场中的工具用于养殖--对于Java的学习中处理不同的工作也要采用不同的工具.如:处理数学函数问题用Math类.针对文件的操作采用File类--这也充分体现了Java面向对象的特点 一.字符串类(重点理解内存模型) (一)String Java.lang.String字符串常量,具有不可变性. (二)StringBuffer Java.lang.StringBuffer字符串可变量,是线程安全的. (三

JAVA 常用类System以及Properties类的使用

package ioTest.io1; import java.util.Iterator; import java.util.Properties; import java.util.Set; /* * System: * API描述:public final class System extends Object * System 类包含一些有用的类字段和方法.它不能被实例化. * 在 System 类提供的设施中,有标准输入.标准输出和错误输出流:对外部定义的属性和环境变量的访问: * 加

java常用类之String类

public class StringTest{ /* * 1.字符串类: String . * 1) 什么是字符串? * 用一对双引号将一个或多个字符括起来组成的字符系列.例如: "A" "ABC" * 特殊的串: 一对连续的双引号.即: "" ,它称之为空串.也称之为长度为0的字符串. * * 2) 字符串的特性: * a) 字符串属于引用类型,一个字符串就是一个对象. * b) 字符串是不变的. * c) 字符串中每一个字符都有一个索引号(

java常用类之封装类

public class BaseTypeClassTest { /*  *   常用类  *   1.基本类型的封装类:  在Java语言中,八种基本类型均对应着一个封装类.  *   *    byte ====>>>  Byte  *    short ===>>>  Short  *    int =====>>>  Integer  *    long ====>>>  Long  *   *    float ===>

Android逆向之Java常用类

Android逆向之Java常用类 包装类 byte ­> Byte int ­> Integer short ­> Short long ­> Long float ­> Float double ­> Double boolean ­> Boolean char ­> Character   public static void test0(){        int n =123456;      // 整型转字符串         String nu

java常用类-String

Java String 类 字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串. 创建字符串 创建字符串最简单的方式如下: 1 String greeting = "小猛"; 在代码中遇到字符串常量时,这里的值是 "小猛"",编译器会使用该值创建一个 String 对象. 和其它对象一样,可以使用关键字和构造方法来创建 String 对象. String 类有 11 种构造方法,这些方法

Java 11 - Java String类

Java String类 字符串广泛应用在Java编程中,在Java中字符串属于对象,Java提供了String类来创建和操作字符串. 创建字符串 创建字符串最简单的方式如下: String greeting = "Hello world!"; 在代码中遇到字符串常量时,这里的值是"Hello world!",编译器会使用该值创建一个String对象. 和其它对象一样,可以使用关键字和构造方法来创建String对象. String类有11种构造方法,这些方法提供不同

Java——常用类(String)

[常用类] <1>字符串相关类(String.StringBuffer) <2>基本数据类型包装类 <3>Math类 <4>File类 <5>枚举类 [String类] <1>java.lang.String类代表不可变的字符序列. <2>String类的常见构造方法: String(String original) //创建一个String对象为original的拷贝 String(char[] value) //用一个