String源码的自我解读

1. Stirng的修饰符和实现类

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

• final修饰符
  • String不能被继承
  • 成员方法都默认是final修饰的方法
  • 类一旦创建就无法改变，对String对象的任何操作，不会影响到原对象
• Serializable ,Comparable, CharSequence接口

2. String类的成员变量

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    
    private final char value[];

    private int hash; // Default to 0

    private static final long serialVersionUID = -6849794470754667710L;

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

• String是通过char数组来保存字符串的
• hash值用来hashCode()方法的计算
• serialVersionUID属性作为String类的序列化ID
• serialPersistentFields属性
  • 属于JAVA序列化的内容，应该清楚transient是用于指定哪个字段不被默认序列化，对于不需要序列化的属性直接用transient修饰即可。而serialPersistentFields用于指定哪些字段需要被默认序列化，具体用法如下：
  • 如果同时定义了serialPersistentFields与transient，transient会被忽略。

private static final ObjectStreamField[] serialPersistentFields = {
    new ObjectStreamField("name", String.class),
    new ObjectStreamField("age", Integer.Type)
}

3. 创建String对象

• 直接使用"",就是使用"字面量"赋值

String name = "bruis";

• 使用连接符"+"来赋值

String name = "ca" + "t";

• 使用关键字new来创建对象

String name = new String("bruis");

• 除了上面常见的，还有：
  • 使用clone()方法
  • 使用反射
  • 使用反序列化

4. String被设计为不可变性的原因

• 主要是为了“效率”和“安全性”的缘故，若String允许被继承，由于高度被使用率，可能会降低程序的性能，所以String被定义为final。
• 由于字符串常量池的存在，为了更有效的管理和优化字符串常量池里的对象，将String设计为不可变性。
• 为了安全性考虑。因为使用字符串的场景非常多，设计成不可变可以有效的防止字符串被有意或者无意的篡改。
• 作为HashMap、HashTable等hash型数据key的必要。因为不可变的设计，jvm底层很容易在缓存String对象的时候缓存其hashcode，这样再执行效率上会大大提升。

5. 了解一下JAVA内存区域

JAVA的运行时数据区包括以下几个区域：

方法区（Method Area）
Java堆区（Heap）
本地方法栈（Native Method Stack）
虚拟机栈（VM Stack）
程序技术器（Program Conter Register）

• 总结内容：
  • 字符串常量池再每个VM中只有一份，存放的是字符串常量的值。
  • 字符串常量池——string pool，也叫做string literal pool。
  • 字符串池里的内容是在类加载完成，经过验证，准备阶段之后再堆中生成字符串对象实例，然后将该字符串对象示例的引用值存到string pool中。
  • string pool中存的是值而不是具体的实例对象，具体的实例对象实在堆中开辟的一块空间存放的。

6. String与JAVA内存区域

public class TestString {
	public static void main(String[] args) {
		String name = "bruis";
		String name2 = "bruis";
		String name3 = new String("bruis");
		//System.out.println("name == name2 : " + (name == name2));// true
		//System.out.println("name == name3 : " + (name == name3));// false
	}
}

• 因为语句String name = “bruis”;已经将创建好的字符串对象存放在了常量池中，所以name引用指向常量池中的"bruis"对象，而name2就直接指向已经存在在常量池中的"bruis"对象，所以name和name2都指向了同一个对象。这就能理解为什么name == name2 为true了。

• 使用new 方式创建字符串。首先会在堆上创建一个对象，然后判断字符串常量池中是否存在字符串的常量，如果不存在则在字符串常量池上创建常量；如果存在则不作任何操作。所以name是指向字符串常量池中的常量，而name3是指向堆中的对象，所以name == name3 为false。

• java中使用"+"连接符时，效率非常低下，底层是通过StringBuilder.append()来实现的，所以如：String name = “a” + “b”;在底层是先new 出一个StringBuilder对象，然后再调用该对象的append()方法来实现的

