String 那些事

String 的底层是final char[]数组实现的 ，因此String中的绝大多数方法，具体的实现都和char有着密切的关系，包括常用的length()，isEmpty()，charAt(),

1.string之 equals 方法，==。

源码，先比较==，然后确定是不是string类型，  比较字符串长度，  然后比较内容,（string内部其实就是char[]）

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;
    }
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;
    }

2.string的唯一一个静态内部类， 

首先，代码复用，compareToIgnoreCase这个方法就是通过这个内部类实现的。

其次，源码定义了一个CASE_INSENSITIVE_ORDER变量，来使用这个类。

private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

3,string 骚操作。

3.1string的另一特点就是final，不变的不被继承的，所以一些substr ,replac,contact 这些骚操作都是用在新生成，都是new string 。

3.2 字符串常量。

String a="abc";先查下常量池中是否已经有了"abc"了，如果没有就在常量池中创建一个。

String b="abc";先查下常量池中是否已经有了"abc"了，已经有了，那么b就指向常量池中“abc”这个地址。

所以a==b 是true的

String c =new String("abc")，当new一个对象的时候，也是先检测常量池中有没有“abc”,发现已经存在了，然后在接着去堆中进行创建这个对象，所以c指向的是堆中的“abc”地址； 

所以c==a是false。

3.3 string +操作

String b="好好学习"；

String c="天天向上"；

String a1=“我要”+b+c; 是在堆中新创建一个对象；生成过程是 String a= StringBuilder("我要").append(“好好学习”)

.append(“天天向上”)，toString();

String a2="我要好好学习"+"天天向上"； 编译期间运行的，被看做   “好好学习天天向上”；a1==a2 是false；

3.3 string stringbuffer 

（1）可变与不可变：String是不可变字符串对象，StringBuilder和StringBuffer是可变字符串对象（其内部的字符数组长度可变）。

（2）是否多线程安全：String中的对象是不可变的，也就可以理解为常量，显然线程安全。StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，只是StringBuffer 中的方法大都采用了synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是非线程安全的。

final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句编译不通过

final StringBuffer a = new StringBuffer("111");
a.append("222");//编译通过

可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。