Java源码分析之String

初学Java经常会误认为String是java基本类型，实际上String并非Java的8个基本类型，String本质上是对char数组的封装
下面对String源码进行分析

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

String类实现了Serializable，Comparable和CharSequence三个接口

Serializable是标记接口，用于标记实现此接口的类可以被序列化

Comparable：

package java.lang;

import java.util.*;

public interface Comparable<T> {

    public int compareTo(T o);
}

那么Comparable接口到底有什么用呢？简单的说，如果你想一个类的对象支持比较(排序)，那就必须要实现Comparable接口。此接口内部只有一个要重写的方法int compareTo(T o)，这个方法对两个字符串按字典排序的方式进行比较，返回两个字符串中第一个不同的字符的 ascii码差值

CharSequence：
是一个字符char序列，实现此接口的类有CharBuffer，String，StringBuffer(线程安全),StringBuilder(线程不安全)，那么CharSequence接口到底有什么用呢？
就拿String中的方法contains来说，注意它的参数是CharSequence s，由于StringBuffer和StringBuilder都实现了CharSequence，那么就可以直接用StringBuffer和StringBuilder传参，可以减少一次转换

下面开始说说String类的私有变量和构造函数

    /*
    这个私有变量说明了String最重要的两个点:
    1.char value[]表明String实质是以字符数组的形式存放的
    2.final关键字表明String一旦创建就无法改变，对于String的
    重新赋值都是重新划分内存空间，创建了新的String
    */
    private final char value[];
    //缓存String的hashCode值 默认为0
    private int hash;

    //Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的
    private static final long serialVersionUID = -6849794470754667710L;

    private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

public class Demo {
    public static void main(String[] args) throws Exception {
        String str1 = "abcd";
        System.out.println(str1);// abcd

        String str2 = new String();
        System.out.println(str2);//

        String str3 = new String("abcd");
        System.out.println(str3);// abcd

        char[] c = { 'a', 'b', 'c', 'd', 'e', 'f' };
        String str4 = new String(c);
        System.out.println(str4);// abcdef
        String str5 = new String(c, 2, 3);
        System.out.println(str5);// cde

        int[] a = { 65, 66, 67, 68, 97, 98 };
        String str6 = new String(a, 2, 3);
        System.out.println(str6);// CDa

        byte[] b = { 65, 66, 67, 68 };
        String str7 = new String(b, 1, 3, "ASCII");
        System.out.println(str7);// BCD
        String str8 = new String(b, 1, 3);
        System.out.println(str8);// BCD
        String str9 = new String(b, "ASCII");
        System.out.println(str9);// ABCD
        String str10 = new String(b);
        System.out.println(str10);// ABCD

        StringBuffer sb1 = new StringBuffer("abcd");
        String str11 = new String(sb1);
        System.out.println(str11);// abcd

        StringBuilder sb2 = new StringBuilder("abcde");
        String str12 = new String(sb2);
        System.out.println(str12);// abcde

    }

}

接下来分析String的核心方法

import java.util.Date;

