String、StringBuffer、StringBuilder

String类：

1.String的创建原理
由于String在java中使用过于频繁，java为了避免在系统中存在大量string的对象，引入了字符串常量池，其运行机制是：如果通过 String str1 = “897”; 直接量赋值方式，创建一个字符串时，首先会检查字符串常量池中是否有值相同的字符串对象，如果有，则不需要创建对象直接从常量池中查找到对象的引用，如果没有，则新建字符串对象，但是，如果是通过new 方法构建字符串对象是不检查字符串常量池的，而是直接在堆创建一个对象，不会把对象放入字符串常量池中。

举例：

String str1 = "897"; //通过直接量赋值方式，放入字符串常量池
String str2 = new String(“897”);//通过new方式赋值方式，不放入字符串常量池

2.String的特性分析

1. 不可变性
   String对象一旦生成，则不能再对它进行改变。不可变的主要作用在于当一个对象需要被多线程共享，并且访问频繁时，可以省略同步和锁等待的时间，从而大幅度提高系统性能。不可变模式是一个可以提高多线程程序的性能，降低多线程程序复杂度的设计模式。

首先我们要知道什么是不可变对象：
如果一个对象在创建之后就不能再改变他的状态，那么这个对象是不可变的，不能改变状态的意思是，不能改变对象内的成员变量，包括基本数据类型变量的值不能改变，引用类型的变量不能指向其他的对象，引用类型指向的对象的状态也不能改变。

String类不可变分析

String s = "abc";    //(1)
System.out.println("s = " + s);

s = "123";    //(2)
System.out.println("s = " + s);

结果：

s = abc
s = 123

但从打印结果看，你可能会觉得String类型的s不就发生改变了吗，为什么说string不可变，联想下刚刚我们说的string的创建原理，String s = "abc"我只是在字符串常量池创建了对象‘’abc” ，然后再栈中创建了引用s指向abc

现在，我 s = “123”，我先在字符串常量池中找，没有符合的对象，则新建一个对象123放入池中，修改原来栈中s引用的指向，指向123,。

不可变原理分析

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;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

从string源码可以看到，string类用final修饰，不可继承，String类的成员变量value,value是char[]类型，因此String对象实际上是用这个字符数组进行封装的。再看value的修饰符，使用了private，也没有提供setter方法，所以在String类的外部不能修改value，同时value也使用了final进行修饰，那么在String类的内部也不能修改value

string真的不可变吗？
利用之前的反射知识

String s = "Hello World";
System.out.println("s = " + s);

//获取String类中的value属性
Field valueField = String.class.getDeclaredField("value");

//改变value属性的访问权限
valueField.setAccessible(true);

//获取s对象上的value属性的值
char[] value = (char[]) valueField.get(s);

//改变value所引用的数组中的第6个字符
value[5] = '_';
System.out.println("s = " + s);

s始终指向同一个String对象，但是在反射操作之后，这个String对象的内容发生了变化。也就是说，通过反射是可以修改String这种不可变对象的。

3.补充：

string的+拼接操作分析

		String a = "hellohello";
		String b = "hello";
		System.err.println(a == b+"hello");//false

输出是false，原因是Java中的String类不可变的，每一次拼接都是生成新对象的过程，String拼接中间会产生StringBuilder对象（JDK1.5之前产生StringBuffer）所以实质就是stringbuffer的appen操作

		String str1 = "hello";
		String str2 = "world";
		String s = str1 + str2;

字符串“+” 的拼接操作，实际上是先调用

	String s1 = String.valueOf(str1);
   	String s2 = String.valueOf(str2);

而在valueOf方法是这样进行判断的：如果传入的对象是null，则直接返回“null”字符串，否则则返回该对象的字符串类型

    public static String valueOf(Object obj) {
       return (obj == null) ? "null" : obj.toString();
   }

然后才会去产生StringBuilder， 调用的StringBuilder(str1)构造方法， 把StringBuilder初始化，长度为str1.length()+16，并且调用append(str1)！ 接下来调用StringBuilder.append(str2), 把第二个字符串拼接进去， 然后调用StringBuilder.toString返回结果！

所以才会有这样一道比较经典面试题

String s = null;  
s += "abc";  
System.out.println(s);  

答案是nullabc

4. stringbuilder和stringBuffer的区别

1. StringBuffer和StringBuilder都集成了AbstractStringBuilder，而StringBuffer大部分方法都是synchronized，也就是线程安全的，而StringBuilder就没有，所以，我们查看API可以知道，StringBuilder可以操作StringBuffer，但是StringBuffer不可以操作StringBuilder。
2. StringBuffer、StringBuilder和String一样，用来代表字符串。String类是不可变类，任何对String的改变都 会引发新的String对象的生成；StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象。既然可变和不可变都有了，为何还有一个StringBuilder呢？相信初期的你，在进行append时，一般都会选择StringBuffer吧！StringBufferd支持并发操作，线性安全的，适 合多线程中使用。StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。
3. 效率：StringBuilder>StringBuffer>String。考虑单线程程序的话，用StringBuilder，如果涉及到多线程的，推荐StringBuffer。