JavaSE 12 常用类，javase12

1、包装类

⑴ 概念

本身属于引用数据类型，它是基本数据类型对应的引用数据类型。

基本数据类型         包装类

 byte               Byte
 short              Short
 int                Integer
 long               Long

 float              Float
 double             Double

 char               Character

 boolean            Boolean

⑵ 包装类和基本数据类型的转换

装箱：基本数据类型转包装类型
拆箱：包装类型转基本数据类型

这里以int类型作为演示

手动【调用方法】

手动装箱：
    方式一：通过构造器
        Integer i = new Integer(整数);
    方式二：调用valueOf 方法
        Integer i = Integer.valueOf(整数);

手动拆箱：通过intValue 方法
        int i = Integer对象.intValue( );

其他7个类型，对应的方法名为 基本数据类型名Value( )。例如char类型为：Character对象.charValue( ); boolean类型为：Boolean对象.booleanValue( );等

示例：

public class Test {
  public static void main(String[] args) {
    Integer i1 = new Integer(100); // 手动装箱（方式一）【通过构造器，转为包装类】
    int i2 = i1.intValue(); // 手动拆箱【调用intValue 方法】
    System.out.println(i2);

    Integer i3 = Integer.valueOf(i2); // 手动装箱（方式二）【调用valueOf 方法】
    System.out.println(i3);
  }
}

自动【不用方法】

JDK5.0产生的新特性

自动装箱：Integer i1 = 10;

自动拆箱：int i2 = i1;

包装类和String类型之间的转换

包装类转为String

包装类都重写了toString( )方法
    Integer i = 10;
    String str = i.toString( );

String转为包装类

⑴ 方式一：
    通过包装类的valueOf 方法
        String str = “123”;
        Integer i = Integer.valueOf(str);

⑵ 方式二：
    通过构造方法
        Integer i = new Integer(“123”);

2、Integer类

属性

最大值：Integer.MAX_VALUE // 2147483647【2^31－1】
最小值：Integer.MIN_VALUE // -2147483648【－2^31】

方法

toBinaryString

public static String toBinaryString(int i){}
静态的，返回一个二进制无符号整数形式的字符串。

System.out.println(Integer.toBinaryString(10)); // 1010

toOctalString

public static String toOctalString(int i) {}
静态的，返回一个八进制无符号整数形式的字符串。

System.out.println(Integer.toOctalString(10)); // 12

toHexString

public static String toHexString(int i) {}
静态的，返回一个十六进制无符号整数形式的字符串。

System.out.println(Integer.toHexString(10)); // a

3、Character类方法

isLetter

public static boolean isLetter(char ch) {}
静态的，返回值为boolean类型。确定指定字符是否为字母。

System.out.println(Character.isLetter('A')); // true

isDigit

public static boolean isDigit(char ch) {}
静态的，返回值为boolean类型。确定指定字符是否为数字。

System.out.println(Character.isDigit('9')); // true

isUpperCase

public static boolean isUpperCase(char ch) {}
静态的，返回值为boolean类型。确定指定字符是否为大写字母。

System.out.println(Character.isUpperCase('C')); // true

isLowerCase

public static boolean isLowerCase(char ch) {}
静态的，返回值为boolean类型。确定指定字符是否为小写字母。

System.out.println(Character.isLowerCase('C')); // false

toUpperCase

public static char toUpperCase(char ch) {}
静态的，返回值为char类型。将传入的字符转换为大写。

System.out.println(Character.toUpperCase('e')); // E

toLowerCase

public static char toLowerCase(char ch) {}
静态的，返回值为char类型。将传入的字符转换为小写。

System.out.println(Character.toLowerCase('C')); // c

4、String类

创建对象

⑴ 直接赋值

String str = "abc";

特点：先去常量池中查看是否有字面值为”abc”的空间，如果没有，则先创建，然后再指向；如果有，则不会创建，直接指向。

⑵ 通过构造方法

String str = new String("abc");

特点：先在堆中创建一个对象【String类型】，然后str指向这个对象。然后再查看常量池中是否有字面值为”abc”的空间，如果没有，则先创建，然后再让堆中的对象的value属性指向常量池中的”abc”；如果有，则不会创建，直接指向让堆中的对象的value属性指向它。

