理解String、StringBuffer和StringBuilder之间的区别

目录

1、String 类的特性

2、创建字符串的基本方式：

3、理解String的不可变性（重点理解）

4、字符串的不可变性（重点）

5、字符串的比较相等

6、字符与字符串的相互转换（String与char[]之间相互转换）（重点）

8、字节与字符串（String与byte[]之间相互转换）

9、字符串的常见操作

10、StringBuilder和StringBuffer（重点理解）

---

 

1、String 类的特性

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

1. String是被final修饰的类，不能被继承，不存在子类，这样的话就可以保证所有使用JDK的人，大家用到的String类仅此一个，大家都相同
2. String实现了Serializable和Comparable接口，表示String支持序列化和可以比较大小；
3. String底层是通过char[]字符数组实现的，并且被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性

4. 任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。

2、创建字符串的基本方式：

方式一：直接赋值（常用）
方式二:通过构造方法产生对象
方式三:通过字符数组产生对象
方式四:通过String的静态方法valueOf(任意数据类型) =>转为字符串（常用）

//方式一：直接赋值法（常用） 
    String str1 = "hello world"; 

//方式二：通过构造方法产生字符串对象
    String str2 = new String("hello world");

//方式三：字符数组产生对象
    char[] data = {'a','b','c'};
//将字符数组复制给字符串对象
    String str3 = new String(data);

// 方式四：通过String类的静态方法转为字符串
    String str4 = String.valueOf(10);

3、理解String的不可变性（重点理解）

1. 字符串常量池

字面量：直接写出来的数值就是字面量

String类是引用类型，当通过直接赋值（字面量方式）产生字符串对象时，JVM会维护一 个字符串的常量池，若该对象在堆中还不存在，则会产生一个新的字符串对象加入字符串的常量池中，此时新的的字符串存储在方法区的字符串常量池中，（2）当继续使用直接赋值法产生字符串对象时，JVM发现该引用指向的字符串内容在常量池中已经存在，则不会产生新的字符串对象，而是指向已有对象，（在字符串常量池中不会存储相同内容的字符串）此时的字符串存储在方法区的字符串常量池中，并且在字符串常量池中不会存储相同内容的字符串。

1.1 两种实例化方式对比：

a. 通过字直接赋值（面量方式）为字符串赋值时，此时的字符串存储在方法区的字符串常量池中；

//直接赋值方式的常量池变化     
//字符串的字面量也是字符串的对象
    String str1 = "hello ";
    String str2 = "hello ";
    String str3 = "hello ";

System.out.println(str1 == str2);//ture
System.out.println(str2 == str3);//ture
System.out.println(str1 == str3);//ture

 直接赋值时内存结构图（假设字符串常量池在堆中）：

理解： String str1 = "hello "  ：“hello”是字符串常量，第一次出现，此时常量池中不存在，则新建一个该对象加入常量池中，str2和str3仍然使用直接赋值法产生对象，但是该“hello”已经在常量池中存在,此时并不会新产生对象，而是指向已有对象。

b. 通过new+构造器方式实例化字符串时，字符串对象存储在堆中，但是字符串的值仍然存储在方法区的常量池中。

//new+构造其产生字符串对象
String str1 = new String("hello");
String str2 = new String("hello");
String str3 = new String("hello");

System.out.println(str1 == str2);//false
System.out.println(str2 == str3);//false

  使用构造方法（new）时内存结构图（假设字符串常量池在堆中）：

理解： 使用构造方法时，首先“hello”是字符串常量，第一次出现，会产生一个字符串字面量对象，加入常量池中。其次有new，会在堆中开辟一个新空间，存储字符串对象（值也是“hello”），该对象不会进入常量池中，会在堆中作为一个普通的字符串对象所保存。此时这个此时str1指向的是堆中的普通的字符串对象，str2和str3的字符串常量在常量池中已经存在了，并且也是new产生的，str2和str3指向的都是堆中的普通的字符串对象；

