Java_String_源码

0x01:String属于java.lang包里的类

0x02:String是一个final类，实现了Serializable,Comparable,CharSequence接口

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

• Serializable 该接口没有任何方法和成员，用于标识序列化。
• Comparable 该接口只有一个compareTo(T 0)方法，用于比较两个对象大小。
• CharSequence 该接口是一个只读的字符序列。包括length(), charAt(int index), subSequence(int start, int end)这几个接口方法。

0x03:主要成员变量

private final char value[];//用于存储string的所有字符
    private int hash; // hash值
    public static final Comparator<String> CASE_INSENSITIVE_ORDER= new CaseInsensitiveComparator();//忽略大小写得比较两个字符串

• String 变量的值在内存中的根本形式就是一个char数组
• 由于String常常用来做比较，所以便把hash存储下来
• CASE_INSENSITIVE_ORDER用于比较两个忽略大小写的字符串

0x04:内部类

private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable {
        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) {
                            return c1 - c2;// No overflow because of numeric promotion
                        }
                    }
                }
            }
            return n1 - n2;
        }
        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }
  public static final Comparator<String> CASE_INSENSITIVE_ORDER= new CaseInsensitiveComparator();

• 和String.compareTo()方法相比，此方法在比较时是忽略大小写的。使用了{静态内部类}单例模式，可以很容易的用它来比较两个String。
• 可以看到String类中提供的compareToIgnoreCase方法其实就是调用这个内部类里面的方法实现的。从而实现代码复用。

0x05:众多的构造函数

无参数的构造函数{直接引用""的地址}

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

String类型参数的构造函数{直接引用原String的地址}

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

char数组的拷贝的构造函数

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

public String(char value[], int offset, int count) {
        //安全性考虑
        if (offset < 0) {throw new StringIndexOutOfBoundsException(offset);}
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

由int数组转化的构造方法

public String(int[] codePoints, int offset, int count) {
         //安全性考虑的代码部分
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= codePoints.length) {
                this.value = "".value;
                return;
            }
        }
        if (offset > codePoints.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        //安全性考虑结束
        final int end = offset + count;
        // Pass 1: Compute precise size of char[]
        int n = count;
        for (int i = offset; i < end; i++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                continue;
            else if (Character.isValidCodePoint(c))
                n++;
            else throw new IllegalArgumentException(Integer.toString(c));
        }

        // Pass 2: Allocate and fill in char[]
        final char[] v = new char[n];

        for (int i = offset, j = 0; i < end; i++, j++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                v[j] = (char)c;
            else
                Character.toSurrogates(c, v, j++);
        }
        this.value = v;
    }

• 这是一个把unicode编码的int类型的数组转换为String的构造函数
• unicode的合理取值范围现在扩展到了0x0000-0x10ffff,一共21位，二进制 0000 0000 0000 0001 0000 1111 1111 1111 1111
• java中的char是两个字节的，也就是16位。最大值就是0xffff,就是二进制 1111 1111 1111 1111
• unicode中 0x0000-0xffff 被称作BMP(Basic Multilingual Plane)，char只能表示BMP
• 值大于0xffff的字符称为增补字符
• char只能表示BMP，而int的范围甚至超出了unicode的合理取值范围

判断codePoint是否BMP

public static boolean isBmpCodePoint(int codePoint) {
        return codePoint >>> 16 == 0;//无符号右移
    }

• 判断是不是BMP，如果是的话，一个char就能放下，就不需要增加空间。如果不是的话，先验证是否在unicode的合理取值范围内。如果是的话，说明一个char的空间存不下，再申请一个，如果超出了合理取值范围就抛异常。
• 判断方法同BMP

public static final int MAX_CODE_POINT = 0X10FFFF;
public static boolean isValidCodePoint(int codePoint) {
        int plane = codePoint >>> 16;//无符号右移
        return plane < ((MAX_CODE_POINT + 1) >>> 16);
         //0x10FFFF ===   0001 0000 1111 1111 1111 1111
         //0x110000 ===   0001 0001 0000 0000 0000 0000  {MAX_CODE_POINT + 1}
         //0x11   0001 0001                         (MAX_CODE_POINT + 1) >>> 16
    }

toSurrogates(c, v, j++)方法将大于BMP范围但是是unicode合理范围的codePoint，处理成两个char，分别为高位代理和低位代理，Charater类中有对应的方法，判断是否为代理，是否为高位代理，是否为低位代理，是否为代理对，将一对代理转换为一个codePoint