示例：

public class Test {
  public static void main(String[] args) {
    String s1 = "abc";
    String s2 = new String("bcd");
  }
}

面试题

情况1

String s1 = new String("abc");
这句话，创建了2个对象。

情况2

String s2 = "abc";
这句话，创建了1个对象。

情况3

 String s1 = new String("abc");
 String s2 = "abc";
 这两句话，创建了2个对象。

情况4

String s = "hello" + "java";
这句话，创建了3个对象。

情况5

 String s1 = "hello";
 String s2 = "java";
 String s3 = "hellojava";
 String s4 = s1 + s2;
 System.out.println(s3 == s4); // false

解释：s3指向的是常量池中的对象，而s4指向的是堆中的对象。这是因为s4是s1 + s2，相当于两个变量的拼接，Java虚拟机会在堆中创建一个新的对象，用于保存新的变量。

情况6

     String s1 = "hello";
     String s2 = "java";
     String s3 = "hellojava";
     String s4 = (s1 + s2).intern();
     System.out.println(s3 == s4); // true

解释：s3指向的是常量池中的对象，而s4指向的也是常量池中的对象。这是因为调用了intern方法。而intern方法返回的是字符串常量的地址号。

情况7

String s = "hello" + "java";
System.out.println(s == "hellojava"); // true

总结

String类保存的是字符串常量，里面的值一旦固定将不能更改。每次更新，相当于重新开辟新的空间，效率很低。

方法列举

length

public int length() {}
返回此字符串的长度。

System.out.println("hellojava".length()); // 9

equals

public boolean equals(Object anObject) {}
将此字符串与指定的对象比较【被重写了】。用于判断两个字符串的内容是否相等。

String str = "java";
System.out.println("java".equals(str)); // true 【容错性的处理，即将要比较的字符串放到前面，比较的对象放在括号中，这样不会出现空指针异常】

equalsIgnoreCase

public boolean equalsIgnoreCase(String anotherString) {}
将此 String 与另一个 String 比较，不考虑大小写。用于判断两个字符串的内容是否相等。

String str = "HelLOjAvA";
System.out.println("HelloJava".equalsIgnoreCase(str));

trim

public String trim() {}
返回字符串的副本，忽略前边的空白和尾部的空白。注意：字符当中的空白不会被忽略。

System.out.println("       ja  va       ".trim()); // ja  va

indexOf

public int indexOf(int ch) {}
返回指定字符在此字符串中第一次出现处的索引。如果找不到，就返回-1。索引位置从0开始。

System.out.println("ke2jjavafj3".indexOf('b')); // -1

public int indexOf(String str) {}
返回指定子字符串在此字符串中第一次出现处的索引。如果找不到，就返回-1。索引位置从0开始。

System.out.println("ke2jjavafj3".indexOf("4java")); // 4

lastIndexOf

public int lastIndexOf(int ch) {}
返回指定字符在此字符串中最后一次出现处的索引。如果找不到，就返回-1。索引位置从0开始。

System.out.println("ekf3ajg".indexOf('a')); // 4

public int lastIndexOf(String str) {}
返回指定子字符串在此字符串中最右边出现处的索引。如果找不到，就返回-1。索引位置从0开始。

System.out.println("ekf3ajg".indexOf("ak")); // -1

compareTo

public int compareTo(String anotherString) {}
按字典顺序比较两个字符串。这里说的字典就是ascii码表。

System.out.println("G".compareTo("a")); // -26

charAt

public char charAt(int index) {}
返回指定索引处的字符。索引位置从0开始。

System.out.println("HelloJava!".charAt(4)); // o

substring

public String substring(int beginIndex, int endIndex) {}
从起始索引处开始，到结束索引处的前一位字符，截取。返回一个新的字符串。

System.out.println("ek3hJava4k#".substring(4, 8)); // Java

public String substring(int beginIndex) {}
从起始索引处开始，直到字符串尾部，都截取，返回一个新的字符串。

System.out.println("ekJavaOk".substring(2)); // JavaOk

toUpperCase

public String toUpperCase() {}
将此字符串中所有的字符都转换为大写

System.out.println("3rka@leOk".toUpperCase()); // 3RKA@LEOK

