string stringBufer

面试中常常会遇到这样的问题：1、你了解String类吗？2、String，StringBuilder和StringBuffer适合在什么样的场景下使用?

1、String类

首先看一下String的源码

public final class String

    implements java.io.Serializable, Comparable<String>, CharSequence
{

    /** The value is used for character storage. */

    private final char value[];
 
    /** The offset is the first index of the storage that is used. */

    private final int offset;
 
    /** The count is the number of characters in the String. */

    private final int count;
 
    /** Cache the hash code for the string */

    private int hash; // Default to 0
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */

    private static final long serialVersionUID = -6849794470754667710L;
 
    ......
 
}

1）打开String源码们会发现这个类是final类，说明这个类不能被继承，其中的成员默认也是final修饰的。在之前的JVM实现版本中，被final修饰的方法会被转为内嵌调用以便提升效率。但是从JDK5/6之后，就抛弃了这种方式。因此现在不需要考虑通过final修饰来提高方法的调用效率。一般情况下，如果想要某个方法不被覆盖或者重载的情况下使用final修饰。

2）String采用immutable 设计模式，因此对象是最终的，不可被改变(在JDK的标准下是这样，当绕过JDK标准时，采用反射的方式就可以改变)。

String s1 = "abcd";  

String s2 = "abcd";  

s1和s2是两个不同的对象

Q：为什么将其设为不可变的，有什么好处？(了解)

a.字符串常量池的需要

字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。

如下面的代码所示,将会在堆内存中只创建一个实际String对象.

String s1 = "abcd";
String s2 = "abcd";

假若字符串对象允许改变,那么将会导致各种逻辑错误,比如改变一个对象会影响到另一个独立对象. 严格来说，这种常量池的思想,是一种优化手段.

b.允许String对象缓存HashCode
Java中String对象的哈希码被频繁地使用, 比如在hashMap 等容器中。

字符串不变性保证了hash码的唯一性,因此可以放心地进行缓存.这也是一种性能优化手段,意味着不必每次都去计算新的哈希码. 在String类的定义中有如下代码:

private int hash;//用来缓存HashCode

c.安全性
String被许多的Java类(库)用来当做参数,例如网络连接地址URL,文件路径path,还有反射机制所需要的String参数等, 假若String不是固定不变的,将会引起各种安全隐患。

假如有如下的代码:

boolean connect(string s){
if (!isSecure(s)) {
throw new SecurityException();
}
// 如果在其他地方可以修改String,那么此处就会引起各种预料不到的问题/错误
causeProblem(s);
}

3）上面列举出了String类中所有的成员属性，从上面可以看出String类其实是通过char数组来保存字符串的。

　　下面再继续看String类的一些方法实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