7. javap命令

• javap 命令能对class文件进行反编译，能够对照源代码和字节码，从而了解很多编译器内部的工作

8. String的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;
    }

• equals方法比较是"字符串对象的地址"，如果不相同则比较字符串的内容，实际也就是char数组的内容。

9. String的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;
    }

• String类中，有个字段hash存储着String的哈希值，如果字符串为空，则hash的值为0。String类中的hasCode计算方法就是以31为权，每一位为字符的ASCII值进行运算，用自然溢出来等效取模，经过第一次的hashcode计算之后，属性hash就会赋哈希值。计算公式如下：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

10. String的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;
    }

• 这方法时先比较两个字符串内的字符串数组的ASCII值，如果最小字符串都比较完了都还是相等的，则返回字符串长度的差值；否则在最小字符串比较完之前，字符不相等，则返回不相等字符的ASCII值差值。

11. String的startWith(String prefix)方法

public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }
    
    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;
    }

• 如果参数字符序列是该字符串字符序列的前缀，则返回true；否则返回false；

11. String的endsWith(String suffix)方法

 public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }

• 其实endsWith()方法就是服用了startsWith()方法而已，传进的toffset参数值时value和suffix长度差值。

12. String的indexOf(int ch)方法

public int indexOf(int ch) {
        return indexOf(ch, 0);
    }

    public int indexOf(int ch, int fromIndex) {
        final int max = value.length;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= max) {
            // Note: fromIndex might be near -1>>>1.
            return -1;
        }

        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            final char[] value = this.value;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == ch) {
                    return i;
                }
            }
            return -1;
        } else {
            return indexOfSupplementary(ch, fromIndex);
        }
    }

• String的indexOf(int ch)方法，查看其源码可知其方法入参为ASCII码值，然后和目标字符串的ASCII值来进行比较的。其中常量Character.MIN_SUPPLEMENTARY_CODE_POINT表示的是0x010000——十六进制的010000，十进制的值为65536，这个值表示的是十六进制的最大值。
• 下面再看看indexOfSupplementary(ch, fromIndex)方法

private int indexOfSupplementary(int ch, int fromIndex) {
        if (Character.isValidCodePoint(ch)) {
            final char[] value = this.value;
            final char hi = Character.highSurrogate(ch);
            final char lo = Character.lowSurrogate(ch);
            final int max = value.length - 1;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == hi && value[i + 1] == lo) {
                    return i;
                }
            }
        }
        return -1;
    }

• java中特意对超过两个字节的字符进行了处理，例如emoji之类的字符。处理逻辑就在indexOfSupplementary(int ch, int fromIndex)方法里。

• Character.class

public static boolean isValidCodePoint(int codePoint) {
        // Optimized form of:
        //     codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT
        int plane = codePoint >>> 16;
        return plane < ((MAX_CODE_POINT + 1) >>> 16);
    }

• 对于方法isValidCodePoint(int codePoint)方法，用于确定指定代码点是否是一个有效的Unicode代码点。代码

int plane = codePoint >>> 16;
return plane < ((MAX_CODE_POINT + 1) >>> 16);

• 表达的就时判断codePoint是否在MIN_CODE_POINT和MAX_CODE_POINT值之间，如果是则返回true，否则返回false。

12. String的split(String regex, int limit)方法

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;
            // 如果limit > 0，则limited为true
            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 {    // last one
                    // limit > 0，直接返回原字符串
                    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);
    }

split源码内容分析

• if判断中第一个括号先判断一个字符的情况，并且这个字符不是任何特殊的正则表达式。也就是下面的代码：

(regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1)

• 如果要根据特殊字符来截取字符串，则需要使用\来进行字符转义。
• 在if判断中，第二个括号判断有两个字符的情况，并且如果这两个字符是以\开头的，并且不是字母或者数字的时候。如下列代码所示：

