java.lang.String (JDK1.8)详解编程语言

1 public default IntStream chars(){...} 
2 public default IntStream codePoints() {...}

因为接口有这个语法限制，所以要直接改变/扩展接口内的方法变得非常困难。我们在尝试强化Java 8 Collections API，让其支持lambda表达式的时候，就面临了这样的挑战。为了克服这个困难，Java 8中引入了一个新的概念，叫做default方法，也可以称为Defender方法，或者虚拟扩展方法（Virtual extension methods)。 
Default方法是指，在接口内部包含了一些默认的方法实现（也就是接口中可以包含方法体，这打破了Java之前版本对接口的语法限制），从而使得接口在进行扩展的时候，不会破坏与接口相关的实现类代码。

1     interface A {} 
2     interface B {}
3     class C implements A,B {}

1     private final char value[]; 
2     private int hash; // Default to 0 
3     private static final long serialVersionUID = -6849794470754667710L; 
4     private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

1 public String(byte bytes[], int offset, int length, String charsetName)

 1     private static Charset lookup(String charsetName) { 
 2         if (charsetName == null) 
 3             throw new IllegalArgumentException("Null charset name"); 
 4         Object[] a; 
 5         // 先从一级缓存中寻找 
 6         if ((a = cache1) != null && charsetName.equals(a[0])) 
 7             return (Charset)a[1]; 
 8         // We expect most programs to use one Charset repeatedly. 
 9         // We convey a hint to this effect to the VM by putting the 
10         // level 1 cache miss code in a separate method. 
11         return lookup2(charsetName); 
12     } 
13  
14     private static Charset lookup2(String charsetName) { 
15         Object[] a; 
16         // 一级缓存未命中，再查找二级缓存 
17         if ((a = cache2) != null && charsetName.equals(a[0])) { 
18             cache2 = cache1; 
19             cache1 = a; 
20             return (Charset)a[1]; 
21         } 
22         // 仍然未命中，则去支持的字符集库中去查找 
23         Charset cs; 
24         // private static CharsetProvider standardProvider = new StandardCharsets(); 
25         // standardProvider其实是个StandardCharsets，StandardCharsets这个类里面定义了所有支持的标准字符集，并且包含其别名 
26         // StandardCharsets继承自FastCharsetProvider，因此最终是要调用FastCharsetProvider类的lookup函数，该函数第一句就是toLower(var1)，然后再去StandardCharsets中定义的几个hashmap中去寻找。 
27         if ((cs = standardProvider.charsetForName(charsetName)) != null || 
28             (cs = lookupExtendedCharset(charsetName))           != null || 
29             (cs = lookupViaProviders(charsetName))              != null) 
30         { 
31             cache(charsetName, cs); 
32             return cs; 
33         } 
34  
35         /* Only need to check the name if we didn't find a charset for it */ 
36         checkName(charsetName); 
37         return null; 
38     }    

1 public boolean equals(Object anObject)

1 public boolean contentEquals(StringBuffer sb) 
2 private boolean nonSyncContentEquals(AbstractStringBuilder sb) 
3 public boolean contentEquals(CharSequence cs)

1 public boolean equalsIgnoreCase(String anotherString)

 1     public int hashCode() { 
 2         int h = hash; 
 3         if (h == 0 && value.length > 0) { 
 4             char val[] = value; 
 5  
 6             for (int i = 0; i < value.length; i++) { 
 7                 h = 31 * h + val[i]; 
 8             } 
 9             hash = h; 
10         } 
11         return h; 
12     }

The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: 31 * i == (i << 5) - i. Modern VMs do this sort of optimization automatically. 
(from Chapter 3, Item 9: Always override hashcode when you override equals, page 48)

1 public int indexOf(int ch, int fromIndex) 
2 private int indexOfSupplementary(int ch, int fromIndex)

代码点（Code Point)：Unicode是属于编码字符集（CCS）的范围。Unicode所做的事情就是将我们需要表示的字符表中的每个字符映射成一个数字，这个数字被称为相应字符的码点（code point）。例如“严”字在Unicode中对应的码点是U+0x4E25。 
代码点是字符集被编码后出现的概念。字符集（Code Set）是一个集合，集合中的元素就是字符，比如ASCII字符集，其中的字符就是'A'、'B'等字符。为了在计算机中处理字符集，必须把字符集数字化，就是给字符集中的每一个字符一个编号，计算机程序中要用字符，直接用这个编号就可以了。于是就出现了编码后的字符集，叫做编码字符集(Coded Code Set)。编码字符集中每一个字符都和一个编号对应。那么这个编号就是代码点（Code Point）。 
码元（Code Unit）是指一个已编码的文本中具有最短的比特组合的单元。对于 UTF-8 来说，码元是 8 比特长；对于 UTF-16 来说，码元是 16 比特长。换一种说法就是 UTF-8 的是以一个字节为最小单位的，UTF-16 是以两个字节为最小单位的。换一种说法就是UTF-8的是以一个字节为最小单位的，UTF-16是以两个字节为最小单位的。 
代码单元是把代码点存放到计算机后出现的概念。一个字符集，比如有10个字符，每一个字符从0到9依次编码。那么代码点就是0、1、。。。、9。为了在计算机中存储这10个代代码点，一个代码点给一个字节，那么这里的一个字节就是一个代码单元。比如Unicode是一个编码字符集，其中有65536个字符，代码点依次为0、1、2、。。。、65535，为了在计算机中表示这些代码点就出现了代码单元，65536个代码点为了统一表示每个代码点必须要有两个字节表示才行。但是为了节省空间0-127的ASCII码就可以不用两个字节来表示，只需要一个字节，于是不同的表示方案就形成了不同的编码方案，比如utf-8、utf-16等。对utf-8而言代码单元就是一个字节，对utf-16而言代码单元就是两个字节。