static void toSurrogates(int codePoint, char[] dst, int index) {
        dst[index+1] = lowSurrogate(codePoint);
        dst[index] = highSurrogate(codePoint);
    }

   public static final char MIN_LOW_SURROGATE  = '\uDC00';

   public static char lowSurrogate(int codePoint) {
        return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
    }

  public static final char MIN_HIGH_SURROGATE = '\uD800'；
  public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;

  public static char highSurrogate(int codePoint) {
        return (char) ((codePoint >>> 10)+
        (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
    }

ascii数组的构造方法

//hibyte(高8位)
  @Deprecated
    public String(byte ascii[], int hibyte, int offset, int count) {
        checkBounds(ascii, offset, count);
        char value[] = new char[count];

        if (hibyte == 0) {
            for (int i = count; i-- > 0;) {
                value[i] = (char)(ascii[i + offset] & 0xff);
            }
        } else {
            hibyte <<= 8;
            for (int i = count; i-- > 0;) {
                value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
            }
        }
        this.value = value;
    }

bytes数组构造String

public String(byte bytes[], int offset, int length, String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        checkBounds(bytes, offset, length);
        this.value = StringCoding.decode(charsetName, bytes, offset, length);
    }

StringBuffer构造String(线程安全)

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

StringBuilder构造String

public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

0x06:常用的方法

java.lang.String对象中封装方法非常多，仅针对常用方法源代码进行分析。如：equals()，replace(), indexOf()，startsWith()，compareTo()，regionMathes()，hashCode()。

public boolean equals(Object anObject)

比较两对象存储内容是否相同。采用排除法比较，算法更优：
(1)是不是同一个对象，如果是同一个对象，则两个字符串肯定相等。
(2)如果都不是String,也没法比较，直接不相等
(3)如果长度都不相等,肯定也就不相等了
(4)从第一个字符开始比较，如果有字符不相等，则直接就不相等了，就没必要继续比较下去了。

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 String replace(CharSequence target, CharSequence replacement)

该方法是我们通常意义所用到的 public String replace(String target, String replacement) ，String实现了CharSequence接口。方法内部调用正则表达式匹配替换来实现。

public String replace(CharSequence target, CharSequence replacement) {
       return Pattern.compile(target.toString(), Pattern.LITERAL).matcher( this)
.replaceAll(Matcher.quoteReplacement(replacement.toString());
   }

public int indexOf(str)

该方法是找出目标字符串是第一次出现指定子字符串的位置，若不存在，则返回-1，若存在，则返回位置坐标。具体实现是调用 static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) 方法。先对目标字符串中出现子字符串的位置可能范围，然后在此范围中遍历找出与子字符串第一个字符相同的位置，并对后面字符进行比较分析。

public int indexOf(String str) {
         return indexOf(str, 0);
     }
     public int indexOf(String str, int fromIndex) {
         return indexOf(value, 0, value.length,
                 str.value, 0, str.value.length, fromIndex);
     }
 
     /**
      * Code shared by String and StringBuffer to do searches. The
      * source is the character array being searched, and the target
      * is the string being searched for.
      *
      * @param   source       the characters being searched.
      * @param   sourceOffset offset of the source string.
      * @param   sourceCount  count of the source string.
      * @param   target       the characters being searched for.
      * @param   targetOffset offset of the target string.
      * @param   targetCount  count of the target string.
      * @param   fromIndex    the index to begin searching from.
      */
     static int indexOf(char[] source, int sourceOffset, int sourceCount,
             char[] target, int targetOffset, int targetCount,
             int fromIndex) {
         if (fromIndex >= sourceCount) {
             return (targetCount == 0 ? sourceCount : -1);
         }
         if (fromIndex < 0) {
             fromIndex = 0;
         }
         if (targetCount == 0) {
             return fromIndex;
         }
 
         char first = target[targetOffset];
         int max = sourceOffset + (sourceCount - targetCount);
 
         for (int i = sourceOffset + fromIndex; i <= max; i++) {
             /* Look for first character. */
             if (source[i] != first) {
                 while (++i <= max && source[i] != first);
             }
 
             /* Found first character, now look at the rest of v2 */
             if (i <= max) {
                 int j = i + 1;
                 int end = j + targetCount - 1;
                 for (int k = targetOffset + 1; j < end && source[j]
                         == target[k]; j++, k++);
 
                 if (j == end) {
                     /* Found whole string. */
                     return i - sourceOffset;
                 }
             }
         }
         return -1;
     }

public int compareTo(String anotherString)

该方法是对字符串集合进行排序的基础，通过此方法可比较两字符串大小

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

public boolean startsWith(String prefix)

public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;
        int to = toffset;
        char pa[] = prefix.value;
        int po = 0;
        int pc = prefix.value.length;
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }

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

hash常常用来判断两个字符串相等或者回文。一个String的hash值=s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
关于为什么取31为权，可以参考StackOverflow上的这个问题
主要是因为31是一个奇质数，所以31*i=32*i-i=(i<<5)-i，这种位移与减法结合的计算相比一般的运算快很多。

...to be continue.