toLowerCase

public String toLowerCase() {}
将此字符串中所有的字符都转换为小写

System.out.println("eKET3#Jre".toLowerCase()); // eket3#jre

startsWith

public boolean startsWith(String prefix) {}
判断某字符串是否以给定的字符串开头。

System.out.println("hellojava".startsWith("he")); // true

endsWith

public boolean endsWith(String suffix) {}
判断某字符串是否以给定的字符串结尾。

System.out.println("hellojava".startsWith("na")); // false

replace

public String replace(char oldChar, char newChar) {}
用新的字符去替换字符串中所有的旧的字符。

System.out.println("he11o".replace("1", "l")); // hello

split

public String[] split(String regex, int limit) {}
根据匹配给定的正则表达式来拆分此字符串。

String str = "你好，Java，世界，！";
String[] strs = str.split("，");

for (int i = 0; i < strs.length; i++) {
  System.out.println(strs[i]);
}
  /*
    你好
    Java
    世界
    ！
   */

public String[] split(String regex, int limit) {}
根据匹配给定的正则表达式来拆分此字符串。返回一个String类型的数组。第二个参数是限制，将给定字符串，拆分成几个子字符串。如果限制的个数小于，按照正则表达式可以拆分成的子字符串的个数，则只会拆分成限制的个数，而忽略后面子字符串中的符合正则的子字符串。

String str = "你好，Java，世界，！";
String[] strs = str.split("，", 3);

for (int i = 0; i < strs.length; i++) {
  System.out.println(strs[i]);
}

  /*
    你好
    Java
    世界，！  // 因为限制拆分成3个子字符串，所以忽略此逗号（传入的正则规则）
   */

format

public static String format(String format, Object… args) {}
使用指定的格式字符串和参数返回一个格式化字符串。

常用指定格式字符串：
 %s   字符串
 %d   整数
 %f   浮点数
 %c   字符

第二个参数为可变参数，需要和第一个参数（指定格式字符串的数据类型）一一对应。
静态方法，用String调用。

String name = "张三";
int age = 17;
double weight = 60;
char gender = '男';

String info = String.format("姓名：%s，性别：%c，年龄：%d，体重：%.1f", name, gender, age, weight);
System.out.println(info); // 姓名：张三，性别：男，年龄：17，体重：60.0

concat

public String concat(String str) {}
将指定字符串连接到此字符串的结尾（拼接字符串）。注意：传入的参数只能是String类型。

String str1 = "Hello";
String str2 = "Java";
System.out.println(str1.concat(str2)); // HelloJava

toCharArray

public char[] toCharArray() {}
将此字符串转换为一个新的字符数组。

String str = "abc";
char[] chs = str.toCharArray();
for (int i = 0; i < chs.length; i++) {
  System.out.println(chs[i]);
}

intern

public native String intern();
      当调用intern方法时，如果常量池中已经包含一个等于此 String对象的字符串（用 equals(Object) 方法确定），则返回常量池中的字符串。否则，将此String对象添加到常量池中，并返回此 String 对象的引用。
       例子可以看上面 面试题 中的 情况6。

5、StringBuffer类

String和StringBuffer的区别

⑴ String保存的是字符串常量，存放在常量池中。里面的值一旦固定将不能更改，每次更新字符串，需要重新开辟空间。
⑵ StringBuffer保存的是字符串变量，存放在堆中。里面的值可以更改，每次更新字符串，在原有的空间中直接修改。效率较高。

构造方法

StringBuffer( )

构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符

