浅谈Java中的String,StringBuffer与StringBuilder

String,StringBuffer与StringBuilder类是我们比较常用的三个类，弄懂它们也是很重的，下面是我学习之后对这三个类的总结，欢迎评论纠错

String类

用法：
1、String对象用于保存字符串，也就是一组字符序列
2、字符串常量（如 "Tom" ）对象是用双引号括起的字符序列。例如：“你好”、“12.2”等
3、字符串的字符使用的是Unicode字符编码，一个字符占2个字节
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 startindex,int count):
String s5 = new String(byte[] b);
5、下图中展示了String类实现的3个接口，其中实现Serializable，说明String可以串行化，实现了Comparable，说明String对象可以比较大小
6、String是final类，不能被其他的类继承
7、在源码中，String类有属性 private final char value[]，用来存放字符串内容，也是final类型，则这个value不能指向新的地址，但是单个字符内容可以变化。
例如：

package string;

public class String_01 {
    public static void main(String[] args) {
        String name="nihao";
        final char[] value = {'1','2','3'};
        char[] value_1={'a','b','c'};
        value[0] = 'A';
        System.out.println(value);
        // value =value_1;   (这样写就会出现 Cannot assign a value to final variable 'value')
    }
}

输出结果：

A23

创建String类的方式

方式：
1、直接赋值：String str="abc";
2、调用构造器：String str= new String("abc");
解释：
方法1 ：先从常量池中查看是否有“abc”数据空间，如果有，直接指向；如果没有则重新创建，然后指向。str最终指向的是常量池的空间地址
方法2 ：先在堆中创建空间，里面维护了一个value属性，指向常量池的“abc”空间。如果常量池没有”abc“ ，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。
例如：

package string;
public class String_02 {
    public static void main(String[] args) {
        String str1 = "ABC"; //指向常量池中的“ABC”
        String str2 = "ABC";
        System.out.println(str1.equals(str2));
        System.out.println(str1==str2);
    }
}

输出结果：

true
true

注意：
String在调用intern 方法时，如果常量池已经包含一个等于此String 对象的字符串（ 用equals()方法确定 ），则返回常量池中的字符串，否则将此String对象添加到池中，并返回此String对象的引用。
例如：

package string;

public class String_03 {
    public static void main(String[] args) {
        String str1="abc"; //str1指向常量池的“abc”
        String str2= new String("abc");//str2指向堆中对象
        String str3= new String("abc");
        System.out.println(str1.equals(str2));
        System.out.println(str1 == str2);
        System.out.println(str1==str2.intern());
        System.out.println(str1==str2.intern());
        System.out.println();
        System.out.println(str2.equals(str3));
        System.out.println(str2 == str3);
        System.out.println(str2==str3.intern());
        System.out.println(str2==str3.intern());
    }
}

输出结果：

true
false
true
true

true
false
false
false

package string;

public class String_04 {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "abc";
        //首先创建一个 StringBuilder sb = new StringBuilder();
        //然后执行 sb.append("hello");
        //之后 String str =sb.toString();
        //最后 str指向堆中的对象（String） value[]指向 常量池中 “helloabc”
        String str = str1 + str2;
        String s1 = new String("helloabc");
        String s2 = "helloabc";
        String s = "hello" + "abc"; //s指向常量池
        //直接看对象指向哪里？
        System.out.println("是否s1==str？ "+(s1==str));
        System.out.println("是否s2==str？ "+(s2==str));
        System.out.println("是否s==s2？ "+ (s==s2));
    }
}

输出结果

是否s1==str？ false
是否s2==str？ false
是否s==s2？ true

StringBuffer

用法：
1、java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。很多方法与String相同，但StringBuffer是可变长度的。
2、StringBuffer是一个容器
3、下图中 可以看出 StringBuffer 的直接父类是AbstractStringBuffer，StringBuffer 实现了Serializable，即StringBuffer的对象可以串行化
4、在父类中 AbstractStringBuffer类 具有属性 char[] value,不是final类型，该value数组存放字符串内容，因此存放在堆中
5、StringBuffer 是一个final类，不能被继承
6、StringBuffer常用的几个构造器
StringBuffer s1=new StringBuffer(); （ 创建一个大小为16字节的char[] ,用于存放字符内容 ）
StringBuffer s2=new StringBuffer(CharSequence seq);
StringBuffer s3=new StringBuffer(int capacity);（可以指定char[]大小）
StringBuffer s4=new(String str);(通过给一个String创建StringBuffer，char[]大小就是str.length+16)
7、常用的StringBuffer类中的方法
例如：

package stringbuffer;

