【JAVA】String、StringBuilder、StringBuffer三者的区别

 

              String、StringBuilder、StringBuffer三者的联系与区别

这个问题在面试中经常被问到，现在浅谈一下自己对于这三者的理解

联系

（1）这三者都属于Java.lang包

（2）都是final类

 

简单区别

 

【1】String

（1）字符串常量，一旦被指定初值，则不能被修改

（2）使用字符数组来存储字符串

问题：String好像可以修改它的值啊

package day0809;

public class TestString {

    public static void main(String args[]){
      String s1="abc";
      s1+="d";
        System.out.println(s1);
    }
}

输出：

看似是String可以修改值，但是JVM欺骗了我们，底层使用StringBuffer.append()操作再复制给新的String对象

 

【2】StringBuilder

 

（1）字符串变量，可自由操作赋值

（2）线程不安全，所有的方法都没用synchronized修饰

 

【3】StringBuffer

（1）字符串变量，可自由操作赋值

（2）线程安全，大部分方法和StringBuilder中的方法类似，但用了synchronized修饰

 

性能区别

废话不多说，直接上代码测试

执行10万次加“a”的操作

package day0809;

public class TestString {
    public static void testString() {
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 100000; i++) {
            s += "a";
        }
        long end = System.currentTimeMillis();
        System.out.println("String耗时：" + (end - start));
    }

    public static void testStringBuilder() {
        long start = System.currentTimeMillis();
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            s.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder耗时：" + (end - start));
    }

    public static void testStringBuffer() {
        long start = System.currentTimeMillis();
        StringBuffer s = new StringBuffer();
        for (int i = 0; i < 100000; i++) {
            s.append("a");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer耗时：" + (end - start));
    }

    public static void main(String args[]) {
        testString();
        testStringBuilder();
        testStringBuffer();
    }
}

耗时如下

此时性能的差异就完全体现出来了

String由于是不可变类，执行加“a”的操作，不断实例化新的对象，然后又不断发生GC，耗时是非常严重的

StringBuilder和StringBuffer在10万条操作下的耗时差不多，单线程下，synchronized没有起到作用

 

大量的案例证明

性能：StringBuilder>StringBuffer>String

 

多线程下

由于StringBuilder没有同步方法，因此StringBuilder是线程不安全的。

下面在多线程的情况下测试效果

调用他们的append方法，每个线程给StringBuilder对象新增“12345”字符串，循环生成5个这样线程

如果是线程安全的，应该顺序输出123451234512345....

先是StringBuilder

package day0809;

public class TestStringThread {
    static class MyThread implements Runnable {
        private StringBuilder sb;

        public MyThread(StringBuilder sb) {
            this.sb = sb;
        }

        @Override
        public void run() {
            for (int i = 1; i <= 5; i++) {
                sb.append(i);
            }
            System.out.print(sb);
        }
    }


    public static void testStringBuilder() throws InterruptedException {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            new Thread(new MyThread(sb)).start();
        }
    }


    public static void main(String args[]) throws InterruptedException {
        testStringBuilder();
    }

}

输出

第一组数据就不符合“12345”的顺序，因此StringBuilder是线程不安全的

现在测试StringBuffer

只要把上述把StringBuilder换成StringBuffer即可

输出

可以看得出，StringBuffer是线程安全的

 

三者的使用场景

【1】String多使用于数据量比较小，操作比较少的情况

【2】StringBuilder多使用于单线程，数据量比较大的情况下

【3】StringBuffer多使用于多线程，数据量比较大的情况下

现实编程中，应根据实际情况灵活进行选择。