String的理解

关于String的学习上，我学习的似乎太浅显了，只知道这就是按照字面上的理解，只是一个字符串而已，但是怎么去深入地理解String这个Java给我们提供的原生的类呢，这个问题在我面试的工作中经常被问到。
好的首先我们来看看Java种String类的继承关系：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

首先我们可以看到这是一个final类，也就是说String类是不能够被继承的一种类，当然根据final关键字的特性，String中的所有的方法也都将隐型地被认为是final方法。
那么第一个问题：
Q：为什么要将String设置为final类
A：
1.首先就是为了安全，什么叫安全？这就要讲到一部分的JVM内存的知识了，在JVM中有方法区、Java堆、Java栈、程序计数器、本地方法栈这些东西，而对象都是放在Java堆中的，常量均存放于方法区中，我们使用的仅仅是一个引用而已，在String中

private final byte[] value;

很显然这个value数组就是用来存放我们真实的数据的，设想String如果不是final类，虽然我们将value数组也设置成了final，但实质上这是一种比较假的final，因为我们维护的紧紧只是一个这个数组的引用而已，也就是说我们只要这个引用的值不变，就算value数组的大小改变了符合相应的定义的，那么我们来试试：

        final char[] value = {'a','b','c'};
        value[2] = 'd';

这样是完全行得通的。
那么如何去保证它的不变性呢，当然还有一个private修饰符，这样就能保证不会直接通过修改value来修改字符串。
那么又回到了这个安全性能上来，当字符串是可变的时候，那么那些用来存储一些数据库的用户名、密码这些，一般是用String来存储的，如果可变，那么一些黑客就能够钻到空子，改变String指向的对象，从而造成安全漏洞。
2.只有当String是不可变的时候，那么我们的字符串池才有实现的可能，我们知道，有时候像字符串这种东西，我们使用的次数是很多的，并且经常会有相同的情况，也就是说复用的可能很大。

        String aaa = new String("abc");
        String bbb = new String("abc");

        String aa = "abc";
        String bb = "abc";

        StringBuffer cc = new StringBuffer("abc");
        StringBuffer dd = new StringBuffer("abc");


        System.out.println(aa==bb);   //true
        System.out.println(aaa==bbb);   //false
        System.out.println(aa==aaa);   //false
        System.out.println(aa==cc.toString());   //false
        System.out.println(cc==dd);   //false

实质上，上述的过程中，
第一步通过new关键字创建的是一个对象，所以这个对象应该放在Java堆中，但是我们初始化的时候用到了"abc"这个常量，所以首先应该把这个常量放在方法区中，然后返回一个引用，在这句话中，我们一共产生了"abc"、new String("abc")、两个对象以及aaa这是个引用
第二步也是通过new关键字，但是这个时候，由于经过第一步所以常量池中已经存在"abc"这个常量了，我们不需要建立一个常量对象，只是需要对其做一个返回的引用就行，也就是说我们只需要再Java堆中建立一个new String("abc")的对象就行，然后返回一个引用即可
那么将常量统一管理的好处是什么，这样就能大大减少堆所占的空间，不同的字符串变量都能够指向同一个常量，注意这里的常量是不会变的（String的final修饰），我想过去调用String中的replace方法来改变，但最终replace会重新新建一个String的对象，也就是说在堆中又放入了一个对象了。
3.容易被管理，由于其不变的性质，那么在创建的时候其Hashcode就能够被缓存，所以很适合作为Map中的Key
4.因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

===================end Question
那么我们再回到String的定义中来

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

//TODO
它继承了Serializable接口还有Comparable接口以及CharSequence接口，这几个接口的功能还有待深入了解，一个是序列化用到的接口，一个是比较时用到的接口，一个是字符数组的接口。

String与StringBuffer、StringBuilder的比较

认识StringBuffer

按照国际惯例，我们来看看StringBuffer的源码：

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

我们可以看到这也是个final类，而且是继承了AbstractStringBuilder，那么来看看这个抽象类：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    byte[] value;
    byte coder;
    int count;

是的，我们看到这个抽象类这个的value数组，我们逐步观察StrungBuffer中的构造函数，发现最终存储数据的就是这个value数组，而这个数组并没有加上private或者说final的修饰符，也就是说这个value数组是可以任意改变的，而这个抽象类所继承的Appendable接口按照字面理解就是说能够进行追加。
那么可以改变的话相对于String来说它就失去了一些特点了。
然后StringBuffer有一个成员变量：

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

那么官方给出的解释就是说这是toString方法的最后的值的缓存，当StringBuffer被修改的时候就被清理掉,我们观察StringBuffer中这个变量的用处，基本都是在改变StringBuffer的时候将其赋值为空，只有在toString方法中我们用其做了一个new的方式，这在我看来只是一种缓存的方式而已，我们看看toString方法：

    @Override
    @HotSpotIntrinsicCandidate
    public synchronized String toString() {
        if (toStringCache == null) {
            return toStringCache =
                    isLatin1() ? StringLatin1.newString(value, 0, count)
                               : StringUTF16.newString(value, 0, count);
        }
        return new String(toStringCache);
    }

也就是说，当我们频繁地调用StringBuffer对象的toString方法的话，我们并不需要通过StringLatin1和StringUTF16的方法做转换，直接给一个String就是了，直接的new String仅仅只是传递了引用而已，但是通过StringLatin1或者StringUTF16的方法就会多出一些判断之类的（//TODO这里其实理解的不好）
通过阅读StringBuffer的源码，我们可以发现其中的许多方法都是用synchronized关键词修饰的，也就是说，这是一个线程安全类（毕竟用了同步方法），但是相应的同步带来的一些问题就是效率低下问题了。

认识StringBuilder

那么我们还是可以看看StringBuilder的源码：

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

这么一看，它与StringBuffer近乎一模一样，但是我们并没有看到像StringBuffer中的toStringCache这个变量，也就是说它并没有做一种在toString方法中的优化处理了，而且其方法都没有加上synchronized关键词，这就说明了这个类并不是线程安全类，在多线程环境下需要慎重使用。

比较三者之间的关系

1.String对象不仅可以存在于常量池中，也可以存在于Java堆中，另外两个只能在Java堆中
2.String对象是线程安全的，StringBuffer也是线程安全的，StringBudilder不是
3.关于字符串相加，在Java中有一些优化过程，如果仅仅只是直接的字符串相加，比如String a = "abc" + "da"这种过程，其实在编译的期间就会将其形成常量，所以会很快，但是String对间接相加并没有那么好，那么三者的效率一般情况下是这样的：StringBuilder>String>StringBuffer

（大致的总结就到这里啦，后面应该还有增加~）