public class Demo2 {
    public static void main(String[] args) throws Exception {
        String str1 = "abcde";
        System.out.println(str1.length());// 5 返回String的长度
        System.out.println(str1.isEmpty());// false 判断String是否为空
        System.out.println(str1.charAt(1));// b 返回value[index]
        System.out.println(str1.codePointAt(1));// 98
        System.out.println(str1.codePointBefore(1));// 97
        /*
         Java中超出char编码范围(65536)的unicode字符由两个char组成
         codePointCount()是准确计算unicode(而不是char)字符的数量的方法
        */
        System.out.println(str1.codePointCount(1, 3));// 2 返回1-3之间的码点值
        System.out.println(str1.offsetByCodePoints(1, 3));// 4 返回从1偏移3个码点后的索引

        char[] c = new char[10];
        str1.getChars(0, 3, c, 0);// 把value[0-3)的值复制到c中(从0开始存放)
        for (char d : c) {
            System.out.print(d + " ");// a b c
        }
        System.out.println();

        byte[] b1 = str1.getBytes("ASCII");
        for (byte b : b1) {
            System.out.print(b + " ");// 97 98 99 100 101
        }
        System.out.println();
        byte[] b2 = str1.getBytes();
        for (byte b : b2) {
            System.out.print(b + " ");// 97 98 99 100 101
        }
        System.out.println();

        // str1.equals(abc):false
        System.out.println("str1.equals(" + "abc" + "):" + str1.equals("abc"));

        boolean f1 = str1.contentEquals(new StringBuffer("abcde"));
        System.out.println("str1.equals(" + "abcde" + "):" + f1);// str1.equals(abcde):true

        boolean f2 = str1.contentEquals(new StringBuilder("ABCDE"));
        System.out.println("str1.equals(" + "ABCDE" + "):" + f2);// str1.equals(ABCDE):false

        // str1.equalsIgnoreCase(ABCDE):true
        boolean f3 = str1.equalsIgnoreCase("ABCDE");
        System.out.println("str1.equalsIgnoreCase(" + "ABCDE" + "):" + f3);

        String str3 = "abcdE";
        System.out.println(str1.compareTo(str3));// 32 e-E
        System.out.println(str1.compareToIgnoreCase(str3));// 0
        System.out.println(str1.compareTo("abcdefg"));// -2 5-7
        System.out.println(str1.compareToIgnoreCase("abcdefg"));// -2

        // str1.regionMatches(0, str3, 0, str3.length()):false
        boolean f4 = str1.regionMatches(0, str3, 0, str3.length());
        System.out.println("str1.regionMatches(0, str3, 0, str3.length()):"+ f4);

        // str1.regionMatches(true,0, str3, 0,str3.length()):true
        boolean f5 = str1.regionMatches(true, 0, str3, 0, str3.length());
        System.out.println("str1.regionMatches(true,0, str3, 0, str3.length()):"+ f5);

        // str1.startsWith(bc,1):true
        boolean f6 = str1.startsWith("bc", 1);
        System.out.println("str1.startsWith(" + "bc" + ", 1):" + f6);

        // str1.startsWith(ab):true
        boolean f7 = str1.startsWith("ab");
        System.out.println("str1.startsWith(" + "ab" + "):" + f7);
        // str1.endwith(de):true
        boolean f8 = str1.endsWith("de");
        System.out.println("str1.endwith(" + "de" + "):" + f8);

        /*
         3105 31*(31*0+97)+98
         实际上ab的hashCode值就是把ab从31进制转化为10进制的值
        */
        System.out.println("ab".hashCode());

        System.out.println("abacd".indexOf(97));// 0
        System.out.println("abcd".indexOf(99, 2));// 2
        System.out.println("abababa".lastIndexOf(97));// 6
        System.out.println("aba".lastIndexOf(98, 0));// -1
        System.out.println("aababcabcd".indexOf("abcd"));// 6
        System.out.println("aababcabcdabcd".indexOf("abcd", 7));// 10
        System.out.println("ababab".lastIndexOf("ab"));// 4

        System.out.println("ababab".lastIndexOf("ab", 5));// 4
        System.out.println("ababab".lastIndexOf("ab", 4));// 4
        System.out.println("ababab".lastIndexOf("ab", 3));// 2

        System.out.println(str1.substring(2));// cde
        System.out.println(str1.substring(1, 3));// bc
        System.out.println(str1.subSequence(1, 3));// bc

        System.out.println("to".concat("get").concat("her"));// together
        System.out.println("ababab".replace('b', 'c'));// acacac

        System.out.println(str1.matches("([a-zA-Z])+"));// true

        System.out.println("aababcabcd".contains("ab"));// true
        System.out.println("aababcabcd".replaceFirst("[a][b]", "AC"));// aACabcabcd
        System.out.println("aababcabcd".replaceAll("[a][b]", "AC"));// aACACcACcd
        System.out.println("aababcabcd".replace("ab", "AC"));// aACACcACcd

        String[] s1 = "boo:and:foo".split(":", 2);
        for (String string : s1) {
            System.out.print(string + " ");// boo and:foo n>0 pattern模式执行n-1次
        }
        System.out.println();

        String[] s2 = "boo:and:foo".split(":", -2);
        for (String string : s2) {
            System.out.print(string + " ");// boo and foo n<0 pattern模式执行无限次
        }
        System.out.println();

        String[] s3 = "boo:and:foo".split("o", -2);
        for (String string : s3) {
            System.out.print(string + " ");// b :and:f
        }
        System.out.println();

        String[] s4 = "boo:and:foo".split("o", 0);
        for (String string : s4) {
            // b :and:f n=0 pattern模式执行无限次并省略末尾的空字符串
            System.out.print(string + " ");                             
        }
        System.out.println();

        String[] s5 = "boo:and:foo".split("o");
        for (String string : s5) {
            System.out.print(string + " ");// b :and:f
        }
        System.out.println();

        System.out.println("abcde".toUpperCase());// ABCDE
        System.out.println("Abcd".toLowerCase());// abcd

        System.out.println(" a bc de ".trim());// a bc de

        char[] c2 = str1.toCharArray();
        for (char d : c2) {
            System.out.print(d + " ");// a b c d e
        }
        System.out.println();

        System.out.println(String.format("%tF", new Date()));// 2017-09-02

        String str6 = null;
        // System.out.println(str6.toString()); //NullPointerException
        System.out.println(String.valueOf(str6));// null

    }

}

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class Demo3 {
    @Test
    public void fun1() {
        System.out.println(String.join("-", "java", "is", "cool"));// java-is-cool

        List<String> list = new ArrayList<String>();
        list.add("java");
        list.add("is");
        list.add("cool");
        System.out.println(String.join(" ", list));// java is cool
    }
}

