JDK源码阅读——String

String类概述
    1.java.lang.String
    2.继承关系：Serializable ， CharSequence ， Comparable < String > 
    3.字符串是常量，一旦创建，不允许被修改。
      字符串对象时不可修改的，因此可以被共享
    
一、继承关系    
    1.继承java.io.Serializable,可被序列化
    2.继承 java.lang.Comparable<T>,重写了compareTo方法
    3.继承CharSequence

二、主要变量

 /** The value is used for character storage. */
 // char[] 数组用来存储字符串内容
    private final char value[];

    /** Cache the hash code for the string */
    // hash用来存放字符串的hashcode,当做缓存使用
    private int hash; // Default to 0

    //提供一个compare方法，与compare区别是 这个方法不区分字符的大小写
　　public static final Comparator<String> CASE_INSENSITIVE_ORDER
        = new CaseInsensitiveComparator();

三、构造函数
    1.String()
    初始化新创建的String对象，使其表示空字符序列。注意，使用此构造函数是不必要的，因为Strings是不可变的。

public String() {
        this.value = "".value;
    }

    2.String(String original) 
    初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
    除非需要original的显式副本， original使用此构造函数是不必要的，因为Strings是不可变的。
    我们平时String str = "abc" 就是调用的这个构造方法。

    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

在此说一下 ==、equeals方法
equeals方法：比较内容是否一致
==比较引用地址是否一致

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc")

s1.equeals(s2)  s1.equeals(s3) => true,true  三个字符串内容一致，没有异议
s1==s2 true s1==s3 false 
s1和s2是常量池中的同一对象。
s3是s1的副本，被强制新建了对象，也就是产生了新的引用。

    3.String(char[] value)
    分配一个新的String ，以便它表示当前包含在字符数组参数中的字符序列。 字符数组的内容被复制; 字符数组的后续修改不会      影响新创建的字符串。

 public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

    4.String(byte bytes[]，int offset,int length,Stirng charsetName)

/**
    将字节数组转化为字符串
    后续处理还是将字节先转化为char
    nio这块还没有了解，后续学习吧
*/   

 public String(byte bytes[], int offset, int length, String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        //判断是否越界 offset+length=bytes.lenth
        checkBounds(bytes, offset, length);
         //设置编码格式，默认为 ISO-8859-1
        this.value = StringCoding.decode(charsetName, bytes, offset, length);
    }
 

其他构造函数其实跟上面几个构造函数类似。涉及char[]的 调用的是Arrays.copyof类似方法。
四、方法

1.compareToIgnoreCase 和 compareTo方法

//compareToIgnoreCase方法 
/**
  为何要用内部类？

   1.   内部类一般只为其外部类使用；

   2.   内部类提供了某种进入外部类的窗户；

   3.   也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。
*/
public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    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; }
    }

//CompareTo方法
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

    

compareToIgnoreCase方法实际调用的CaseInsensitiveComparator静态内部类的compare方法。
通过compareTo方法，我们先看一下字符串比较的算法：
字符串比较其实是返回char[]相同位置不同字符ASCII码的差值，若相同位置字符都一致，返回两个char数组长度差。compareToIgnoreCase方法也是在以上基础上：
字符串忽略大小写比较其实是返回char[]相同位置不同字符(包括大写不同、小写不同)ASCII码的差值，若相同位置字符都一致，返回两个char数组长度差。

2.equals方法、hashCode方法
通过方法可以看出，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;
    }

//hash的初始值为0，当调用过hashCode方法后，hash值被赋值，之后就不用再重新计算hash值了 
 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;
    }

 

3.trim方法

//从源码可看出，' '的ASCII在我们使用的字符中应该是最小的临界值
//substring方法底层实际还是arryCopy方法,中间调用了String的构造函数，产生了一个新的字符串对象
public String trim() {
    int len = value.length;
    int st = 0;
    char[] val = value;    /* avoid getfield opcode */

    while ((st < len) && (val[st] <= ' ')) {
        st++;
    }
    while ((st < len) && (val[len - 1] <= ' ')) {
        len--;
    }
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}

重点在于char[]数组，和Character类，这块还没有学习过源码，后续自己学习后再补充。

仅供督促自己学习使用，类似不错的博客欢迎阅读

https://www.cnblogs.com/listenfwind/p/8450241.html