简介(摘自Java源码)

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是一个不可变对象，对象的值不可以被改变。因为这一点，所以String是线程安全的。然后Stringbuffer是可变对象。

【问题1】什么是不可变对象(immutable object),不可变对象有什么好处，在什么情况下应该用，或者更具体一些，Java的String类为什么要设成immutable类型？

答：从String类的源码中，我们可以知道不可变对象是被final关键字修饰的类产生的对象，其成员变量也是被final修饰的，因此该类不能被修改也不能被继承。

不可变对象的好处主要体现在以下两方面：

1. 不可变对象是线程安全的，可用于多线程。在多线程通信中，某一个变量很可能被多个线程进行修改，因此是不安全的。而不可变对象不能被修改，安全；

2.不可变对象可以提高拷贝时的效率，不可变意味着拷贝时只需要拷贝地址，效率高。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** 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;

...........................................
}

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    /**
     * A cache of the last value returned by toString. Cleared
     * whenever the StringBuffer is modified.
     */
    private transient char[] toStringCache;

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    static final long serialVersionUID = 3388685877147921107L;
}

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

    /**
     * The count is the number of characters used.
     */
    int count;
}

【问题2】String和StringBuffer以及StringBuilder的区别是什么？

从问题1中我们已经看到了其中一个主要的区别：String是不可变对象，StringBuffer是可变对象。这一点也导致了其他的很多的区别。

看下面两个例子字符串拼接：

String str = new String ("Stanford  ");
     str += "Lost!!";

StringBuffer str = new StringBuffer ("Stanford ");
     str.append("Lost!!");

乍一眼看过去还真以为第一种方式高于第二种方式，其实不然。我们看两张程序的字节码。

0 new #7 <Class java.lang.String>
3 dup 
4 ldc #2 <String "Stanford ">
6 invokespecial #12 <Method java.lang.String(java.lang.String)>
9 astore_1
10 new #8 <Class java.lang.StringBuffer>
13 dup
14 aload_1
15 invokestatic #23 <Method java.lang.String valueOf(java.lang.Object)>
18 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
21 ldc #1 <String "Lost!!">
23 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
26 invokevirtual #22 <Method java.lang.String toString()>
29 astore_1

0 new #8 <Class java.lang.StringBuffer>
3 dup
4 ldc #2 <String "Stanford ">
6 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
9 astore_1
10 aload_1 
11 ldc #1 <String "Lost!!">
13 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
16 pop

再说StringBuilder，StringBuilder和StringBuffer一样都是可变对象，那有什么区别呢？我们稍微比较一下源码就可以看到StringBuffer中的大多数函数都带有关键字：synchronized和StringBuilder中没有。因此，StringBuilder在单线程中效率高于StringBuffer，而StringBuffer可以用于多线程。

【问题3】String两种初始化方式的区别

String str = new String("abc");

String str = "abc";

String str1 = new String("abc"); //jvm 在堆上创建一个String对象   
  
 //jvm 在strings pool中找不到值为“abc”的字符串，因此   
 //在堆上创建一个String对象，并将该对象的引用加入至strings pool中   
 //此时堆上有两个String对象   
Stirng str2 = "abc";   
  
 if(str1 == str2){   
         System.out.println("str1 == str2");   
 }else{   
         System.out.println("str1 != str2");   
 }   
  //打印结果是 str1 != str2,因为它们是堆上两个不同的对象   
  
  String str3 = "abc";   
 //此时，jvm发现String Pool中已有“abc”对象了，因为“abc”equals “abc”   
 //因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用   
  if(str2 == str3){   
         System.out.println("str2 == str3");   
  }else{   
         System.out.println("str2 != str3");   
  }   

再来看一段代码

String str1 = new String("abc"); //jvm 在堆上创建一个String对象   
  
str1 = str1.intern();   
//程序显式将str1放到String Pool中，intern运行过程是这样的：首先查看String Pool   
//有没“abc”对象的引用，没有，则在堆中新建一个对象，然后将新对象的引用加入至   
//String Pool中。执行完该语句后，str1原来指向的String对象已经成为垃圾对象了，随时会   
//被GC收集。   
  
//此时，jvm发现String Pool中已有“abc”对象了，因为“abc”equals “abc”   
//因此直接返回str1指向的对象给str2，也就是说str2和str1引用着同一个对象，   
//此时，堆上的有效对象只有一个。   
Stirng str2 = "abc";   
  
 if(str1 == str2){   
         System.out.println("str1 == str2");   
 }else{   
         System.out.println("str1 != str2");   
 }   

这个问题就涉及到Java的内存模型了，简单的说来区别在于：

第一种初始化方式会立即在对上创建一个String对象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在String Pool判断是否存在该String对象。如果有，则返回已有的String对象，如果没有，则在heap中重新创建对象，将其引用返回给用户同时将该引用添加至String Pool中。而第一种方式是不会主动把对象添加至String Pool中的。因此第一段程序的输出结果是

str1 != str2
str1 == str2

str1 == str2

【问题4】String Pool和Const Pool的区别和联系

了解Java内存模型的都知道，在Java内存中有一块区域叫做方法区。方法区主要用于存储一些常量和静态变量。而String Pool和Const Pool的区别简单的说来，String Pool是Const Pool的一部分，Const Pool包括很多种常量，整型啊之类的，而String Pool只是用来专门存储String常量。

没有写完，持续更新。。。。

Java学习笔记（1）String常见面试知识总结