源码分析：

1. equals方法

public boolean equals(Object anObject) {
        // 1.判断是否==,是就直接返回true(==的要求比equals更加严格)
        if (this == anObject) {
            return true;
        }
        // 2.判断anObject是否为String,是 接着判断 否则返回false
        if (anObject instanceof String) {

            String anotherString = (String) anObject;
            int n = value.length;
            // 3.判断二者长度是否一样,是就接着判断,否则返回false
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                // 4.依次比较所有元素,全部一样返回true，否则返回false
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

2. 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) {
        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;
    }

3. compareTo方法

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        //1.得到两个字符串长度的最小值lim
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        /*
         2.在0-lim范围内依次比较所有元素
           返回第一个不相同的char的差值(如果有的话)
        */
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        //3.否则返回字符串长度的差值
        return len1 - len2;
    }

4 . startsWith方法

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;

        //1.检查边界
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
        //2.从to开始依次比较pc次 出现一次不一样返回false 否则返回true
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

5. indexOf和lastIndexOf方法

beautiful code !

public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length, str.value, 0, str.value.length,
                fromIndex);
    }


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++) {

            if (source[i] != first) {
                while (++i <= max && source[i] != first)
                    ;
            }

            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) {

                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

public int lastIndexOf(String str, int fromIndex) {
        return lastIndexOf(value, 0, value.length, str.value, 0,
                str.value.length, fromIndex);
    }



static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount, int fromIndex) {

        int rightIndex = sourceCount - targetCount;
        if (fromIndex < 0) {
            return -1;
        }
        if (fromIndex > rightIndex) {
            fromIndex = rightIndex;
        }

        if (targetCount == 0) {
            return fromIndex;
        }

        int strLastIndex = targetOffset + targetCount - 1;
        char strLastChar = target[strLastIndex];
        int min = sourceOffset + targetCount - 1;
        int i = min + fromIndex;

        startSearchForLastChar: while (true) {
            while (i >= min && source[i] != strLastChar) {
                i--;
            }
            if (i < min) {
                return -1;
            }
            int j = i - 1;
            int start = j - (targetCount - 1);
            int k = strLastIndex - 1;

            while (j > start) {
                if (source[j--] != target[k--]) {
                    i--;
                    continue startSearchForLastChar;
                }
            }
            return start - sourceOffset + 1;
        }
    }

6. replace方法

public String replace(char oldChar, char newChar) {
        //1.判断oldChar和newChar是否一样 是就返回this 否则继续
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; 

            //2.找到第一个是oldChar的索引i
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                //3.复制i之前的元素到buf中
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                //4.对i以及i之后的元素进行替换
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

7. split方法

public String[] split(String regex, int limit) {

        char ch = 0;
        if (((regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
             (regex.length() == 2 &&
              regex.charAt(0) == '\\' &&
              (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
              ((ch-'a')|('z'-ch)) < 0 &&
              ((ch-'A')|('Z'-ch)) < 0)) &&
            (ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE))
        {
            int off = 0;
            int next = 0;
            boolean limited = limit > 0;
            ArrayList<String> list = new ArrayList<>();
            while ((next = indexOf(ch, off)) != -1) {
                if (!limited || list.size() < limit - 1) {
                    list.add(substring(off, next));
                    off = next + 1;
                } else {  
                    list.add(substring(off, value.length));
                    off = value.length;
                    break;
                }
            }

            if (off == 0)
                return new String[]{this};


            if (!limited || list.size() < limit)
                list.add(substring(off, value.length));


            int resultSize = list.size();
            if (limit == 0) {
                while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                    resultSize--;
                }
            }
            String[] result = new String[resultSize];
            return list.subList(0, resultSize).toArray(result);
        }
        return Pattern.compile(regex).split(this, limit);
    }

8. trim方法

public String trim() {
        int len = value.length;
        int st = 0;
        //可以提高性能
        char[] val = value;

        //1.从左向右遍历空白，得到第一个不是空白的索引st
        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        //2.从右向左遍历空白，得到最后一个空白的索引len
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        //3.通过substring(st,len)返回结果
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

9. intern方法

    /*
    A native method is a Java method whose implementation is provided by non-java code
    在Java中，用双引号声明出来的String对象会直接存储在常量池中。如果不是用双引号声明的String对象，可
    以使用String提供的intern方法。intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会
    把当前字符串放入常量池中，再返回。
    */
    public native String intern();