详解Java中的String类

---

一、String类的概述

String：字符串，使用一对“”引起来表示

1. String声明为final的，不可被继承
2. String实现了Serializable接口：表示字符串是支持序列化的
   String实现了Comparable接口：表示String可以比较大小
3. String内部定义了final char[] value 用于存储字符串数据
4. String代表不可变的字符序列，简称：不可变性
   体现：
   ①当对字符串进行重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
   ②当对现有的字符串进行连续操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
   ③当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值
5. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中
6. 字符串常量池中是不会存储相同内容的字符串的

import org.junit.Test;

public class StringTest {
    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        s1 = "hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值

        System.out.println(s1);//helo
        System.out.println(s2);//abc

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);

        String s4 = "abc";
        String s5 = s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);
    }
}

输出结果为：

二、String实例化的方式

方式一：通过字面量定义的方式
方式二：通过new+构造器的方式

public void Test2(){
	//通过字面量定义的方式：此时的s1和s2的数据qwe声明在方法区中的字符串常量池中
	String s1 = "qwe";
	String s2 = "qwe";
	//通过new+构造器的方式：此时的s3,s4保存的是地址值，是数据在堆空间开辟空间以后对应的地址值
	String s3 = new String("qwe");
	String s4 = new String("qwe");
	
	System.out.println(s1 == s2);//true
	System.out.println(s1 == s3);//false
	System.out.println(s1 == s4);//false
	System.out.println(s3 == s4);//false
}

例题：用String s = new String(“abc”)方式创建对象，在内存中创建了几个对象？
——两个：一个是堆空间的new结构，另一个是char[]对应的常量池中的数据“abc”

三、String的拼接

1. 常量与常量拼接结果在常量池，且常量池中不会存在相同内容的常量
2. 只要其中有一个变量，结果就在堆中
3. 如果拼接的结果调用intern()方法，返回值就在常量池中

public void Test3(){
        String s1 = "hello";
        String s2 = "world";
        String s3 = "hello"+"world";
        String s4 = s1 + "world";
        String s5 = s1 + s2;
        String s6 = (s1+s2).intern();
        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s4 == s5);//false
        System.out.println(s3 == s6);//true
    }

四、String的常用方法

五、String与基本数据类型的转换

六、String与char[]、byte[]之间的转换

String与char[]之间的转换
String→char[]：调用String的toCharArray()
char[]→String：调用String的构造器

String与byte[]之间的转换

编码：String→byte[]：调用String的getBytes()
解码：byte[]→String：调用String的构造器

编码：字符串→字节（看得懂→看不懂的二进制数据）
解码：编码的逆过程，字节→字符串（看不懂的二进制数据→看得懂）

说明：解码时，要求解码使用的字符集必须与编码使用的字符集一致，否则会出现乱码

七、StringBuffer、StringBuilder的介绍

String、StringBuffer、StringBuilder三者的异同
String：不可变的字符序列：底层使用char[]存储
StringBuffer：可变的字符序列：线程是安全的，但是效率低，底层使用char[]存储
StringBuilder：可变的字符序列：JDK5.0新增的，线程是不安全的，但是效率高，底层使用char[]存储

源码分析:

String str = new String();

上述代码的底层实际上是帮我们new了一个char型数组，长度为0（char[] value = new char[0]）

String str = new String("abc");

上述代码的底层实际上是new了一个char型数组char[]，长度为3，有三个元素a、b、c，（char[] value = new char[]{'a','b','c'}）

StringBuffer sb1 = new StringBuffer();
sb.append('a');
sb.append('b');

上述代码的底层实际上是创建了一个长度为16的数组，（char[] value = new char[16]）因为源码是这么写的，append就是向数组里添加元素。sb.append(‘a’)相当于value[0]=‘a’，sb.append(‘b’)相当于value[1]=‘b’

StringBuffer sb2 = new StringBuffer(“abc”);

上述代码的底层实际上是创建了一个char型数组，长度为abc的长度3 加上16，（char[] value = new char[“abc”.length()+16]）

问题一：这时System.out.println(sb2.length)为多少？
16？19？3？——答案是3 ，有几个元素就返回几，这就好像你造了一个长度为5的数组，但是里面只有两个元素，你输出的长度当然是只有两个元素

问题二：扩容问题：如果要添加的数据底层数组装不下了，那就需要扩容底层的数组。默认情况下，扩容为原来的两倍再加2，同时将原有的数组中的元素复制到新的数组中去。

StringBuffer、StringBuilder常用的方法

StringBuffer和StringBuilder用法一致

String、StringBuffer、StringBuilder的效率对比
从高到低排列：StringBuilder＞StringBuffer＞String