死磕JDK源码之String

String本质是对char数组的封装

Serializable接口

实现Serializable接口的类可以被序列化

Comparable接口

实现Comparable接口的类可以支持排序，需要重写的compareTo方法返回两个字符串中第一个不同的字符的ASCII码差值

CharSequence接口

多态，String、StringBuffer及StringBuilder均实现了CharSequence接口，可以减少传参时的类型转换

String私有变量

/*
1.char value[]表明String实质是以字符数组的形式存放的
2.final关键字表明String一旦创建就无法改变，对于String
的重新赋值都是重新划分内存空间，创建了新的String
 */
private final char value[];

//缓存String的hashCode值 默认为0
private int hash;

String构造函数

public class Demo1 {
    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();
        System.out.println(str1.equals("abc"));//false
        System.out.println(str1.contentEquals(new StringBuffer("abcde")));//true
        System.out.println(str1.contentEquals(new StringBuilder("ABCDE")));//false
        System.out.println(str1.equalsIgnoreCase("ABCDE"));//true
        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
        System.out.println(str1.regionMatches(0, str3, 0, str3.length()));//false
        System.out.println(str1.regionMatches(true, 0, str3, 0, str3.length()));//true
        System.out.println(str1.startsWith("bc", 1));//true
        System.out.println(str1.startsWith("ab"));//true
        System.out.println(str1.endsWith("de"));//true
        /*
         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-12-04
        String str6 = null;
        // System.out.println(str6.toString()); //NullPointerException
        System.out.println(String.valueOf(str6));// null
    }
}

join

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

部分方法源码分析 

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

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

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

indexOf

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

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

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

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

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();