String、StringBuffer、StringBuilder类

    String 类是不可改变的，对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象，通过char数组来保存字符串的。
    String  test1 = "abcdef";
    String test2 = "abc" + "def";
    只生成了一个String对象。
    String  test1 = "abcdef";
    String test2 = test1 + "def";
    生成了两个String对象。

    2、连接字符串
    两种连接方式：string1.concat(string2)，string1 + string2。

三、StringBuffer、StringBuilder
    当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。
    StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问），很多方法都被关键字synchronized 修饰了。

四、常见面试题
1. 下面这段代码的输出结果是什么？
　   String a = "hello2"; 　　String b = "hello" + 2; 　　System.out.println((a == b));
输出结果为：true。原因很简单，"hello"+2在编译期间就已经被优化成"hello2"，因此在运行期间，变量a和变量b指向的是同一个对象。

2.下面这段代码的输出结果是什么？
    String a = "hello2"; String b = "hello";  String c = b + 2;  System.out.println((a == c));
    输出结果为:false。由于有符号引用的存在，所以  String c = b + 2;不会在编译期间被优化，不会把b+2当做字面常量来处理的，因此这种方式生成的对象事实上是保存在堆上的。因此a和c指向的并不是同一个对象。

3.下面这段代码的输出结果是什么？
　　String a = "hello2"; final String b = "hello"; String c = b + 2; System.out.println((a ==  c));
　　输出结果为：true。对于被final修饰的变量，会在class文件常量池中保存一个副本，
也就是说不会通过连接而进行访问，对final变量的访问在编译期间都会直接被替代为        
真实的值。那么String c = b + 2;在编译期间就会被优化成：String c = "hello" + 2。

4.下面这段代码输出结果为：
    public class Main {
        public static void main(String[] args) {
        String a = "hello2";
        final String b = getHello();
        String c = b + 2;
        System.out.println((a == c));
        }
        public static String getHello() {
            return "hello";
        }
    }
　   输出结果为false。这里面虽然将b用final修饰了，但是由于其赋值是通过方法调用返回的，那么它的值只能在运行期间确定，因此a和c指向的不是同一个对象。

5.下面这段代码的输出结果是什么？
    public class Main {
        public static void main(String[] args) {
        String a = "hello";
        String b =  new String("hello");
        String c =  new String("hello");
        String d = b.intern();
         
        System.out.println(a==b);
        System.out.println(b==c);
        System.out.println(b==d);
        System.out.println(a==d);
        }
    }
输出结果为（JDK版本 JDK6)：
　　这里面涉及到的是String.intern方法的使用。在String类中，intern方法是一个本地方法，在JAVA SE6之前，intern方法会在运行时常量池中查找是否存在内容相同的字符串，如果存在则返回指向该字符串的引用，如果不存在，则会将该字符串入池，并返回一个指向该字符串的引用。因此，a和d指向的是同一个对象。

6.String str = new String("abc")创建了多少个对象？
    new只调用了一次，也就是说只创建了一个对象。
    该段代码执行过程和类的加载过程（编译期间）是有区别的。在类加载的过程中，在运行时常量池中创建了一个"abc"对象，而在代码执行过程中只创建了一个String对象。因此，这个问题如果换成 String str = new String("abc")涉及到几个String对象？合理的解释是2个。

7.下面这段代码//1和//2的区别是什么？
    public class Main {
      public static void main(String[] args) {
        String str1 = "I";
         str1 += "love"+"java";        //1
         str1 = str1+"love"+"java";      //2
        }
    }
1的效率比2的效率要高，1中的"love"+"java"在编译期间会被优化成"lovejava"，而2中的不会被优化。