面试题：使用String str=new String(“hello”)方式创建对象，一共创建了几个对象？
有new就有新空间，一共两个字符串对象。一个是使用new创建的对象，存储在堆中；另一个是常量对象"hello"，存储在字符串常量池中

2.手工入池 （inter方法）：

由于在构造方法中，字符串引用指向的是堆中的对象，因此我们调用String类提供的intern方法将当前字符串引用指向的对象保存到字符串常量池中。

a. 若当前常量池中已经存在了该对象,则不再产生新的对象，返回常量池中的String对象

    //第一次出现：“hello”，存放在常量池中，并在堆中也会产生值为“hello”的字符串对象
    String str1 = new String("hello");
    str1.intern(); // 常量池中已经存在“hello”，所以不会产生新的对象
    String str2 = "hello"; //"hello"字面量已经在常量池中,引用指向常量池中字符串对象

    System.out.println(str1 == str2);//false

    String str1 = new String("hello");
    str1 = str1.intern();  //返回常量池中字符串对象地址
    String str2 = "hello";

    System.out.println(str1 == str2); //ture

 b.若当前常量池中不存在该对象，则将该对象入池，返回入池后的地址。

 char[] data = new char[] {'a','b','c'};
String str1 = new String(data); //data为字符串数组，所以不入池
//intern方法手动将堆中字符串对象入池操作
 str1.intern(); //str1 并没有重新赋值
 String str2 = "abc";

 System.out.println(str1 == str2); //ture

4、字符串的不可变性（重点）

 所谓的字符串不可变指的是字符串对象的内容不能变，而不是字符串引用不能变。

