第十三章 常用类（包装类和 String 相关类）

一、包装类

1. 包装类的分类

（1）针对八种基本数据类型相应的引用类型—包装类
（2）有了类的特点，就可以调用类中的方法。

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

（1）jdk5 前的手动装箱和拆箱方式

public class Test {
 
    public static void main(String[] args) {
 
        int n1 = 100;
        //jdk5 前的手动装箱和拆箱方式
        //装箱
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
 
        //拆箱
        int i = integer.intValue();
    }
}

（2）jdk5 及以后的自动装箱和拆箱方式

public class Test {
 
    public static void main(String[] args) {
 
        int n1 = 100;
        //jdk5 及以后的自动装箱和拆箱方式
        //装箱
        Integer integer = n1;// 底层是 Integer.valueOf()
 
        //拆箱
        int i = integer;// 底层是 intValue()
    }
}

3. 包装类和 String 类型的相互转换

public class Test {
 
    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";
        //方式 1
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        //方式 2
        Integer i3 = new Integer(str4);//构造器
    }
}

4. Integer 类和 Character 类的常用方法

public class Test {
 
    public static void main(String[] args) {
 
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值
        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写
        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写
    }
}

二、String 类（P466）

1. String 类的理解和创建对象

（1）String 对象用于保存字符串，也就是一组字符序列。
（2）字符串常量 对象是用双引号括起的字符序列。
（3）字符串的字符使用 Unicode 字符编码，一个字符（不区分字母还是汉字）占两个字节。
（4）String类 实现了接口 Serializable【String 可以串行化：可以在网络传输】。
（5）String类 实现了接口 Comparable 【String 对象可以比较大小】。
（6）String 是 final 类，不能被其他的类继承。
（7）String 有属性 private final char value[]：用于存放字符串内容。
（8）一定要注意：value 是一个 final 类型，不可以修改【即 value 不能指向新的地址，但是单个字符内容是可以变化】。
（9）字符串常用构造器

public class Test {
 
    public static void main(String[] args) {
 
        String s1 = new String();
 
        //public String(String original)
        String s2 = new String("字符串");
 
        //public String(char value[])
        char[] data = {'a','b','c'};
        String s3 = new String(data);
 
        //public String(char value[], int offset, int count) 
        String s4 = new String(data,1,2);
 
    }
}

2. 两种创建 String 对象的区别