public class StringBuffer_03 {
    public static void main(String[] args) {
        StringBuffer str =new StringBuffer("nihao");
        str.append(",");
        str.append("Liangsen");
        str.append("Shuanyu").append(100).append(true).append(10.5);
        System.out.println(str);

        System.out.println();
        //删除索引为 >=start && <end 处的字符
        str.delete(11,14);
        System.out.println(str);

        System.out.println();
        //使用Tom替换索引 <=1 && >11 的字符
        str.replace(1,11,"Tom");
        System.out.println(str);

        System.out.println();
        //查找指定的子串在字符第一次出现的索引，如果找不到返回-1
        int indexOf =str.indexOf("Shuanyu");
        System.out.println(indexOf);

        System.out.println();
        //在索引为9的位置插入 Tim
        str.insert(4,"Tim");
        System.out.println(str);
        
        System.out.println(str.length());
    }
}

输出结果：

nihao,LiangsenShuanyu100true10.5

nihao,LiangShuanyu100true10.5

nTomShuanyu100true10.5

4

nTomTimShuanyu100true10.5
25

String VS StringBuffer

区别：
1、String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率低
2、StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高
两者转换：
1、String转为StringBuffer：方法1使用构造器，返回的是StringBuffer，对str本身没有影响。方式2使用的是append方法
2、StringBuffer转换为String：方法1使用StringBuffer提供的toString方法，方法2使用构造器。
例如

package stringbuffer;
public class StringBuffer_02 {
    public static void main(String[] args) {
    	//String转为StringBuffer
        String str="hello Alin";
        StringBuffer stringBuffer = new StringBuffer(str);
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 =stringBuffer1.append(str);

        //StringBuffer转换为String
        StringBuffer stringBuffer2 = new StringBuffer("nihao");
        String s= stringBuffer2.toString();
        String s1=new String( stringBuffer2);
    }
}

StringBuilder

用法：
1、StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但是不保证同步（StringBuilder不是线程安全）。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可以，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快
2、在·StringBuilder上的主要操作append和insert方法，可重载这些方法，以接受任意类型的数据。
3、StringBuilder和StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样
4、StringBuilder是final类型，不能被继承
5、Stringbuilder继承了AbstractStringBuilder，其属性 char[] value，最终的内容都是存到value（堆中）
6、实现了Serializable接口，说明StringBuilder对象可以串行化。
7、StringBuilder的方法，没有做互斥处理，即没有synchronized关键字，因此在单线程的情况下使用

String VS StringBuffer VS StringBuilder

1、StringBuilder和StringBuffer非常相似，均带表可变的字符序列，而且方法也是一样的
2、String：不可变字符序列，效率低，但是复用率高
3、StringBuffer：可变字符序列、效率较高（增删）、线程安全
4、StringBuilder：可变字符序列、效率最高、线程不安全
5、String使用注意说明：
String s ="a"; //创建了一个字符串
s +="b"; //实际上原来的“a”字符串对象已经丢弃了，现在又产生了一个字符串s +="b"（也就是“ab”）。如果多次执行这些改变字符串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序性能，最后如果我们对String做大量的修改，不要你使用String
例如：

package stringbuilder;

public class String_VS_StringBuffer_VS_StringBuilder {
    public static void main(String[] args) {
        String str="";
        StringBuffer strbuf = new StringBuffer("");
        StringBuilder strbui = new StringBuilder("");

        long startTime=0L;
        long endTime=0L;

       startTime=System.currentTimeMillis();
       for (int i=0;i<100000;i++){
           strbuf.append(String.valueOf(i));
       }
       endTime=System.currentTimeMillis();
       System.out.println("Stringbuffer所执行的时间："+(endTime-startTime));

        startTime=System.currentTimeMillis();
        for (int i=0;i<100000;i++){
            strbui.append(String.valueOf(i));
        }
        endTime=System.currentTimeMillis();
        System.out.println("StringBuilder所执行的时间："+(endTime-startTime));

        startTime=System.currentTimeMillis();
        for (int i=0;i<100000;i++){
            str += i;
        }
        endTime=System.currentTimeMillis();
        System.out.println("String所执行的时间："+(endTime-startTime));

    }
}

输出结果：

Stringbuffer所执行的时间：10
StringBuilder所执行的时间：4
String所执行的时间：2042

关于String，StringBuffer，StringBuilder的选择

1、如果字符串存在大量的修改，一般可以使用StringBuffer或StringBuilder
2、如果字符串存在大量的修改并且在单线程的情况下，一般选择使用StringBuilder
3、如果字符串存在大量的修改并且在多线程的情况下，一般选择使用StringBuffer
4、如果我们的字符串很少修改，被多个对象引用，一般选择使用String