十一. 常用类

一、包装类

1.1 包装类的继承关系

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

public class Test{
    public static void main(String[] args){
        int n1 = 12;
        Integer n2 = n1; // 底层使用 valueOf 方法
        int n3 = n2; // 底层使用 intValue 方法
    }
}

1.3 包装类与String之间的转换

public class WrapperVSSring{
    public static void main(String[] args){
        
        // 包装类 (Integer) -> String
        Integer i = 100; // 自动装箱
        // 方式1
        String str1 = i + "";
        // 方式2
        String str2 = i.toString();
        // 方式3
        String str3 = String.valueOf(i);
    
        // String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4); // 使用到自动装箱
        Integer i3 = new Integer(str4);
    }
}

1.4 包装类的常用方法

二、String类

2.1 String类的理解和创建对象

package com.str_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class String01 {
    public static void main(String[] args) {
        // 1. String 对象用于保存字符串，也就是一组字符序列
        // 2. "jack" 字符串常量，双引号括起来的字符序列
        // 3. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
        // 4. String 类有很多构造器，构造器的重载
        //    常用的有 String s1 = new String();
        //    String s2 = new String(String original);
        //    String s3 = new String(char[] a);
        //    String s4 = new String(char[] a,int startIndex,int count)
        //    String s5 = new String(byte[] b)
        // 5. String 类实现 接口 Serializable 【String 可以串行化：可以在网络传输】
        //                 接口 Comparable [String 对象可以比较大小]
        // 6. String 是final类，不能被其他类继承
        // 7. String 有属性 private final char value[];用于存放字符串内容
        // 8. 一定要注意: value 是一个final类型，赋值后，不可以修改(需要功力)：
        // 即：value不能指向新的地址，但是单个字符内容是可以变化的
        String name = "jack";
        name = "tom";

        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H'; // 可以修改堆中字符数组空间中的元素
//        value = v2; // 不能修改value的指向
    }
}

2.2 String的创建方式

2.3 字符串的特性

package com.str_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class String02 {
    public static void main(String[] args) {
        String a = "a"; // 在常量池中创建"a"对象
        String b = "b"; // 在常量池中创建"b"对象
        // 解读
        // 1. 先 创建一个 StringBuilder sb = new StringBuilder();
        // 2. 执行 sb.append("a");
        // 3. sb.append("abc");
        // 4. String c = sb.toString()
        // 最后其实 c 指向堆中的对象（String），value[] -> 池中 "ab"
        String c = a + b;
        String d = "ab";
        System.out.println(c == d); // false
    }
}

2.4 String的常用方法

三、StringBuffer和StringBuilder类

3.1 StringBuffer类

3.1.1 StringBuffer类基本介绍

package com.str_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class StringBuilder01 {
    public static void main(String[] args) {
        // 老韩解读
        // 1. StringBuilder 的直接父类 是 AbstractStringBuilder
        // 2. StringBuilder 实现了 Serializable,即StringBuffer的对象可以串行化
        // 3. 在父类中 AbstractStringBuilder 有属性 char[] value，不是final！
        // 该 value 数组存放 字符串内容，指向堆中的对象（不同于String 的 value 指向常量池）
        // 4. String 是 final 类，不能被继承
        // 5. 因为 StringBuffer 字符内容是存在 char value, 所以在变化(增加/删除)
        // 不用每次都更换地址（即不是每次创建新对象），所以效率高于 String
        StringBuilder stringBuilder = new StringBuilder;

    }
}

3.1.2 String VS StringBuffer

3.1.3 StringBuffer的构造器

3.1.4 String与StringBuffer之间的转换

3.1.5 StringBuffer类常见方法

3.2 StringBuilder类

package com.str_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class StringBuilder01 {
    public static void main(String[] args) {
        // 1. StringBuilder 继承 AbstractStringBuilder 类
        // 2. 实现了 Serializable ，说明 StringBuilder对象时可以串行化（对象可以网络传输，可以保存到文件）
        // 3. StringBuilder 是final类，不被继承
        // 4. StringBuilder 对象字符序列是存放在其父类 AbstractStringBuilder 的 char[] value;
        // 5. StringBuilder 的方法，没有做互斥的处理，即没有synchronized 关键字，因此在单线程的情况下使用
        // StringBuilder
        StringBuilder stringBuilder = new StringBuilder();
    }
}

3.3 String、StringBuffer与StringBuilder的比较

四、Math类

五、Date日期类、Calender日历类以及新的日期

5.1 第一代日期类

5.2 第二代日期类

5.3 第三代日期类

六、System类

七、Arrays类

八、BigInterger类和BigDecimal

九、经典例题

9.1 Integer的创建机制

public void main(String[] args){
    Integer i = new Integer(1);
    Integer j = new Integer(1);
    System.out.println(i == j); // 创建两个对象空间，false
    
    Integer m = 1; // 底层 Integer.valueOf(1)
    Integer n = 1; //  底层 Integer.valueOf(1)
    System.out.println(i == j); // -128 ~ 127 范围内返回的是缓存中的 Integer 对象，true
    
    Integer x = 128;
    Integer y = 128;
    System.out.println(x == y); //  -128 ~ 127 范围内返回的是缓存中的 Integer 对象，false


    Integer i1 = 127; // 底层 Integer.valueOf()
    int i2 = 127;
    System.out.print(i1 == i2); // 只要有基本数据类型，判断的是值是否相等（即：转换为基本数据类型相比较）
}

9.2 String 相关题

• String.intern方法解读
  

package com.str_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class String02 {
    public static void main(String[] args) {
        String a = "a"; // 在常量池中创建"a"对象
        String b = "b"; // 在常量池中创建"b"对象
        // 解读
        // 1. 先 创建一个 StringBuilder sb = new StringBuilder();
        // 2. 执行 sb.append("a");
        // 3. sb.append("abc");
        // 4. String c = sb.toString()
        // 最后其实 c 指向堆中的对象（String），value[] -> 池中 "ab"
        String c = a + b;
        String d = "ab";
        System.out.println(c == d); // false
    }
}