StringBuffer(int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区。

StringBuffer(String str)

构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

方法

append

public synchronized StringBuffer append(Object obj) {}
将参数追加到此StringBuffer中。这是一个重载的方法，参数可以为任意类型。线程安全。

sb.append("Java");
sb.append(true);
sb.append(12);
sb.append('@');
System.out.println(sb); // Javatrue12@

concat和append对对比

                concat                   append
定义的类         String                StringBuffer
参数             String                  任意类型
返回值类型       String                StringBuffer
功能        拼接，需要重新指向       追加，不需要重新指向
         （重新赋值给方法调用方）
效率                低                      高

insert

public synchronized StringBuffer insert(int offset, Object obj) {}
将 Object 参数的字符串表示形式插入此字符序列中。这是一个重载的方法。第一个参数为要插入的位置，从0开始；第二个参数为要插入的对象。线程安全。

StringBuffer sb = new StringBuffer("abcd");
sb.insert(0, "JAVA");
System.out.println(sb); // JAVAabcd

delete

public synchronized StringBuffer delete(int start, int end) {}
移除从指定的起始位置到结束位置的前一位的子字符串。线程安全。

StringBuffer sb = new StringBuffer("JhelloAVA");
sb.delete(1, 6);
System.out.println(sb); // JAVA

replace

public synchronized StringBuffer replace(int start, int end, String str) {}
使用给定的字符串，替换从指定的起始位置到结束位置的前一位的子字符串。线程安全。

StringBuffer sb = new StringBuffer("helloJAVA!");
sb.replace(5, 9, "World");
System.out.println(sb); // helloWorld!

reverse

public synchronized StringBuffer reverse() {}
反转此StringBuffer的内容

StringBuffer sb = new StringBuffer("helloJAVA!");
sb.reverse();
System.out.println(sb); // !AVAJolleh

StringBuffer和String类的转换

⑴ StringBuffer转String
    ① 调用toString 方法

StringBuffer sb = new StringBuffer("abc");
String str = sb.toString( );

    ② 通过构造方法

StringBuffer sb = new StringBuffer("abc");
String str = new String(sb);

⑵ String转StringBuffer

 String str = "abc";
 StringBuffer sb = new StringBuffer(str);

6、StringBuilder类

      此类提供一个与 StringBuffer 兼容的 API（即append，insert，delete，replace，reverse等方法都可以用。效果相同），但不保证线程安全。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 的效率要高。
      将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

7、StringBuffer和StringBuilder的对比

相同点

都是用于保存字符串变量。

不同点

               StringBuffer          StringBuilder
出现的版本         JDK1.0                  1.5
线程是否安全        安全                  不安全
是否同步            同步                  不同步
效率                低                     高

8、Math类的常用方法

Math类的构造器被私有化，里面的属性和方法都是静态的。

abs

public static int abs(int a) {}
求绝对值。返回一个和传入的参数类型相同的数值。这是一个重载方法。可传入的参数类型：int，long，float，double。

System.out.println(Math.abs(-2.3)); // 2.3

pow

public static double pow(double a, double b) {}
返回第一个参数的第二个参数次幂的值。

System.out.println(Math.pow(9, 2)); // 81.0

sqrt

public static double sqrt(double a) {}
求平方根，返回值为double类型。

System.out.println(Math.sqrt(2.56)); // 1.6

random

public static double random() {}
随机数。返回带正号的 double 值，该值的范围为：0 <= num < 1 【即[0,1)】

常用方法：
公式：产生范围为 a~b 的随机正数
int x = (int)(Math.random() * (b - a + 1) + a);

示例：产生一个随机的两位数
分析：
    ① 两位数的范围是10~99；
    ② 设a = 10，b = 99；
    ③ 带入公式中，得到：b - a + 1 = 90；
    ④ 所以最终表达式为：(int)(Math.random() * 90 + 10);

ceil

public static double ceil(double a) {}
向上取整。返回离传入的参数最近的，较大的数值。返回值为double类型。

System.out.println(Math.ceil(2.1)); // 3.0

floor

public static double floor(double a) {}
向上取整。返回离传入的参数最近的，较小的数值。返回值为double类型。

System.out.println(Math.floor(3.9)); // 3.0

round

public static int round(float a) {}
四舍五入。返回值为int类型。

System.out.println(Math.round(3.4)); // 3

9、Date类

用于描述一个特定的瞬间，精确到毫秒。

构造方法

⑴ Date(){};
    创建一个表示当前时间的Date对象

⑵ public Date(long date) {};
    形参表示表示自1970年1月1日00:00:00 以来的指定毫秒数

示例：

import java.util.Date; // 导包
Date date = new Date( );
System.out.println(date);

修改日期输出的格式

需要使用SimpleDateFormat，注意要导包。
构造器中传入要格式的字符串参数。

日期和时间格式由日期和时间模式字符串指定:
  y       年
  M       年中的月份
  d       月份中的天数
  h       am/pm 中的小时数（1-12）
  H       一天中的小时数（0-23）
  m       小时中的分钟数
  s       分钟中的秒数
  E       星期中的天数

import java.text.SimpleDateFormat; // 导包
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss E");
String d = sdf.format(date);
System.out.println(d);

10、Calender类

抽象类，不能直接实例化。其为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法。

创建对象

   import java.util.Calendar; // 导包
   Calendar calendar = Calendar.getInstance();

方法

get

public int get(int field){}
返回给定日历字段的值

示例：

System.out.println(calendar.get(Calendar.YEAR)); // 年
System.out.println(calendar.get(Calendar.MONTH) + 1); // 月【从0开始】
System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); // 日

