String，StringBuilder和StringBuffer类

今天看了一下子关于String的一类的书，大概了解了String，StringBuilder和Stringuffer的区别。下面我就来浅谈一下关于这三部分的差异。

public class Test {

        int loopCount = 10000; // 执行添加操做10000次

        public static void main(String[] args) {
            Test test = new Test();
            test.testString();
            test.testStringBuffer();
            test.testStringBuilder();
        }

        private void testString() {
            long startTime = System.nanoTime();// 得到当前系统最准确的计时器，以毫微秒为计时单位
            String temp = "";
            for (int i = 0; i < loopCount; i++) {
                temp += i;
            }
            long endTime = System.nanoTime();
            System.out.println("String运行时间： " + (endTime - startTime));
        }

        private void testStringBuffer() {
            long startTime = System.nanoTime();// 得到当前系统最准确的计时器，以毫微秒为计时单位
            StringBuffer temp = new StringBuffer("");
            for (int i = 0; i < loopCount; i++) {
                temp.append(i);
            }
            long endTime = System.nanoTime();
            System.out.println("StringBuffer运行时间： " + (endTime - startTime));
        }

        private void testStringBuilder() {
            long startTime = System.nanoTime();// 得到当前系统最准确的计时器，以毫微秒为计时单位
            StringBuilder temp = new StringBuilder("");
            for (int i = 0; i < loopCount; i++) {
                temp.append(i);
            }
            long endTime = System.nanoTime();
            System.out.println("StringBuilder运行时间： " + (endTime - startTime));
        }
}

首先，运行这三个String差异，能够看出时间上差别很大

String运行时间： 606270951
StringBuffer运行时间： 1167296
StringBuilder运行时间： 746880

Process finished with exit code 0

String作字符串的拼接中

  String是一个不可变的线程安全的一个函数，关于字符串拼接，其调用

/** The value is used for character storage. */
private final char value[];

因为final是一个不可变的，因此每一次的调用，都须要建立一个新的对象。

String new=“this”+“is”+“a day“;

这样的拼接方式，编译器直接给你拼接为this is a day 实际上就是调用了Stringbuffer直接拼接而成，因此时间和StringBuffer其实差很少。可是若是是String str1="this",String str2="is";String str3="a day";String str=str1+str2+str3;这种形式的话，就是真实的按照String拼接。String的拼接，因为使用final做为不可变参数，因此线程安全。

而StringBuffer，因为须要字符串的拼接，因此有一些独特的用于拼接字符串的方法。

@Override
public synchronized StringBuffer append(Object obj) {
    toStringCache = null;
    super.append(String.valueOf(obj));
    return this;
}

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

/**
 * @throws StringIndexOutOfBoundsException {@inheritDoc}
 * @since      1.2
 */
@Override
public synchronized StringBuffer delete(int start, int end) {
    toStringCache = null;
    super.delete(start, end);
    return this;
}

这些方法，是用来作字符串拼接有关，咱们能够见到synchronized，其中全部的方法都给加了锁，因此这个方法也是线程安全的。

   

private transient char[] toStringCache;

关于字符串拼接，因为不是不可变的，因此速度会快。

另外一个的话，和StringBuffer差很少，可是线程不安全。

关于StringBuffer和StringBuilder他们共同继承了

AbstractStringBuilder

和序列化

public AbstractStringBuilder append(char[] str) {
    int len = str.length;
    ensureCapacityInternal(count + len);
    System.arraycopy(str, 0, value, count, len);
    count += len;
    return this;
}

这一部分是字符串拼接部分