(regex.length() == 2 && regex.charAt(0) == '\\' && (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 && ((ch-'a')|('z'-ch)) < 0 && ((ch-'A')|('Z'-ch)) < 0)

• 判断完之后，在进行第三个括号判断，判断是否是两字节的unicode字符。如下列代码所示：

(ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE)

• 示例1：

String splitStr1 = "what,is,,,,split";
String[] strs1 = splitStr1.split(",");
for (String s : strs1) {
    System.out.println(s);
}
System.out.println(strs1.length);

• 运行结果：

what
is

split
6

• 示例2：

String splitStr1 = "what,is,,,,";
String[] strs1 = splitStr1.split(",");
for (String s : strs1) {
    System.out.println(s);
}
System.out.println(strs1.length);

• 运行结果：

what
is
2

• 示例3:

String splitStr1 = "what,is,,,,";
String[] strs1 = splitStr1.split(",", -1);
for (String s : strs1) {
    System.out.println(s);
}
System.out.println(strs1.length);

• 运行结果

what
is


6

详解：

• 在split(String regex, int limit)方法的if判断内部，定义了off和next变量，作为拆分整个字符串的两个指针，然后limit作为拆分整个string字符串的一个阈值。在split()方法内部的复杂逻辑判断中，都围绕着这三个变量来进行。
• 下面将示例代码1的字符串拆分成字符数组，如下(n代表next指针，o代表off指针)：

w h a t , i s , , , ,  s  p  l  i  t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
n 
o

• 由于regex为’,’，所以满足if括号里的判断。一开始next和off指针都在0位置，limit为0，在while里的判断逻辑指的是获取’,'索引位置，由上图拆分的字符数组可知，next会分别为4,7,8,9,10。由于limited = limit > 0，得知limited为false，则逻辑会走到

if (!limited || list.size() < limit - 1) {
    list.add(substring(off, next));
    off = next + 1;
}

• 进入第一次while循环体，此时的字符数组以及索引关系如下：

w h a t , i s , , , ,  s  p  l  i  t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
        n 
o

• 所以list集合里就会添加进字符串what。

• 第二次进入while循环时，此时的字符数组以及索引关系如下：

w h a t , i s , , , ,  s  p  l  i  t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
              n 
          o

• list集合里就会添加进字符串is

• 第三次进入while循环时，此时的字符数组以及索引关系如下：

w h a t , i s , , , ,  s  p  l  i  t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
                n 
              o

• list集合里就会添加进空字符串""

• 第四次进入while循环时，此时的字符数组以及索引关系如下：

w h a t , i s , , , ,  s  p  l  i  t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
                  n 
                o

• list集合里就会添加进空字符串""

• 当o指针指向位置10时，while((next = indexOf(ch, off)) != -1)结果为false，因为此时已经获取不到’,'了。

• 注意，此时list中包含的元素有：

[what,is, , , ,]

• 当程序走到时，

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

• 会将字符数组off（此时off为10）位置到value.length位置的字符串存进list集合里，也就是split元素,由于list集合最后一个元素为split，其大小不为0，所以就不会进行resultSize–。所以最终list集合里的元素就有6个元素，值为

[what,is, , , ,split]

• 这里相信小伙伴们都知道示例1和示例2的区别在那里了，是因为示例2最后索引位置的list为空字符串，所以list.get(resultSize-1).length()为0，则会调用下面的代码逻辑：

while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
    resultSize--;
}

• 最终会将list中的空字符串给减少。所以示例2的最终结果为

[what,is]

• 对于入参limit，可以总结一下为：

  • limit > 0，split()方法最多把字符串拆分成limit个部分。
  • limit = 0，split()方法会拆分匹配到的最后一位regex。
  • limit < 0，split()方法会根据regex匹配到的最后一位，如果最后一位为regex，则多添加一位空字符串；如果不是则添加regex到字符串末尾的子字符串。

点击此处阅读全文

本文地址：https://blog.csdn.net/weixin_42152604/article/details/112223396