1 public int lastIndexOf(int ch, int fromIndex) 
2 private int lastIndexOfSupplementary(int ch, int fromIndex)

1 int i = Math.min(fromIndex, value.length - 1)

1 static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)

 1     static int lastIndexOf(char[] source, int sourceOffset, int sourceCount, 
 2             char[] target, int targetOffset, int targetCount, 
 3             int fromIndex) { 
 4        // ...... 
 5  
 6     startSearchForLastChar: 
 7         while (true) { 
 8             while (i >= min && source[i] != strLastChar) { 
 9                 i--; 
10             } 
11             if (i < min) { 
12                 return -1; 
13             } 
14             int j = i - 1; 
15             int start = j - (targetCount - 1); 
16             int k = strLastIndex - 1; 
17  
18             while (j > start) { 
19                 if (source[j--] != target[k--]) { 
20                     i--; 
21                     continue startSearchForLastChar; 
22                 } 
23             } 
24             return start - sourceOffset + 1; 
25         } 
26     }

1 public String substring(int beginIndex)  
2 public String substring(int beginIndex, int endIndex) 

1 public String replace(char oldChar, char newChar) 
2 public String replaceAll(String regex, String replacement)

 1     public String[] split(String regex, int limit) { 
 2         /* fastpath if the regex is a 
 3          (1)one-char String and this character is not one of the 
 4             RegEx's meta characters ".$|()[{^?*+//", or 
 5          (2)two-char String and the first char is the backslash and 
 6             the second is not the ascii digit or ascii letter. 
 7          */ 
 8         char ch = 0; 
 9         if (((regex.value.length == 1 && 
10              ".$|()[{^?*+//".indexOf(ch = regex.charAt(0)) == -1) || 
11              (regex.length() == 2 && 
12               regex.charAt(0) == '//' && 
13               (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 && 
14               ((ch-'a')|('z'-ch)) < 0 && 
15               ((ch-'A')|('Z'-ch)) < 0)) && 
16             (ch < Character.MIN_HIGH_SURROGATE || 
17              ch > Character.MAX_LOW_SURROGATE)) 
18         { 
19             int off = 0; 
20             int next = 0; 
21             boolean limited = limit > 0; 
22             ArrayList<String> list = new ArrayList<>(); 
23             while ((next = indexOf(ch, off)) != -1) { 
24                 if (!limited || list.size() < limit - 1) { 
25                     list.add(substring(off, next)); 
26                     off = next + 1; 
27                 } else {    // last one 
28                     //assert (list.size() == limit - 1); 
29                     list.add(substring(off, value.length)); 
30                     off = value.length; 
31                     break; 
32                 } 
33             } 
34             // If no match was found, return this 
35             if (off == 0) 
36                 return new String[]{this}; 
37  
38             // Add remaining segment 
39             if (!limited || list.size() < limit) 
40                 list.add(substring(off, value.length)); 
41  
42             // 当limit = 0的时候，结尾的空字符串将不会包含在返回数组中 
43             // Construct result 
44             int resultSize = list.size(); 
45             if (limit == 0) { 
46                 while (resultSize > 0 && list.get(resultSize - 1).length() == 0) { 
47                     resultSize--; 
48                 } 
49             } 
50             String[] result = new String[resultSize]; 
51             return list.subList(0, resultSize).toArray(result); 
52         } 
53         return Pattern.compile(regex).split(this, limit); 
54     }

1 ",,a,b,c,d,,,,".split(",").length = 6 
2 ",,a,b,c,d,,,,".split(",", -1).length = 10 
3 ",,a,b,c,d,,,,".split(",", 5).length = 5 
4 ",,a,b,c,d,,,,".split(",", 20).length = 10

1 public static String join(CharSequence delimiter, CharSequence... elements) 
2 public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

 1     public String trim() { 
 2         int len = value.length; 
 3         int st = 0; 
 4         char[] val = value;    /* avoid getfield opcode */ 
 5  
 6         while ((st < len) && (val[st] <= ' ')) { 
 7             st++; 
 8         } 
 9         while ((st < len) && (val[len - 1] <= ' ')) { 
10             len--; 
11         } 
12         return ((st > 0) || (len < value.length)) ? substring(st, len) : this; 
13     }

1 public native String intern();

 1         String str1 = "a"; 
 2         String str2 = "b"; 
 3         String str3 = "ab"; 
 4         String str4 = "a" + "b"; 
 5         String str5 = str1 + str2; 
 6         String str6 = new String("ab"); 
 7  
 8         System.out.println(str4 == str3);   // true 
 9         System.out.println(str5 == str3);   // false 
10         System.out.println(str6 == str3);   // false 
11         System.out.println(str4.intern() == str3);   // true 
12         System.out.println(str5.intern() == str3);   // true 
13         System.out.println(str6.intern() == str3);   // true

 1     public static void test3() { 
 2         String s3 = new String("1") + new String("1"); 
 3         String s4 = "11"; 
 4         s3.intern();  
 5         System.out.println(s3 == s4); 
 6         System.out.println(s3.intern() == s4); 
 7     } 
 8  
 9     public static void test4() { 
10         String s3 = new String("1") + new String("1"); 
11         s3.intern(); 
12         String s4 = "11"; 
13         System.out.println(s3 == s4); 
14         System.out.println(s3.intern() == s4); 
15     }