String

final类,也就是无法被继承, 底层实际是 final char[] value ，享元模式最经典的存在。 所以存在于常量池中，并且不可改变，所以是线程安全的。 (jdk8之后常量池取消) 。 存储于常量池中, 可以直接用=赋值(java特殊处理)， 赋值时先会去常量池查找，没有则新建。 几乎所有操作在底层都是将char[] 复制备份之后在进行操作，并最终new String 已保证常量性. 可能引发内存泄漏。

之前的java版本引发内存泄漏的著名方法就是 不断new String的新对象，现在应该已经修复了此问题。

String : 

    StringBuffer : 线程安全的字符串变量，内容长度都可被修改，多个线程可以安全的访问StringBuffer对象

    StringBuilder ： 非线程安全的字符串变量，在单线程使用时，效率略高于StringBuffer,JDK 1.5之后加入

一些方法的源码 :

// subString: 实际还是截取一段字符串，然后new 一个新的string
public String substring(int beginIndex) {
        if (beginIndex < 0) {//初始位置不能为负
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;//初始位置不能大于串长度
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {//结尾位置不能大于串长度
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;//结尾位置必须大于开始位置
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
 }

最著名的equals : 

 // equals: 判断字符串相同
 public boolean equals(Object anObject) {
        if (this == anObject) { // 如果是自己 那肯定是一致的
            return true;
        }
        if (anObject instanceof String) { // 是否是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;
    }

忽略大小写的equals :

equalsIgnoreCase:忽略大小写
    public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
 }

 public boolean regionMatches(boolean ignoreCase, int toffset,
            String other, int ooffset, int len) { // 是否忽略大小写，偏移量， 要比较的string，偏移量，要比较的长度
        char ta[] = value;
        int to = toffset;
        char pa[] = other.value;
        int po = ooffset;
      
        // 偏移量的验证 
        if ((ooffset < 0) || (toffset < 0)
                || (toffset > (long)value.length - len)
                || (ooffset > (long)other.value.length - len)) {
            return false;
        }
        // 开始逐个对比
        while (len-- > 0) {
            char c1 = ta[to++];
            char c2 = pa[po++];
            if (c1 == c2) {
                continue;
            }
            if (ignoreCase) {//如果忽略大小写
                char u1 = Character.toUpperCase(c1);//都变大写在比较
                char u2 = Character.toUpperCase(c2);
                if (u1 == u2) {
                    continue;
                }
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;//都变小写在比较一次，多次判定
                }
            }
            return false;
        }
        return true;
    }