一、包装类

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）字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

        // 编译器自动优化为 String str = "helloabc";
        String str = "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 str = s1 + s2;

        String s3 = "helloabc"; // s3 -> 池中"helloabc"
        System.out.println(str == 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        //比较两个字符串的大小。从第一个字符开始比较，如果不同就相减。

        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        //格式字符串

        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 转换

        // 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）

        // 删除索引为 >=start && <end 处的字符
        StringBuffer sb = new StringBuffer("hello,Jack.Hi");
        // 5:,
        // 9:k
        sb.delete(5,9);
        System.out.println(sb);    // hellok.Hi

（3）改：replace(startend,string）

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

（4）查：indexof【查找子字符串在字符串第一次出现的索引，如果找不到返回 -1】

（5）插：insert

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

（6）length：获取长度

四、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：可变字符序列、效率最高、线程不安全