System.out.println(calendar.get(Calendar.HOUR)); // 时【1-12】
System.out.println(calendar.get(Calendar.MINUTE)); // 分
System.out.println(calendar.get(Calendar.SECOND)); // 秒

set

public final void set(int year, int month, int date, int hourOfDay, int minute,int second){}
设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值

示例：

Calendar c = Calendar.getInstance();
c.set(2000, 11, 21, 14, 10, 26); // 设置月份（第二个参数)时，要注意月份是从0开始的

11、BigInteger类

创建对象

通过构造器BigInteger(String str);

方法

import java.math.BigInteger; // 导包
BigInteger b1 = new BigInteger("1230383923812323");
BigInteger b2 = new BigInteger("33918183929382");

System.out.println(b1.add(b2)); // 加
System.out.println(b1.subtract(b2)); // 减
System.out.println(b1.multiply(b2)); // 乘
System.out.println(b1.divide(b2)); // 除

12、BigDecimal类

创建对象

通过构造器BigDecimal(String str);

方法

import java.math.BigInteger; // 导包
BigDecimal b1 = new BigDecimal("391902434329.2");
BigDecimal b2 = new BigDecimal("1000000000");

System.out.println(b1.add(b2)); // 加
System.out.println(b1.subtract(b2)); // 减
System.out.println(b1.multiply(b2)); // 乘
System.out.println(b1.divide(b2)); // 除

注意除法【divide方法】若结果的精度会损失，则会报错：
java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

这时就需要调用重载的方法：
     public BigDecimal divide(BigDecimal divisor, int roundingMode) {}
示例：

b1.divide(b2, BigDecimal.ROUND_CEILING); // 接近正无穷大的舍入模式。

13、System类

arraycopy

public static native void arraycopy(Object src, int srcPos,Object dest,int destPos,int length);
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。第一个参数为源数组，第二个参数为开始从源数组的哪一位复制，第三个参数为目标数组，第四个参数为目标数组的起始索引，第五个参数为目标数组复制的长度。

currentTimeMillis

public static native long currentTimeMillis();
返回以毫秒为单位的当前时间。

gc

public static void gc() {}
唤醒垃圾回收机制。但不一定马上就能让回收机制回收垃圾。

exit

public static void exit(int status) {}
终止当前正在运行的 Java 虚拟机。根据惯例，0表示正常终止，非0的状态码表示异常终止。

getProperties

public static Properties getProperties() {}
返回当前的系统属性。

使用示例

import java.util.Date;
import java.util.Properties;

public class TestSystem {
  public static void main(String[] args) {
    // 获取当前系统时间与1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）
    long date = System.currentTimeMillis();
    Date d = new Date(date);
    System.out.println(d);

    String[] src = { "a", "b", "c" };
    String[] dest = new String[src.length];
    // 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
    System.arraycopy(src, 0, dest, 0, dest.length);
    int len = dest.length;
    for (int i = 0; i < len; i++) {
      System.out.println(dest[i]);
    }

    // 返回当前的系统属性
    Properties properties = System.getProperties();
    properties.list(System.err);

    MyClass mc = new MyClass();
    mc = null;
    // 唤醒垃圾回收器
    System.gc();

    // 终止当前正在运行的 Java 虚拟机
    System.exit(0);

    System.out.println("会执行我吗？");
  }
}

class MyClass {
  @Override
    protected void finalize() throws Throwable {
      System.out.println("被回收！");
    }
}