深入探讨Java字符串的拼接

前言：国庆最近跟着小男友在图书馆学习，偶然被他带着看开了Java源码，因而有兴趣想看看String这个是怎么回事。

String中的equals

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

这是String复写的equals的源码，在Object中equals方法返回的是两者地址值，即：

public boolean equals(Object obj) {
    return (this == obj);
}

也就是说，如果这两个地址相同则返回true，不进行内容的比较。例如，

String s1 = "abc";
String s2 = "abc";

由于这两个变量都在常量池，所以地址会一致，所以返回true。之后的判断也一目了然，首先判断是否属于String类，然后判断内容是否一致。

String中的HashCode

hashcode是何许物种？我们可以查到一种解释，hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值，在Object中也可以看到对HashCode生成的方法，是一个native类，但好在有注释，Whenever it is invoked on the same object more than once during an execution of a Java application, the method must consistently return the same integer.底层是C++的实现，但总而言之，是可以用它确定对象地址是否相同的。

在String类中，复写了hashCode的生成方法，显得简单了很多，这里的hashcode将String字符串经过计算得到了一个数字，计算方法如下：

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

也就是将每个字符转成ASCII码，通过公式算得。例如：

String str = "abc";
System.out.println(str.hashCode());
System.out.println(31*((31*97)+98)+99);
即为：96354
同时我们可以看出字符串a的hashcode为97
System.out.println("a".hashCode()); ==> 97

其实有很多类都复写了hashcode方法，例如Integer，直接返回了Integer的值。

public int hashCode() {
    return Integer.hashCode(value);
}

String中的 + 拼接

终于引出来我们最需要了解的一个方法了。

引出今天探索的原因是String是一个被final修饰的类
    public final class String
所以，我就在想，通过 + 的字符拼接是怎么进行的，== 是判断地址的，那么由于String是一个不可变的类，也就是说，+ 拼接完后的String还是不是它本身。
如代码：
    String s = "hello";
    String str = "hello";
    System.out.println(s==str);
    s+="world";
    System.out.println(s==str);
假设s的地址没有发生改变的话，那么两个判断都应该是true，然而结果是第一个是true，第二个是false，我们也就可以这样猜想，是不是这个拼接后的s，已经不是之前的s。

之后我们又进行了如下测试，返回值是false，也就是说，str1与str2地址不同，这个很好理解，因为是new操作，所以hello就存放在了两个堆区，同时str1和str2的地址值存放到了栈中。
    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println(str1 == str2);

通过反编译代码，可以发现String中 + 进行拼接，实际上是创建了一个StringBuilder，事实上这个我还真没反编译出来，网上找到的参考资料如下：

String str0 = "a";
StringBuilder sb = new StringBuilder();
sb.append(str0).append("b");
String str1 = sb.toString();

来自：http://www.jianshu.com/p/849f1d443b3a

所以，String引用对象在拼接时，建立了临时缓存的StringBuilder，因此地址发生了变化。