String、StringBuffer和StringBuilder之间的区别和联系

以下转载自：https://blog.csdn.net/weixin_41101173/article/details/79677982

一、Java String 类——String字符串常量

字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

需要注意的是，String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。我们来看一下这张对String操作时内存变化的图：

我们可以看到，初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作，谷歌引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

二、Java StringBuffer 和 StringBuilder 类——StringBuffer字符串变量、StringBuilder字符串变量

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

三者的继承结构

三者的区别：

（1）字符修改上的区别（主要，见上面分析）

（2）初始化上的区别，String可以空赋值，后者不行，报错

①String

StringBuffer s = null;   

StringBuffer s = “abc”;   

②StringBuffer

StringBuffer s = null; //结果警告：Null pointer access: The variable result can only be null at this location

StringBuffer s = new StringBuffer();//StringBuffer对象是一个空的对象

StringBuffer s = new StringBuffer(“abc”);//创建带有内容的StringBuffer对象,对象的内容就是字符串”

小结：（1）如果要操作少量的数据用 String；

（2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；

（3）单线程操作字符串缓冲区下操作大量数据 StringBuilder。

————————————————————我是分割线——————————————————————

三、StringBuilder类在Android中运用示例

（1）上官方文档，StringBuilder，A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.

The principal operations on a StringBuilder are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string builder. The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.

参考网址：https://developer.android.google.cn/reference/java/lang/StringBuilder.html

由上面的官方文档，我们知道以下几点：

（2）上代码，具体实现

new Thread(new Runnable){
    @Override
        public void run(){
        HttpURLConnection connection = null;
        BufferedReader reader = null;
        try{
                URL url = new URL("http://www.baidu.com");
                connection = (HttpURLConnection)url.openConnection();
                connnection.setRequestMethod("GET");
                InputStream in = connection.getInputStream();
                //下面对获取到的输入流进行读取
                reader= new BufferedReader(new InputStreamReader(in));
                StringBuilder response = new( StringBuilder() );
                String line;
                While ((line =reader.readLine())!= null ){
                    response.appen    d(line）) ;
                }
            showResponse( reponse.toString() )
        }
    }......

}

上段代码模拟的是向百度网请求数据，然后对网站返回的数据流进行读取，最终应用StringBuilder()进行字符串数据的读取和显示。

 总结：末尾总是有福利，三者区别可参照下表：

以下截选自：https://blog.csdn.net/u011489043/article/details/68488459

如果程序对附加字符串的需求很频繁，不建议使用+来进行字符串的串联。可以考虑使用java.lang.StringBuilder 类，使用这个类所产生的对象默认会有16个字符的容量（capacity），您也可以自行指定初始容量。如果附加的字符超出可容纳的长度，则StringBuilder 对象会自动增加容量以容纳被附加的字符。如果有频繁作字符串附加的需求，使用StringBuilder 类能使效率大大提高。

  见下面测试案例：

public class testStringBuilder {

    public static void main(String[] args) {
        String text = "";

        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++)
            text = text + i;
        long endTime = System.currentTimeMillis();
        System.out.println("普通字符串直接相加的执行时间：" + (endTime - beginTime));

        StringBuffer sbf = new StringBuffer();
        beginTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++)
            sbf.append(String.valueOf(i));
        endTime = System.currentTimeMillis();
        System.out.println("使用StringBuffer的append()方法的执行时间："+ (endTime - beginTime));

        StringBuilder sb = new StringBuilder();
        beginTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++)
            sb.append(String.valueOf(i));
        endTime = System.currentTimeMillis();
        System.out.println("使用StringBuilder的append()方法的执行时间："+ (endTime - beginTime));
    }
}

  输出结果：

  普通字符串直接相加的执行时间：261 
  使用StringBuffer的append()方法的执行时间：3 
  使用StringBuilder的append()方法的执行时间：2

    那Java中为什么StringBuilder比StringBuffer更快呢？

  首先我们看一下源码：

  java.lang.StringBuilder

public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

  java.lang.StringBuffer

public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }

  可以看到，StringBuffer类的append()方法，都被synchronized所修饰，这就是我们的主角。

  synchronized关键字是做什么的呢？在多线程中非常常见，根据用法不同，可以给方法、代码块或对象加锁。以此处为例，当多个线程访问加锁的方法时，每次只有一个线程获得锁，其他线程必须等待该线程释放锁（一般是执行完这个方法），再由下一个线程获得锁，才允许执行该方法。加锁会带来性能上的损耗（毕竟多执行了一些操作，还包括锁等待时的线程阻塞）。

  为什么StringBuffer要加锁？StringBuffer就是为了多线程而设计的，这样可以防止多个线程同时操作同一个对象，也就是线程安全。而如果使用多线程操作StringBuilder对象，则无法保证每次append进去的字符串保持原样（随线程数量和数据量增大，出现错乱的概率也越大，跟线程切换有关）。

  综上所述，Stringbuilder要比Stringbuffer快。