当心字符串连接的性能(关于String及StringBuilder的几点区别)

对于JAVA的字符串连接操作符（+）相信大家都十分熟悉 ，它的作用是把多个字符串合并为一个字符串，当然我们使用它是非常方便的 ，但它确不适合运用在大规模的场景中 。

 

下面我们通过程序说明一下：

假设我们有一个需求会对字符串进行数量很大连接操作

如果我们使用String进行操作，由于 String是不可变的，每次进行用（+）连接时都相当于重新创建了一个对象

这无疑是相当耗时的，以下程序进行了10万次的字符连接操作

 

public static void main(String[] args) {
        long start=System.currentTimeMillis();
        String string="aa";
        for (int i = 0; i <100000; i++) {
            string+="a";
        }
        long end=System.currentTimeMillis();
        System.out.println(end-start);
    }

第一个程序输出8425（具体因计算机处理速度不定）

 

由于我们每次连接两个字符串时，它们的内容都要被拷贝 ，所以程序的执行时候是呈几何增长的。

为了获得可以接受的性能，我们可以用StringBuilder代替String 

 

public static void main(String[] args) {
    long start=System.currentTimeMillis();
    StringBuilder sb=new StringBuilder("aa");
    for (int i = 0; i <100000; i++) {
        sb.append("a");
    }
    long end=System.currentTimeMillis();
    System.out.println(end-start);
}

第二个程序输出15（具体因计算机处理速度不定）

 

由程序的执行结果不难看出 ，二者的性能差十分的大，操作的数量越多 ，差距就越明显 。

 

结论：当我们的程序需要性能的时候，不要使用字符串连接操作符（+）来合并多个字符串 。最好使用StringBuilder的append方法。

 

 

关于String及StringBuilder的几点区别

直接看示例1：

 

public class StringTest{

    void stringReplace(String strTemp){
        strTemp=strTemp.replace('l','i');
    }

    void stringBufferAppend(StringBuffer sbTemp){
        sbTemp=sbTemp.append('c');
    }

    public static void main(String[] args){
        StringTest st=new StringTest();
        String str=new String("hello");
        StringBuffer sb=new StringBuffer("hello");

        // String str1=new String("hello");
        // StringBuffer sb1=new StringBuffer("hello");

        // System.out.println("str.equals(sb)= "+str.equals(sb));
        // System.out.println("str.equals(str1  )= "+str.equals(str1));
        // System.out.println("sb.equals(str)= "+sb.equals(str));
        // System.out.println("sb.equals(sb1)= "+sb.equals(sb1));

        st.stringReplace(str);
        st.stringBufferAppend(sb);
        System.out.println("str= "+str+"\tsb= "+sb);
    }
}

输出结果：

 

 

str= hello  sb= helloc

上面的示例无非就是方法传值与传址的问题，因为形参为引用类型，因此实参传递过来的是对象的地址值，问题来了：改变该地址所对应的内容，实参应该也会跟着发生变化，如sb最终结果那样，但str却没有，为何？

 

这就是String与StringBuilder的区别：

字符串的可变与不可变

JDK_1.8中这样解释：

 

Strings are constant; their values cannot be changed after they are created.
String buffers support mutable strings. Because String objects are immutable
they can be shared.

 

 

String创建的字符串是不可变的，而StringBuilder(或StringBuffer)通过字符缓冲区创建字符串，可变；

先来解析下String的不可变：

 

String s="hello";
s="world";

对象s在创建的时候先查看常量池中是否有"hello"，有则指向它，没有就创建一个"hello"，再指向它，但当重新对s赋值为"world"时，常量池中的"hello"并没有改变，java会重新开辟一个内存存储新值"world"，并令s指向"world"；

因此在示例1中，当调用stringReplace()方法时，实参str所存储的地址值传给了形参strTemp后，strTemp指向了常量池中"hello"，当对其进行字符替换时，java会重新创建"heiio"，并让形参strTemp指向它，因此形参和实参指向了不同的区域，结果自然显而易见；

另外，String的不可变是由于：

 

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];//final的作用，使之初始化后不可改变
    ……
}

 

(P.S.虽然value是用final来修饰的，但仍有办法可以直接改变其值，具体可以参见 反射 )

再来对比下StringBuilder的可变：

 

StringBuilder sb=new StringBuilder("hello");
sb.append("world");

在创建StringBuilder对象时，java实际上在堆中创建了字符类型数组char[]，存储完"hello"后通过append方法在增加"world"，并未开辟新的内存区，形参和实参指向同一区域，因此形参对对象内容进行变化，实参也会跟着变化；