public String substring(int beginIndex, int endIndex) {

    if (beginIndex < 0) {

        throw new StringIndexOutOfBoundsException(beginIndex);

    }

    if (endIndex > count) {

        throw new StringIndexOutOfBoundsException(endIndex);

    }

    if (beginIndex > endIndex) {

        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);

    }

    return ((beginIndex == 0) && (endIndex == count)) ? this :

        new String(offset + beginIndex, endIndex - beginIndex, value);

    }
 

 public String concat(String str) {

    int otherLen = str.length();

    if (otherLen == 0) {

        return this;

    }

    char buf[] = new char[count + otherLen];

    getChars(0, count, buf, 0);

    str.getChars(0, otherLen, buf, count);

    return new String(0, count + otherLen, buf);

    }
 

 public String replace(char oldChar, char newChar) {

    if (oldChar != newChar) {

        int len = count;

        int i = -1;

        char[] val = value; /* avoid getfield opcode */

        int off = offset;   /* avoid getfield opcode */
 

        while (++i < len) {

        if (val[off + i] == oldChar) {

            break;

        }

        }

        if (i < len) {

        char buf[] = new char[len];

        for (int j = 0 ; j < i ; j++) {

            buf[j] = val[off+j];

        }

        while (i < len) {

            char c = val[off + i];

            buf[i] = (c == oldChar) ? newChar : c;

            i++;

        }

        return new String(0, len, buf);

        }

    }

    return this;

　　从上面的三个方法可以看出，无论是sub操、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。

　　在这里要永远记住一点：

　　“对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”。

　　在了解了于String类基础的知识后，下面来看一些在平常使用中容易忽略和混淆的地方。

String str="hello world"和String str=new String("hello world")的区别

想必大家对上面2个语句都不陌生，在平时写代码的过程中也经常遇到，那么它们到底有什么区别和联系呢？下面先看几个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13


public class Main {

         

    public static void main(String[] args) {

        String str1 = "hello world";

        String str2 = new String("hello world");

        String str3 = "hello world";

        String str4 = new String("hello world");

         

        System.out.println(str1==str2);

        System.out.println(str1==str3);

        System.out.println(str2==str4);

    }
}

输出的结果是：

false

true

false

为什么会出现这样的结果？下面解释一下原因：

　　在前面一篇讲解关于JVM内存机制的一篇博文中提到，在class文件中有一部分来存储编译期间生成的字面常量以及符号引用，这部分叫做class文件常量池，在运行期间对应着方法区的运行时常量池。

　　因此在上述代码中，String str1 = "hello world";和String str3 = "hello world"; 都在编译期间生成了字面常量和符号引用，运行期间字面常量"hello world"被存储在运行时常量池（当然只保存了一份）。通过这种方式来将String对象跟引用绑定的话，JVM执行引擎会先在运行时常量池查找是否存在相同的字面常量，如果存在，则直接将引用指向已经存在的字面常量；否则在运行时常量池开辟一个空间来存储该字面常量，并将引用指向该字面常量。

众所周知，通过new关键字来生成对象是在堆区进行的，而在堆区进行对象生成的过程是不会去检测该对象是否已经存在的。因此通过new来创建对象，创建出的一定是不同的对象，即使字符串的内容是相同的。

String、StringBuffer以及StringBuilder的区别

既然在Java中已经存在了String类，那为什么还需要StringBuilder和StringBuffer类呢？

　　那么看下面这段代码：

1
2
3
4
5
6
7
8
9


public class Main {

         

    public static void main(String[] args) {

        String string = "";

        for(int i=0;i<10000;i++){

            string += "hello";

        }

    }
}

　　这句 string += "hello";的过程相当于将原有的string变量指向的对象内容取出与"hello"作字符串相加操作再存进另一个新的String对象当中，再让string变量指向新生成的对象。如果大家还有疑问可以反编译其字节码文件便清楚了

从这段反编译出的字节码文件可以很清楚地看出：从第8行开始到第35行是整个循环的执行过程，并且每次循环会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象。也就是说这个循环执行完毕new出了10000个对象，试想一下，如果这些对象没有被回收，会造成多大的内存资源浪费。从上面还可以看出：string+="hello"的操作事实上会自动被JVM优化成：

　　StringBuilder str = new StringBuilder(string);

　　str.append("hello");

　　str.toString();

　　再看下面这段代码：

public class Main {

    public static void main(String[] args) {

        StringBuilder stringBuilder = new StringBuilder();

        for(int i=0;i<10000;i++){

            stringBuilder.append("hello");

        }

    }
}

反编译字节码文件得到：

string stringBufer

从这里可以明显看出，这段代码的for循环式从13行开始到27行结束，并且new操作只进行了一次，也就是说只生成了一个对象，append操作是在原有对象的基础上进行的。因此在循环了10000次之后，这段代码所占的资源要比上面小得多。

　　那么有人会问既然有了StringBuilder类，为什么还需要StringBuffer类？查看源代码便一目了然，事实上，StringBuilder和StringBuffer类拥有的成员属性以及成员方法基本相同，区别是StringBuffer类的成员方法前面多了一个关键字：synchronized，不用多说，这个关键字是在多线程访问时起到安全保护作用的,也就是说StringBuffer是线程安全的。

　　下面摘了2段代码分别来自StringBuffer和StringBuilder，insert方法的具体实现：

　　StringBuilder的insert方法

1
2
3
4
5
6


public StringBuilder insert(int index, char str[], int offset,

                              int len)

  {

      super.insert(index, str, offset, len);

  return this;

  }

　　StringBuffer的insert方法：

1
2
3
4
5
6


public synchronized StringBuffer insert(int index, char str[], int offset,

                                            int len)

    {

        super.insert(index, str, offset, len);

        return this;

    }

不同场景下的三个类的性能测试

public class Main {

    private static int time = 50000;

    public static void main(String[] args) {

        testString();

        testStringBuffer();

        testStringBuilder();

        test1String();

        test2String();

    }

    public static void testString () {

        String s="";

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            s += "java";

        }

        long over = System.currentTimeMillis();

        System.out.println("操作"+s.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");

    }

    public static void testStringBuffer () {

        StringBuffer sb = new StringBuffer();

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            sb.append("java");

        }

        long over = System.currentTimeMillis();

        System.out.println("操作"+sb.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");

    }

    public static void testStringBuilder () {

        StringBuilder sb = new StringBuilder();

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            sb.append("java");

        }

        long over = System.currentTimeMillis();

        System.out.println("操作"+sb.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");

    }

    public static void test1String () {

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            String s = "I"+"love"+"java";

        }

        long over = System.currentTimeMillis();

        System.out.println("字符串直接相加操作："+(over-begin)+"毫秒");

    }

    public static void test2String () {

        String s1 ="I";

        String s2 = "love";

        String s3 = "java";

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            String s = s1+s2+s3;

        }

        long over = System.currentTimeMillis();

        System.out.println("字符串间接相加操作："+(over-begin)+"毫秒");

    }

}

