签名

{NBRL0XUZ1Z0B}UJT2MQVKX.png

可以看到：

1.实现了io流的Serializable接口，用于表明String类的对象可被序列化.String在实现了Serializable接口之后，所以支持序列化和反序列化支持。Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidCastException).
2.实现Comparable接口，用于表明String类的对象进行整体排序，定义的泛型为String类，说明给Comparable的数据类型只能是String类
3.实现CharSequence接口，用于表明char值得一个可读序列。此接口对许多不同种类的char序列提供统一的自读访问。

Comparable接口

接口里有一个方法:
             public int compareTo(T o);
   我们可以重写compareTo方法进行修改。

CharSequence接口：

int length（）;
char charAt（int index）;
CharSequence subSequence（int start，int end）;
public String toString();
public default IntStream chars(){

}
这些方法主要是对有序字符集合的操作。

设计理念

  private final char value[];

本质：理解为char[]
原因：
1.定义成员变量为char[]数组
2.构造函数是以char[]数组为参数，直接copy,并没有进行编码coding.

String类的特点

>不变形

-由代码中对于value[]变量的修饰符public final可知value[]变量一经初始化便无法再修改 。因此说String是不可变的。
-字符串池(String pool)的需求在Java中，当初始化一个字符串变量时，如果字符串已经存在，就不会创建一个新的字符串变量， 而是返回存在的字符串的引用。例如：String string1 = "abcd";String string2 = "abcd";这两行代码在堆中只会创建一个字符串对象。如果字符串是可变的，改变另一个字符串变量，就会使另一个字符串变量指向错误的值。
-缓存字符串hashcode码的需要，字符串的hashcode是经常被使用的，字符串的不变形确保了hashcode的值一直是一样的，在需要hashcode时，就不需要每次都计算，这样会很高效。
-出于安全性考虑，字符串经常作为网络连接、数据库连接等参数，不可变就可以保证连接的安全性。
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */

        while (++i < len) {
            if (val[i] == oldChar) {
                break;
            }
        }
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            return new String(buf, true);
        }
    }
    return this;
}

可以明显的看出若无变化返回原对象，若有变化则new String返回一个新的对象

源码剖析：

首先从构造器来说，定义了十四个构造器。

public String(){}为了对定义的value数组赋值。
public String(Sting original){}对参数的hash值和value数组赋值
public String(char value[]){}调用Arrays.copyof()方法对定义好的value[]赋值    
public String(char value[],int offset,int count{}分配一个新的字符串，offset是第一个字符的索引子数组，count是指定数组的长度。随后修改的字符数组不影响新创建的字符串。
public String(int[] codePoints,int offset,int count){}子数组内容的转换。
public String(byte bytes[],int offset,int length,String charsetName){},public String(byte byte[],int offset,int length,Charset charset){},public String(byte byte[],String charsetName){},public String(byte byte[],Charset charset){},public String(byte byte[],ing offset,int length){} 这几个构造器调用StringCoding.decode()方法进行解码，使用的解码的字符集就是我们指定的charset和charsetName.
public String(byte byte[]){}在java中，String实例中保存有一个char[]字符数组，char[]字符数组是以unicode码来存储的，String和char为内存形式。byte是网络传输或存储的序列化形式，所以在许多传输和存储的过程中需要将byte[]数组和String进行相互转化。所以String提供了一系列重载的构造方法来将一个字符数组转化为String。
public String(StringBuffer buffer){}运用了synchronized同步锁，为了让程序同时访问一个对象时，先执行完一个后再执行一个。
public String(StringBuilder builder){}这两个构造器运用StringBuffer和StringBuilder并调用他们的toString方法转化成String。

接着我们从说类中的方法:

  public int length(){},public boolean isEmpty(){}这两个方法是对字符串长度进行说明。
  public char charAt(int index){}对字符串的索引位置，调出char数组索引位置的数据。
  public int codePointAt(int index){}此方法返回字符的代码点值的索引。（Unicode代码点）
  public int codePointCount(int beginIndex,int endIndex){}此方法返回在指定文本范围内的Unicode代码点。
  pubic int offsetByCodePoints(int index,int codePointOffset){}codePointOffset参数表示代码点的偏移量，此方法返回在此字符串的索引。
  void getChars(char dest[],int dstBegin){}实现字符串的字符复制。
  public void getChars(int srcBegin,int srcEnd,char dst[],int dstbegin){}实现范围性的字符串的字符复制。
  public byte[] getBytes(String charsetName){},public byte[] getBytes(Charset charset){},public byte[] getBytes(){} String提供了三个getBytes的重载方法，在创建String的时候可以使用byte[]数组，将一个字节数组转化成字符串，同样我们使用重载方法可以将字符串转化成字节数组。为了我们在不同平台上转化成Byte[]数组的结果一样，我们就需要指定相同的编码方式charsetName。

以下这些是对比方法：

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;
} 首先进行当前对象和要判断的对象是不是同一个对象，如果是则返回true。接着判断要判断的对象是不是String类的实例，如果是，接着转化类型判断两个字符串的长度，如果一样，进行char数组[]的逐一比较。
public boolean contentEquals(StringBuffer sb){}、 public boolean contentEquals(CharSequence cs){}这是contentEquals的两个重载方法,StringBuffer考虑到多线程的安全问题，使用的同步代码锁后再次调用contentEquals(StringBuffer sb)和nonSyncContentEquals(AbstractStringBuilder sb){}
private boolean nonSyncContentEquals(AbstractStringBuilder sb){}定义两个char[]数组，随后判断数组和字符串的长度之后的实现和equals的实现一样。
public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true
            : (anotherString != null)
            && (anotherString.value.length == value.length)
            && regionMatches(true, 0, anotherString, 0, value.length);
}使用了三元运算符和&&代替了多个if语句。调用了regionMatches()是这个比较方法忽略了大小写。

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;
}先通过比较两个字符串的长度将最小的长度赋值给lim,接着将字符串赋值给两个字符数组，在0~lim范围内进行字符数组的逐一判断，如果有一个不相等则返回两个字符的ASCII码的差值，如果循环结束都相等则返回两个长度的差值。

内部类

private static class CaseInsensitiveComparator
        implements Comparator<String>, java.io.Serializable {}

实现了定义为String类泛型的Comparator接口，实现了可序列化接口。
重写了Comparator接口里的compare方法。

hashCode

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

hashCode其实就是使用数学公式：s[0]31^(n-1) + s[1]31^(n-2) + ... + s[n-1]

所谓“冲突”，就是在存储数据计算hash地址的时候，我们希望尽量减少有同样的hash地址。如果使用相同hash地址的数据过多，那么这些数据所组成的hash链就更长，从而降低了查询效率。
所以在选择系数的时候要选择尽量长的系数并且让乘法尽量不要溢出的系数，因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会越高。

现在很多虚拟机里面都有做相关优化，使用31的原因可能是为了更好的分配hash地址，并且31只占用5bits。

在Java中，整型数是32位的，也就是说最多有2^32= 4294967296个整数，将任意一个字符串，经过hashCode计算之后，得到的整数应该在这4294967296数之中。那么，最多有 4294967297个不同的字符串作hashCode之后，肯定有两个结果是一样的。

hashCode方法可以保证相同的字符串具有相同的hash值。但是hash值相同并不一定是字符串的value值相同。