超详细的逐句介绍Java高级接口之String函数源码讲解（一）

一、String类

String 类表示字符串。 Java 程序中的所有字符串文字，例如“abc”，都作为此类的实例来实现。下面我将介绍下面的函数常量以及相关的初始化方法设计。

二、内部方法介绍

String类连接的接口为：java.io.Serializable, Comparable, CharSequence

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

初始化定义一个char数组

private final char value[];

为String类获取一个哈希值

private int hash; 

下面定义了String类的通用串行ID

private static final long serialVersionUID = -6849794470754667710L;

类 String 是序列化流协议中的特例。写入了一个 String 实例

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

初始化一个新创建的 String 对象，使其表示一个空字符序列

public String() {
        this.value = "".value;
    }

初始化新创建的 String 对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

分配一个新的 String 以表示当前包含在字符数组参数中的字符序列。复制字符数组的内容；字符数组的后续修改不会影响新创建的字符串。

public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

分配一个新字符串，其中包含来自字符数组参数的子数组的字符。 offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。复制子数组的内容；字符数组的后续修改不会影响新创建的字符串。

public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

分配一个新字符串，其中包含来自 Unicode 代码点数组参数的子数组的字符。 offset 参数是子数组第一个代码点的索引，count 参数指定子数组的长度。子数组的内容被转换为字符；对 int 数组的后续修改不会影响新创建的字符串。

public String(int[] codePoints, int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= codePoints.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > codePoints.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }

        final int end = offset + count;

        // Pass 1: Compute precise size of char[]
        int n = count;
        for (int i = offset; i < end; i++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                continue;
            else if (Character.isValidCodePoint(c))
                n++;
            else throw new IllegalArgumentException(Integer.toString(c));
        }

        // Pass 2: Allocate and fill in char[]
        final char[] v = new char[n];

        for (int i = offset, j = 0; i < end; i++, j++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                v[j] = (char)c;
            else
                Character.toSurrogates(c, v, j++);
        }

        this.value = v;
    }

分配从 8 位整数值数组的子数组构造的新字符串。（已弃用）

public String(byte ascii[], int hibyte, int offset, int count) {
        checkBounds(ascii, offset, count);
        char value[] = new char[count];

        if (hibyte == 0) {
            for (int i = count; i-- > 0;) {
                value[i] = (char)(ascii[i + offset] & 0xff);
            }
        } else {
            hibyte <<= 8;
            for (int i = count; i-- > 0;) {
                value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
            }
        }
        this.value = value;
    }

分配一个包含由 8 位整数值数组构造的字符的新字符串。（已弃用）

public String(byte ascii[], int hibyte) {
        this(ascii, hibyte, 0, ascii.length);
    }

边界检查

 private static void checkBounds(byte[] bytes, int offset, int length) {
        if (length < 0)
            throw new StringIndexOutOfBoundsException(length);
        if (offset < 0)
            throw new StringIndexOutOfBoundsException(offset);
        if (offset > bytes.length - length)
            throw new StringIndexOutOfBoundsException(offset + length);
    }

通过使用指定的字符集解码指定的字节子数组来构造一个新的 String。新字符串的长度是字符集的函数，因此可能不等于子数组的长度。

 public String(byte bytes[], int offset, int length, String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        checkBounds(bytes, offset, length);
        this.value = StringCoding.decode(charsetName, bytes, offset, length);
    }

通过使用指定的字符集解码指定的字节子数组来构造一个新的 String。

public String(byte bytes[], int offset, int length, Charset charset) {
        if (charset == null)
            throw new NullPointerException("charset");
        checkBounds(bytes, offset, length);
        this.value =  StringCoding.decode(charset, bytes, offset, length);
    }

通过使用指定的字符集解码指定的字节数组来构造一个新的 String。

public String(byte bytes[], String charsetName)
            throws UnsupportedEncodingException {
        this(bytes, 0, bytes.length, charsetName);
    }

通过使用指定的字符集解码指定的字节数组来构造一个新的 String。

public String(byte bytes[], Charset charset) {
        this(bytes, 0, bytes.length, charset);
    }

通过使用指定的字符集解码指定的字节数组来构造一个新的 String。

public String(byte bytes[], int offset, int length) {
        checkBounds(bytes, offset, length);
        this.value = StringCoding.decode(bytes, offset, length);
    }

通过使用指定的字符集解码指定的字节数组来构造一个新的 String。

public String(byte bytes[]) {
        this(bytes, 0, bytes.length);
    }

分配一个新字符串，该字符串包含当前包含在字符串缓冲区参数中的字符序列。复制字符串缓冲区的内容；字符串缓冲区的后续修改不会影响新创建的字符串。

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

分配一个新字符串，该字符串包含当前包含在字符串构建器参数中的字符序列。复制字符串生成器的内容；字符串生成器的后续修改不会影响新创建的字符串。

public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

包私有构造函数，它共享值数组以提高速度。这个构造函数总是期望使用 share==true 调用。需要一个单独的构造函数，因为我们已经有一个公共 String(char[]) 构造函数，它可以复制给定的 char[]

String(char[] value, boolean share) {
        // assert share : "unshared not supported";
        this.value = value;
    }