测试结果（win7，Eclipse，JDK6)：

上面提到string+="hello"的操作事实上会自动被JVM优化，看下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


public class Main {

    private static int time = 50000;

    public static void main(String[] args) {

        testString();

        testOptimalString();

    }

     

     

    public static void testString () {

        String s="";

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            s += "java";

        }

        long over = System.currentTimeMillis();

        System.out.println("操作"+s.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");

    }

     

    public static void testOptimalString () {

        String s="";

        long begin = System.currentTimeMillis();

        for(int i=0; i<time; i++){

            StringBuilder sb = new StringBuilder(s);

            sb.append("java");

            s=sb.toString();

        }

        long over = System.currentTimeMillis();

        System.out.println("模拟JVM优化操作的时间为："+(over-begin)+"毫秒");

    }

     
}

    

　　执行结果：

得到验证。

　　下面对上面的执行结果进行一般性的解释：

　　1）对于直接相加字符串，效率很高，因为在编译器便确定了它的值，也就是说形如"I"+"love"+"java"; 的字符串相加，在编译期间便被优化成了"Ilovejava"。这个可以用javap -c命令反编译生成的class文件进行验证。

　　对于间接相加（即包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化。

　　2）String、StringBuilder、StringBuffer三者的执行效率：

　　StringBuilder > StringBuffer > String

　　当然这个是相对的，不一定在所有情况下都是这样。

　　比如String str = "hello"+ "world"的效率就比 StringBuilder st = new StringBuilder().append("hello").append("world")要高。

　　因此，这三个类是各有利弊，应当根据不同的情况来进行选择使用：

　　当字符串相加操作或者改动较少的情况下，建议使用 String str="hello"这种形式；

　　当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。

说了这么多，这三个类在什么场景下使用呢？

3、三个类是使用场景

不需要频繁的拼接字符串的时候使用String，相反需要经常拼接字符串的时候使用StringBuilder。StringBuilder与StringBuffer相比，两个类似，不同的是StringBuilder是非线程安全的，适合在单线程的情况下使用。多线程情况也可以使用，不过需要手动加同步。StrngBuffer是线程安全的，适合在多线程的情况下使用。StringBuilder的效率要StringBuffer高