方式一：直接赋值 String s= “hsp” ;
方式二：调用构造器 String s2 = new String(“hsp”）;
（1）方式一：先从常量池查看是否有 “hsp” 数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s 最终指向的是常量池的空间地址。
（2）方式二：先在堆中创建空间，里面维护了 value 属性，指向常量池的 hsp 空间。如果常量池没有“hsp”，重新创建，如果有，直接通过 value 指向。最终指向的是堆中的空间地址。
（3）画出两种方式的内存分布图

3. 字符串的特性

（1）String 是一个 final 类，代表不可变的字符序列。
（2）字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。

public class Demo {

    public static void main(String[] args) {
        // 编译器自动优化为 String str = "helloabc";
        String str1 = "hello" + "abc";

        String s1 = "hello";
        String s2 = "abc";
        // 1，先创建一个 StringBuilder sb = StringBuilder()
        // 2. 执行 sb.append("hello"）；
        // 3. sb.append("abc”)；
        // 4. String str = sb.tostring()
        // 最后其实 str -> 堆中的对象(String) value[] -> 池中"helloabc"
        String str2 = s1 + s2;

        String s3 = "helloabc"; // s3 -> 池中"helloabc"
        System.out.println(str2 == s3); // false
    }
}

重要规则：
String c1 = “ab” + “cd”；常量相加，看的是池。
String c2 = a +b；变量相加，是在堆中。

4. String 类的常见方法

String类 是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此 java 设计者还提供了 SrimgBuildler 和 StringBuffer 来增强 String 的功能并提高效率。

equals //区分大小写，判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length //获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1
lastlndexOf //获取字符在字符串中最后1次出现的索引索引从0开始，如找不到，返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt //获取某索引处的字符，注意不能使用Strtindex]这种方式

toUpperCase //字符串转换成大写
toLowerCase //字符串转换成小写
concat //拼接字符串
replace //替换字符串中的字符
split //分割字符串。对于某些特殊分割字符，我们需要转义符 \
toCharArray //转换成字符数组
compareTo //比较两个字符串的大小。从第一个字符开始比较，如果不同就相减。

public class Demo {

    public static void main(String[] args) {
        String str1 = "cbaa";
        String str2 = "cbaa";
        System.out.println(str1.compareTo(str2));// 0
        String str3 = "aba";
        System.out.println(str1.compareTo(str3));// 2 c-a
        String str4 = "cfa";
        System.out.println(str1.compareTo(str4));// -4 b-f
        String str5 = "cba";
        System.out.println(str1.compareTo(str5));// 1 str1.len - str5.len = 1
    }
}

format //格式字符串

public class Demo {

    public static void main(String[] args) {
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';

        //1. %s、%d、%.2f、%c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位，并且进行四舍五入的处理
        //6. %c 使用 char类型米替换
        String formatstr = "我的姓名是 %s 年龄是 %d 成绩是 %.2f 性别是 %c.希望大家喜欢我！";
        String info2 = String.format(formatstr, name, age, score, gender);
        System.out.println(info2);
    }
}

三、StringBuffer 类（P475）

【java.lang.StringBuffer】代表可变的字符序列，可以对字符串内容进行增删。
很多方法与 String 相同，但 StringBuffer 是可变长度的。
StringBuffer 是一个容器。

（1）StringBuffer 的直接父类是 AbstractStringBuilder。
（2）StringBuffer 实现了 Serializable，即 StringBuffer 的对象可以串行化
（3）在父类中 AbstractStringBuilder 有属性 char[] value，不是final。该 value数组 存放字符串内容，因此存放在堆中的。
（4）StringBuffer 是一个 final 类，不能被继承。

1. String VS StringBuffer

（1）String 保存的是字符串常量，里面的值不能更改。每次 String 类的更新实际上就是更改地址，效率较低。// private final char value[]
（2）StringBuffer 保存的是字符串变量，里面的值可以更改，每次 StringBuffer 的更新实际上可以更新内容，不用更新地址，效率较高。 // char value 【这个放在堆】

2. StringBuffer 构造方法

3. String 与 StringBuffer 转换

public class Demo {

    public static void main(String[] args) {
        // String -> StringBuffer
        String str = "hello";
        // 方式1
        StringBuffer sb1 = new StringBuffer(str);
        // 方式2
        StringBuffer sb2 = new StringBuffer();
        sb2.append(str);

        // StringBuffer -> String
        // 方式1
        String str1 = sb1.toString();
        // 方式2
        String str2 = new String(sb1);
    }
}

4. StringBuffer类 常见方法

（1）增：append
（2）删：delete（start,end）
（3）改：replace(startend,string）
（4）查：indexof【查找子字符串在字符串第一次出现的索引，如果找不到返回 -1】
（5）插：insert
（6）length：获取长度

public class Demo {

    public static void main(String[] args) {
        // 删除索引为 >=start && 
        StringBuffer sb1 = new StringBuffer("hello,Jack.Hi");
        // 5:,
        // 9:k
        sb1.delete(5,9);
        System.out.println(sb1);    // hellok.Hi

        // 改：替换索引6-10的字符，包含6，不包含10
        StringBuffer sb2 = new StringBuffer("hello,Jack.Hi");
        // 6:J
        // 10:.
        sb2.replace(6,10,"Tom");
        System.out.println(sb2);    // hello,Tom.Hi

        // 插：在索引6的位置，插入Tom。原来索引为6的内容自动后移
        StringBuffer sb3 = new StringBuffer("hello,Jack.Hi");
        // 6:J
        sb3.insert(6,"Tom/");
        System.out.println(sb3);    // hello,Tom/Jack.Hi
    }
}

四、StringBuilder 类（P479）

（1）一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。（StringBuilder不是线程安全）。该类被设计用作 StringBuffer 的一个简易替换，用在字特串缓种区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
（2）在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
（3）StringBuilder 和 StringBuffer 均代表可变的字符序列，方法是一样的，所以使用和StringBuffer 一样。

StringBuilder 的方法，没有做互斥的处理，即没有 synchronized 关键字，因此在单线程的情况下使用 StringBuilder。

1. String、StringBuffer 和 StringBuilder 的比较

（1）StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样。
（2）String：不可变字符序列，效率低，但是复用率高。
（3）StringBuffer：可变字符序列、效率较高（增删）、线程安全。
（4）StringBuilder：可变字符序列、效率最高、线程不安全。