来看下StringBuilder构造器的底层代码：

public StringBuilder() {
        super(16);
    }

public StringBuilder(int capacity) {
        super(capacity);
    }

public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
}

public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
}

其基类AbstractStringBuilder的构造方法：

char[] value;
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}

……

 

可以发现StringBuilder实际创建了一个默认16字符长的char型数组(亦可指定长度)：char[] value；

若为对象赋值时，所存储的字符串长度未超过所定义的char数组长度，则按顺序存储相应字符，若超过所定义的数组长度，则自动扩充其长度，因此说StringBuffer是可变的；

我们还是继续看append()底层代码比较形象：

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
}

private void ensureCapacityInternal(int minimumCapacity) {
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
}

void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
}

当为StringBuilder对象增加内容时，会先计算所需最小空间：minimumCapacity=count+len;并与原数组长度的2倍+2即newCapacity进行比较，取较大值并为数组value重新赋值，赋值采用的是数组复制的方式进行；

常见的数组复制有两种方法：一为：Arrays.copyOf()，另一为：System.arraycopy()，差别在于后者可能存在下标越界的问题，其实前者也是通过调用后者的方法来实现的：

 

public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
}

由于重新为临时数组copy定义了长度newLength，因此复制的时候不会出现越界问题；在数组复制结束后，将临时数组copy赋值给value，使之指向新的区域，完成append()操作 (这里注意：引用变量value的指向发生了变化，但StirngBuilder的指向没有变，只不过其成员变量(恰巧是个引用变量value)的值发生了改变，因此形参sbTemp和sb仍指向同一区域)；

equals方法

示例1中注释掉的几个equals()语句，结果只有String与String比较时才返回true，这是String与StringBuilder的另一个区别；

我们要直到equals()方法的返回结果取决于你如何重写的，如直接继承Object的方法，则比较的是变量的值，对于StringBuilder，它并未重写该方法，因此对两个引用变量进行比较自然返回false；而String类重写了该方法，具体如下：

 

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

可知，若两个引用变量指向同一区域，则自然返回true，若非，则判断anObject是否是String的实例，若是则进行值比较，否则直接返回false；

 

 

效率的差别

 

public class StringBuilderTest2{
    public static void main(String[] args){

            StringBuilder sb=new StringBuilder();
            StringBuilder sb1=new StringBuilder(Integer.MAX_VALUE/7);
            String s=null;
            System.out.println(Integer.MAX_VALUE+"\n"+sb1.capacity());
            long start=System.currentTimeMillis(),end;
            for(int i=0;i<1000000;i++){
                sb.append(1);
            }
            end=System.currentTimeMillis();
            System.out.println("默认初始化SB时循环100w次耗时："+(end-start));
            for(int i=0;i<1000000;i++){
                sb1.append(1);
            }
            start=System.currentTimeMillis();
            System.out.println("给定值初始化SB1时循环100w次耗时："+(start-end));

            for(int i=0;i<100000;i++){
                s+=1;
            }
            end=System.currentTimeMillis();
            System.out.println("String“+”运算10W次耗时："+(end-start));
        }
}

输出：

 

2147483647
306783378//初始化值
默认初始化SB时循环100w次耗时：35
给定值初始化SB1时循环100w次耗时：16
String“+”运算10W次耗时：3211

可以发现在循环“+”/append()运算时，String类的效率明显低于StringBuilder，为何？

 

这里继续使用javap来分析：

 

String s=null;
s+=1;

0: aconst_null
1: astore_1
2: new           #2                  // class java/lang/StringBuilder
5: dup
6: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
9: aload_1
10: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
13: iconst_1
14: invokevirtual #5                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
17: invokevirtual #6                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
20: astore_1
21: return

可以看到编译器在解析String"+"运算时，会转换成StringBuilder，调用append()方法，再通过toString()赋值，因此循环运算时，就不断发生创建对象和产生垃圾，这过程消耗了资源，造成了效率的下降；

 

另外，我们也可以发现调用StringBuilder构造方法时若给它传入较大整数作为参数，则运算效率也会有明显的提升，这跟前面所提扩容时数组复制有关，给定较大初始缓存区，自然不需要频繁扩容；
当然，这里顺带提一下，如果直接把String的"+"运算写成形如：s=""+1+1+1……，而不是通过循环来不断调用变量，则编译器会直接求出其字面量，运行时不会再转换为StringBuilder，效率当然就比后者高了；