Java复习知识点十五:包装类、String、StringBuffer 和 StringBuilder类的使用

1、包装类

八大Wrapper类：

Byte、Short、Integer、Long、Float、Double、Char、Boolean

1.1装箱和拆箱

• 装箱：基本数据类型 --> 包装类型
• 拆箱：包装类型 --> 基本数据类型

jdk5 前是手动装箱和拆箱方式

jdk5 以后（含jdk5）是自动装箱和自动拆箱方式。底层使用的的是valueOf方法。如：Integer.valueOf

手动装箱：

//手动装箱 int --> Integer
int n1 = 100;
Integer integer01 = new Integer(n1);
Integer integer02 = Integer.valueOf(n1);

//手动拆箱
//Integer --> int
int i = integer01.intValue();

自动装箱：

//jdk5 之后，就可以自动装箱和拆箱了
int n2 = 200;
//自动装箱
Integer integer03 = n2; //底层使用的是 Integer.valueOf(n2);
//自动拆箱
int i1 = integer03; //底层使用的是intValue()方法

1.2 包装类与String转换

以Integer为例：

Integer --> String:

Integer i2 = 201;
//方式1
String str = i2 + "";
//方式2
String str2 = i2.toString();
//方式3
String str3 = String.valueOf(i2);

valueOf方法，一般是Java中把基本类型转化为对象类型的方法；返回对象的值；

String --> Integer：

//String --> Integer
String str4 = "1245";
Integer i3 = Integer.parseInt(str4);//使用了自动装箱
Integer i4 = new Integer(str4);//构造器

1.3 包装类常用方法

1.4 Integer细节

只要是new出来的 就不是同一个对象，进而地址不同

Ingteger i = new Integer(1);
Ingteger j = new Integer(1);
System.out.println(i == j);//False
//只要是new出来的 就不是同一个对象

阅读源码发现Integer.valueOf()在-128~127范围内的值，他会从IntegerCache类的成员cache[]中获取，直接返回

Ingteger m = 1;//底层使用的是Integer.valueOf();Integer.valueOf();
Ingteger n = 1;//底层使用的是Integer.valueOf();Integer.valueOf();
//阅读源码发现Integer.valueOf()在
System.out.println(i == j);//True

不在范围内，会重新new

lnteger x = 128;//底层Integer.valueOf(1);
lnteger y = 128;//底层Integer.valueOf(1);
System.out.println(x == y);//False
//不在范围内，会重新new

Integer.valueOf()源码:

IntegerCache类源码：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

2、String类

2.1 两种创建方式

• 方式一：创建字符串常量对象：String s = “jack”；
• 方式二：创建String对象：String s2 = new String(“jack”);

1. 方式一：先从常量池查看是否有"jack"数据空间，如果有，直接指向;如果没有则重新创建，然后指向。S最终指向的是常量池的空间地址
2. 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的jack空间。如果常量池没有"jack"，重新创建,如果有，直接通过value指向。最终指向的是堆中的空间地址。

内存图：

2.2 String使用细节

String类结构：

1. String对象用于保存字符串，也就是一组字符序列

2. 字符串常量对象使用双引号括起的字符序列。例如“你好”、“12.34”；

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 startlndex,int count)
   

5. String类实现了Serializable接口【可串行化，可在网络间传输】

6. String类实现了Compareable接口【对象间可相互比较】

7. String类是fianl类，不能被继承

8. String 有属性 private final char value[]；用于存放字符数组

9. 一定要注意：value是一个final修饰的字符数组，不可修改【不可指向新的地址】

10. intern（）方法是返回常量池中的地址

2.3 String特性

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

创建了两个字符串常量对象

创建了一个字符串常量对象

String a = "hello"+"abc";//底层会优化,判断创建的常量池对象是否有引用指向，等价于 String a = "helloabc";
//创建了几个对象？
//答案：1个对象

创建了三个对象，两个字符串常量对象 （常量池），一个String对象 （堆）

String a = "hello";
String b = "world";
//1. 先创建一个StringBuilder sb = new  StringBuilder();
//2. 执行 sb.append("hello")方法
//3. 执行 sb.append("world")方法
//4. 转换为String对象：String s = sb.toString();
String c = a + b;
//toString方法中是，return new String();方式返回的字符串对象

StringBuilder类的toString方法：

2.4 String类的常用方法

• toUpperCase 转换成大写
• toLowerCase 转换成小写
• concat 拼接字符串
• replace 替换字符串中的字符
• split 分割字符串
• toCharArray 转换成字符数组
• compareTo 比较字符串大小
• fomat 格式化字符串

3、 StringBuffer

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

3.1 StringBuffer介绍：

• java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删。

• 很多方法与String相同，但StringBuffer是可变长度的。

• StringBuffer是一个容器。
  

3.2 使用细节：

1. StringBuffer的直接父类是AbstractStringBuilder
2. 父类AbstractStringBuilder中有char[] value属性，用来存放字符串内容【不是final】，因此是存放在堆中的
3. StringBuffer类是final修饰的，不可被继承

StringBuffer vs String：

1. String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址(创建新的对象)，效率较低 【private final char value[]】
2. StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址(创建新的对象)【数组需要扩容时，会更改地址】,效率较高【char[] value】这个存放在堆.

3.3 StringBuffer的构造器：

• new StringBuffer( ) 使用super(16），让父类初始化长度为16的字符数组

• 

• new StringBuffer(100) 通过构造器指定char[]的大小

• 

• new StringBuffer(“ hello ”) 通过给一个String创建一个StringBuffer char[]大小就是 String的长度+ 16

• 

3.4 String与StringBuffer的转换：

//String --> StringBuffer

//方式1:使用构造器
//注意：返回的才是StringBuffer对象，对str本身没有任何影响
String str = "hello";
StringBuffer s = new StringBuffer(str);

//方式2：使用append方法
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str);

//StringBuffer --> String

StringBuffer stringBuffer1 = new StringBuffer("jack");
//方式1： 使用toString方法
String s1 = stringBuffer1.toString();
//方式2： 使用String构造器
String s2 = new String(stringBuffer1);

3.6 常用方法

• 增 append方法
• 删 delete方法
• 改 replace方法
• 查 indexOf方法
• 插 insert方法
• 获取长度 length方法

3.7 练习

4、StringBuilder

• 一个可变的字符序列。此类提供一个与StringBuffer兼容的 API但不保证同步(线程不安全)。该类被设计用作StringBuffer的简单替换，用在字符缓冲区被单个线程使用的时候。如果可能，建议优先采用该类。因为在多数实现中，它比StringBuffer要快。

• 在StringBuilder上的主要操作是append和 insert方法,可重载这些方法,以接受任意类型的数据。

类结构与StringBuffer一致

1. StringBuilder继承AbstractStringBuilder
2. 实现了Serializable接口，可以串行化（对象可以在网络中传输，也可以保存在文件中）
3. StringBuilder是final类，不能被继承
4. StringBuilder对象的字符序列仍然是存放在欺父类AbstractStringBuilder的属性 char[] value中
5. StringBuilder的方法没有 做 互斥的处理，即没有synchronized关键字修饰

5、String、StringBuffer和StringBuilder的比较

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

String使用注意说明:

string s=“a”; //创建了一个字符串
s +=“b”; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能