Java: java.lang.String

Author: c-rainstorm

README.md

@@ -28,6 +28,7 @@
 |   `-- 面试题目分类及举例.md
 |-- java
 |   |-- Effective-Java.md
+|   |-- java.lang.String.md
 |   |-- Spring-SpringMVC-Mybatis整合.md
 |   |-- 图解JavaCollectionFramework.md
 |   |-- ThreadPoolExecutor源码剖析.md

java/java.lang.String.md

@@ -0,0 +1,231 @@
+# java.lang.String
+
+- 基于 Java9
+- Tips: 预备知识，建议掌握以后再继续向下看。[Unicode 学习笔记](../common/unicodeStandard.md)
+
+---
+
+<!-- TOC -->
+
+- [概览](#概览)
+- [继承结构](#继承结构)
+    - [Serializable](#serializable)
+    - [CharSequence](#charsequence)
+    - [Comparable<T>](#comparablet)
+- [字符集简介](#字符集简介)
+- [重要域成员](#重要域成员)
+- [重要方法](#重要方法)
+    - [代码点及代码单元](#代码点及代码单元)
+    - [比较](#比较)
+    - [搜索](#搜索)
+    - [提取子串](#提取子串)
+    - [创建全大写/全小写副本](#创建全大写全小写副本)
+- [一些体会](#一些体会)
+- [参考](#参考)
+
+<!-- /TOC -->
+
+---
+
+## 概览
+
+`String` 类代表了字符串。所有类似于 `"abc"` 的字符串字面量都是该类的实例。
+
+字符串是常量，从创建后就不可更改。需要修改的字符串可以使用 `StringBuffer`。因为 `String` 实例不可变，所以他们可以安全的共享。一些例子：
+
+```java
+String str = "abc";
+// 与上面一行代码效果相同
+char data[] = {'a', 'b', 'c'};
+String str = new String(data);
+
+
+System.out.println("abc");
+String cde = "cde";
+System.out.println("abc" + cde);
+String c = "abc".substring(2,3);
+String d = cde.substring(1, 2);
+```
+
+`String` 类也包含了一些对单个字符的操作、比较、搜索、提取子串、创建全大写/全小写副本的方法。
+
+Java 语言为字符串连接操作符(+)添加了特殊支持。向左连接。
+
+```java
+//  example 1
+"The square root of 2 is " + Math.sqrt(2)
+  |
+  v
+"The square root of 2 is 1.4142135623730952"
+
+// example 2
+1 + 2 + " fiddlers"
+  |
+  v
+"3 fiddlers"
+
+// example 3
+"fiddlers " + 1 + 2
+  |
+  v
+"fiddlers 12"
+
+```
+
+`String` 使用 UTF-16 来编码（一个字符两个字节或四个字节）。拓展字符用 surrogate pairs 来表示，占用四个字节。（PS：该术语是编码领域的，可以参考之前写的一篇笔记: [Unicode 学习笔记](../common/unicodeStandard.md)）
+
+`String` 也提供了一些处理代码点(Unicode code points)和代码单元(Unicode code units)的方法(PS:这两个也是编码领域术语，可以参考：[Unicode 学习笔记](../common/unicodeStandard.md))。
+
+String 连接操作符的具体实现留给 Java 编译器来决定，只要编译器能够完全遵循 Java 语言规范即可。例如 `javac` 编译器可能用 `StringBuffer`、`StringBuilder` 或 `java.lang.invoke.StringCOncatFactory` 来实现。
+
+## 继承结构
+
+![](../res/java.lang.string-class.png)
+
+### Serializable
+
+类通过实现 `java.io.Serializable` 接口来启用序列化能力。未实现该接口的类其状态将不会被序列化(抛出 `NotSerializableException` 异常)。该接口没有任何域或方法，只是表示可序列化的语义。
+
+```java
+    public static void serializableTest() throws IOException, ClassNotFoundException {
+        String outputfile = "/Users/chen/Desktop/serializable";
+        ST instance = new ST();
+
+        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(outputfile));
+        outputStream.writeObject(instance);
+        outputStream.close();
+
+        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(outputfile));
+        ST newInstance = (ST) inputStream.readObject();
+        inputStream.close();
+
+        System.out.println(newInstance);
+        System.out.println(instance.equals(newInstance));  // true
+        System.out.println(instance == newInstance); //false
+    }
+
+    static class ST implements Serializable{
+        public int publicField = 1;
+        protected int protectedField = 1;
+        int defaultField = 1;
+        private int privateField = 1;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            ST st = (ST) o;
+            return publicField == st.publicField &&
+                    protectedField == st.protectedField &&
+                    defaultField == st.defaultField &&
+                    privateField == st.privateField;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(publicField, protectedField, defaultField, privateField);
+        }
+
+        @Override
+        public String toString() {
+            return "ST{" +
+                    "publicField=" + publicField +
+                    ", protectedField=" + protectedField +
+                    ", defaultField=" + defaultField +
+                    ", privateField=" + privateField +
+                    '}';
+        }
+    }
+```
+
+序列化的对象中引用的所有对象都必须实现了该接口，否则也会抛出 `NotSerializableException` 异常。
+
+### CharSequence
+
+一个 `CharSequence` 是一个只读的 `char` 序列。该接口为不同的实现提供了统一的只读访问。
+
+该接口并没有重新定义 `equals() & hashCode()` 方法，直接比较两个实现类的实例结果是未定义的。所以将 `CharSequence` 的实例作为 `set` 的元素或 `map` 的 `key` 是不合适的。
+
+主要的实现类：`CharBuffer, Segment, String, StringBuffer, StringBuilder`
+
+`String` 中也实现了与 `CharSequence` 实例进行比较、拼接等操作的函数。
+
+### Comparable<T>
+
+主要用于集合中元素排序，两个元素直接比较。
+
+## 字符集简介
+
+`String` 类中用到了两种字符集 `Latin1 & UTF-16`. `Latin1` 拓展了 `ASCII` 编码，但是也是用一个字节来表示，`UTF-16` 使用两个或四个字节表示一个字符。简要介绍请看：[Unicode 学习笔记](../common/unicodeStandard.md)
+
+```java
+/**
+    在构造一个 String 对象时，String 会尝试对传入的参数进行压缩。比如
+
+    String latin1 = new String("latin1".toCharArray());
+    String utf16 = new String("使用 UTF-16 字符集".toCharArray());
+
+    入参是 char[]，java 中 char 是两个字节，byte 是一个字节，压缩后 latin1 的 value 字段是 6 个 byte，utf16 无法进行压缩，所以依旧是 26 个 byte。
+
+    下面是 java.lang.StringUTF16 中进行压缩的函数。
+ */
+    // compressedCopy char[] -> byte[]
+    @HotSpotIntrinsicCandidate
+    public static int compress(char[] src, int srcOff, byte[] dst, int dstOff, int len) {
+        for (int i = 0; i < len; i++) {
+            char c = src[srcOff];
+            if (c > 0xFF) {     // 超出了 LATIN1 所能表示的范围，直接返回不再压缩
+                len = 0;
+                break;
+            }
+            dst[dstOff] = (byte)c;
+            srcOff++;
+            dstOff++;
+        }
+        return len;
+    }
+```
+
+## 重要域成员
+
+1. `private final byte[] value;`
+    - 用来存储字符串的字节序列。
+1. `private final byte coder;`
+    - 用来暗示 `value` 中的字节数组的编码方式。有 `LATIN1 & UTF16` 可选。
+    - `static final byte LATIN1 = 0;`
+    - `static final byte UTF16  = 1;`
+1. `private int hash;`
+    - 缓存字符串哈希值。默认是 0. 在 首次调用 `hashCode()` 方法时计算并缓存。
+1. `static final boolean COMPACT_STRINGS;`
+    - 用来决定 `value` 是否进行压缩，默认是 true（压缩）。如果是 false 的话那么总是使用 UTF16 来编码字符串的字节流。在 `String` 类中，该域使用静态初始化块进行初始化。
+
+## 重要方法
+
+- TIPS：本来计划中有这部分的内容，但是读过源码理解了字符集的概念和 `String` 的处理方式以后感觉这部分就不需要再写了，有兴趣可以自己看。
+
+### 代码点及代码单元
+
+### 比较
+
+### 搜索
+
+### 提取子串
+
+### 创建全大写/全小写副本
+
+## 一些体会
+
+理解 `String` 类最重要的不是会用 `String` 的 API，而是对字符集本身的理解，字符集是什么，它解决了什么问题，字符是怎么编码的等等，只有很好的理解了字符集才能很好的理解 `String` 的行为。
+
+## 参考
+
+1. [java.lang.String](https://docs.oracle.com/javase/9/docs/api/java/lang/String.html)
+1. [15.18.1. String Concatenation Operator +](https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.18.1)
+1. [Serializable](https://docs.oracle.com/javase/9/docs/api/java/io/Serializable.html)
+1. [JAVA 对象序列化（一）——Serializable](http://www.cnblogs.com/chenfei0801/archive/2013/04/05/3001149.html)
+1. [CharSequence](https://docs.oracle.com/javase/9/docs/api/java/lang/CharSequence.html)
+1. [ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)