例一：在字符串赋值时：

        // 2.字符串的字面量也是字符串的对象
    String str = "hello world";
    String str2 = str;
    str = "Hello";

    System.out.println(str == str2); //false

 刚开始字符串str和str2内容相等，都指向字符串常量池中的同一个地址(绿色线），当str值的改变之后，此时str2的值不变还是指向原来的内存地址，但是str会重新分配内存地址进行赋值，如下图所示：

总结1：String字符串具有不可变性，当字符串重新赋值时，不会在原来的内存地址进行修改，而是重新分配新的内存地址进行赋值。

 例二：字符串拼接

   String str = "hello";
   str = str + "world";
   str += "!!!";

   System.out.println(str);  //hello word !!!

总结2：当字符串进行拼接时，也不会在原来的内存地址进行修改，而是重新分配新的内存地址进行赋值

问题： 为何字符串的对象无法修改内容而其他类的对象能修改内容???
字符串其实就是一个字符数组-> char[]. 字符串保存的值实际上在数组中保存。并且在String类中则这个数组是私有的，String类外部无法获取这个数组。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

5、字符串的比较相等

String str1 ="hello";
String str2 ="hello";
//并不是内容相等，只是说明了str1和str2指向了相同的地址空间
System.out.println(str1 == str2); //ture


String str1 = new String("hello");
String str2 = new String("Hello");
//引用保存的是对象的地址空间，str1和str2指向不同的地址空间
System.out.println(str1 == str2); //false

//比较的是对象的值，区分大小写的比较，（常用）
System.out.println( str1.equals(str2) ); //false
//不区分大小写
System.out.println( str1.equalsIgonreCase(str2) ); //ture

6、字符与字符串的相互转换（String与char[]之间相互转换）（重点）

字符串的内部实际上就是使用字符数组来存储的。

char[] ——> String
public String(char value[])// 将字符数组中的所有内容变为字符串
public String (char value[],int offsrt,int count)// 将部分字符数组中的内容变为字符串

String ——> char[]
public char charAt (int index);//取得指定索引位置的字符， 索引从0开
     public char tocharAt();//将字符串变为字符数组返回

char[] ——> String:使用构造方法
char[] ch=new char[]{'a','b','c'};
String str = new String(ch);
System.out.println(str); //abc

String ——> char[] : 调用String的toCharArray方法
String str1 = "hello";
char[] data = str1.toCharArray();//此时产生一个新的字符数组，将字符串的内容复制过去
//data[0] = "H";//String对象不可变！！！
System.out.println(str1); //hello

 如何判断一个字符串的对象是由纯数字组成的?

思路: 将字符串变为字符数组而后判断每一位字符是否是" 0 "~"'9'"之间的内容，若是则为数字

public static void main(String[] args) { 
 String str = "1a23456" ; 
 System.out.println(isNumber(str)? "字符串由数字所组成！" : "字符串中有非数字成员！"); 
 } 

 public static boolean isNumber(String str) { 
 char[] data = str.toCharArray() ; //"1a23456"=>转为字符串处理
 for (int i = 0; i < data.length; i++) { //遍历data中的每个字符，判断是否是数字字符
 if (data[i]<'0' || data[i]>'9') { //
     return false ; 
     } 
 } 
     return true ; 
 }

8、字节与字符串（String与byte[]之间相互转换）

String ——> byte[] 
public byte[] getBytes():将字符数组一字节数组的形式返回。按照指定编码格式转为字节数组
String ——> byte[] 
public String(byte byte[]):字节数组转为字符串

String ——> byte[] : 调用String的getBytes方法
String str="你好中国";
byte[] data = str.getBytes(); //也可以使用指定的字符编码
System.out.println(Arrays.toString(data); //打印数组

byte[] ——> String : 调用String的构造器
byte[] data=new byte[]{'98','99','1','2'};
String str = new String(data); //也可以使用指定的字符编码
System.out.println(str); 

9、字符串的常见操作

1.字符串的比较
public boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：忽略大小写，比较字符串的内容是否相同
public int compareTo(String anotherString)：比较两个字符串的大小

2.字符与字符串的相互转换
char[] ——> String
public String(char value[])// 将字符数组中的所有内容变为字符串
public String (char value[],int offsrt,int count)// 将部分字符数组中的内容变为字符串
String ——> char[]
public char charAt (int index);//取得指定索引位置的字符， 索引从0开
public char tocharAt();//将字符串变为字符数组返回

3.字节与字符串的相互转换
byte[] ——> String 
public byte[] getBytes():将字符数组一字节数组的形式返回。按照指定编码格式转为字节数组
String ——> byte[] 
public String(byte byte[]):字节数组转为字符串

4.字符串查找操作
boolean contains(CharSequence s)：判断子串中是否存在
boolean startsWith(String prefix)：判断字符串是否以指定的字符串开始
boolean endsWith(String suffix)： 判断字符串是否以指定的字符串结束

int indexOf(String str)：返回指定子字符串在当前字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回从指定的索引后，指定子字符串在当前字符串中第一次出现处的索引
int lastIndexOf(String str)：返回指定子字符串在当前字符串中最后一次出现处的索引
int lastIndexOf(String str, int fromIndex)：返回从指定的索引后，指定子字符串在当前字符串中最后一次出现处的索引
boolean startsWith(String prefix, int toffset)：判断字符串在指定索引开始的子字符串是否以指定前缀开始
注：indexOf和lastIndexOf方法如果未查找到指定子字符串时，返回值都为-1。

5.字符串替换操作
String replaceAll(String regex,String repl)：替换当前字符串中指定的所有指定内容
String replaceFirst(String regex,String repl)：替换当前字符串中指定的第一个

6.字符串拆分 split（）
String[] split(String regex)：根据指定的符号拆分当前字符串，然后返回一个String数组
String[] split(String regex，int limit)： 字符串的部分拆分

7.字符串的截取 substring(int index)
String substring(int beginIndex):从指定索引截取
String substring(int beginIndex,int endIndex):截取部分区间，左闭右开 [)

8.其他常用方法
String trim()：去掉字符串中的左右空格，只保留中间空格
String toLowerCase()：将字符串中的所有字符转换为小写
String toUpperCase()：将字符串中的所有字符转换为大写
native String intern()：字符串入池操作
int length()：取字符串长度
boolean isEmpty()：判断是否为空字符串，不是null，而是长度为0
String concat(String str)：将指定字符串连接到此字符串的结尾，等价于用“+”

 IP地址的拆分：

        // 拆分IP地址
        String str = "192.168.1.1";
        String[] data = str.split("\\.");
        // \\为转义字符
        System.out.println(Arrays.toString(data));

10、StringBuilder和StringBuffer（重点理解）

任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。 为了方便字符串的修改，JDK 提供StringBuffer和 StringBuilder类。

1、修改字符串内容（append方法）：在String中使用"+"来进行字符串连接，但若需要频繁进行字符串的拼接，需要使用StringBuilder类的append方法。

public static void main(String[] args) {
    StringBuilder sb = new StringBuilder();
    sb.append("hello");
    sb.append("world");
    sb.append("!!!");
//sb.append("hello").sb.append("world").sb.append("!!!")
    System.out.println(sb);

 }

// 不同拼接方式的比较
        String s1="Hello";
        String s2="World";
        
        String s3="HelloWorld";
        String s4="Hello"+"World";

        String s5=s1+"World";
        String s6="Hello"+s2;
        String s7=s1+s2;

        System.out.println(s3==s4); //true
        System.out.println(s3==s5); //false
        System.out.println(s3==s6); //false
        System.out.println(s3==s7); //false
        System.out.println(s5==s6); //false
        System.out.println(s5==s7); //false
        System.out.println(s6==s7); //false

 (1)Java中有常量优化机制，“Hello"和"World"本身就是字符串常量，所以在编译时，会直接把"Hello"和"World"合并成"HelloWorld"字符串，又因为在执行s3的时候已经在常量池中创建了"HelloWorld”，所以s3==s4。
(2)当变量与字面量或变量与变量进行拼接时，会在堆中创建一个StringBuilde对象，然后使用StringBuilder的append()方法将变量与字面量或变量与变量进行拼接，最后调用toString()方法转成String对象。所以s5、s6、s7指向的都是堆内存中String对象的地址值。

2、StringBuilder 与String的相互转换

//String => StringBuilder

// 使用构造方法,将字符串的字面量变为Stringbuilder类的对象
StringBuilder sb = new  StringBuilder("hello");
//调用append方法，把字符串的内容变为StringBuilder的内容
sb.append("hello");

//StringBuilder => String

String str = sb.toString();
System.out.println();

（1）String => StringBuilder，使用构造方法,将字符串的字面量变为Stringbuilder类的对象或者调用append方法，把字符串的内容变为StringBuilder的内容

（2）StringBuilder => String，使用tostring方法；

3、StringBuffer和StringBuilder中常用的方法：

因为StringBulider类可以修改内容，因此具备一些String类不具备的修改内容的功能，除了拼接append方法外

StringBuffer append(xxx)：拼接字符串
StringBuffer delete(int start,int end)：删除指定范围的内容,左开右闭，[)
StringBuffer insert(int offset, xxx)：在指定位置插入指定的内容
StringBuffer reverse() ：把当前字符序列逆转

 4、面试题：String、StringBuffer和StringBuilder的异同？

 相同点：底层都是通过char数组实现的
不同点：

1. String对象一旦创建，其值是不能修改的，如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer和StringBuilder对象的值是可以被修改的；
2. StringBuffer几乎所有的方法都使用synchronized实现了同步，线程比较安全，在多线程系统中可以保证数据同步，但是效率比较低；而StringBuilder 没有实现同步，线程不安全，在多线程系统中不能使用 StringBuilder，但是效率比较高。
3. 如果我们在实际开发过程中需要对字符串进行频繁的修改，不要使用String，否则会造成内存空间的浪费；当需要考虑线程安全的场景下使用 StringBuffer，如果不需要考虑线程安全，追求效率的场景下可以使用 StringBuilder。