java源码解析之String类(二)

上一节主要介绍了String类的一些构造方法，主要分为四类

• 无参构造器：String()，创建一个空字符串""，区别于null字符串，""已经初始化，null并未初始化
• 副本构造器：String(String s),简单的赋值，得到的是一个副本，俩个引用指向的是常量池中的同一个String，但是String是不可变的，所有用意不大
• byte类构造器：String(byte[] b)，将byte数组转换为String，注意并不是简单的赋值，而是整体copy一份
• char类构造器：String(char[] c)，将char数组转换成String，注意并不是简单的赋值，而是整体copy一份
• codepoints构构器：String(int[] i)，将超过char表示范围的字符转换为为String
• String缓存流的转换：String(StringBuffer)，将字符换缓冲流转换为String

    /*
     * 获得字符串的长度，也就是属性value数组的长度
     */
    public int length() {
        return value.length;
    }
 
    /*
     * 判断字符串是否为空，也就是判断属性value数组的长度是否等于0
     */
    public boolean isEmpty() {
        return value.length == 0;
    }
 
    /*
     * charAt方法可以直接获取当前下标对应的字符，这对于判断某个位置的字符值很方便
     * 区别于
     */
    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
 
    /*
     * 返回指定索引处的字符（Unicode代码点）。 codePoint在上一章已经介绍过了，具体就是那些超出byte和char表示方位的字符
     */
    public int codePointAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return Character.codePointAtImpl(value, index, value.length);
    }
 
    /*
     * 返回指定索引之前的字符（Unicode代码点）。
     */
    public int codePointBefore(int index) {
        int i = index - 1;
        if ((i < 0) || (i >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return Character.codePointBeforeImpl(value, index, 0);
    }
 
    /*
     * 返回此 String指定文本范围内的Unicode代码点数。
     */
    public int codePointCount(int beginIndex, int endIndex) {
        if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
            throw new IndexOutOfBoundsException();
        }
        return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
    }
 
    /*
     * 返回此String中的索引，该索引通过codePointOffset代码点从给定的index偏移。
     * index和codePointOffset给出的文本范围内的未配对代理计为每个代码点。
     *
     */
    public int offsetByCodePoints(int index, int codePointOffset) {
        if (index < 0 || index > value.length) {
            throw new IndexOutOfBoundsException();
        }
        return Character.offsetByCodePointsImpl(value, 0, value.length, index, codePointOffset);
    }
 
    /*
     * 将此字符串复制给dst字节数组，默认为整体复制，其中dstBegin为目标数组dst中的开始位置
     * 此方法为包访问权限，所以我们并没有调用的权限
     */
    void getChars(char dst[], int dstBegin) {
        System.arraycopy(value, 0, dst, dstBegin, value.length);
    }
 
    /*
     * 将此字符串的额指定位置开始到指定位置结束复制给dst字节数组，其中dstBegin为目标数组dst的开始位置，
     * srcBegin和srcEnd分别为本字符串的开始位置和结束位置
     */
    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }
 
    /*
     * 方法已过时
     * 使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中，可以指定字符串的开始位置和结束位置，
     * 但结果往往是不正确的，在源码中我们可以看到，仅仅是将字符串的每一位字符强转成字节类型，实际用处很少。
     *
     */
    @Deprecated
    public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        Objects.requireNonNull(dst);
 
        int j = dstBegin;
        int n = srcEnd;
        int i = srcBegin;
        char[] val = value; /* avoid getfield opcode */
 
        while (i < n) {
            dst[j++] = (byte) val[i++];
        }
    }
 
    /*
     * 指定编码字符集将此 String编码为字节序列，将结果存储到新的字节数组中
     */
    public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
        if (charsetName == null)
            throw new NullPointerException();
        return StringCoding.encode(charsetName, value, 0, value.length);
    }
 
    /*
     * 指定编码字符集将此 String编码为字节序列，将结果存储到新的字节数组中
     */
    public byte[] getBytes(Charset charset) {
        if (charset == null)
            throw new NullPointerException();
        return StringCoding.encode(charset, value, 0, value.length);
    }
 
    /*
     * 使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中
     */
    public byte[] getBytes() {
        return StringCoding.encode(value, 0, value.length);
    }
 
    /*
     * String重写Object类的equals方法，详细阅读源码，我们发现形参是Object类型，那么在实际传参的过程当中
     * 除了String类型，别的引用类型都会返回false，重点注意的是StringBuffer和StringBuild，在实际比较的时候一定要先进行转换
     * equals实际比较的就是字符串的每一位依次进行比较，直到全部比较完毕都没有不一样的才返回true
     */
    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;
    }
 
    /*
     * 将此字符串与指定的StringBuffer进行 比较内容是否相等
     */
    public boolean contentEquals(StringBuffer sb) {
        return contentEquals((CharSequence) sb);
    }
 
    private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
        char v1[] = value;
        char v2[] = sb.getValue();
        int n = v1.length;
        if (n != sb.length()) {
            return false;
        }
        for (int i = 0; i < n; i++) {
            if (v1[i] != v2[i]) {
                return false;
            }
        }
        return true;
    }
 
    /*
     * 将此字符串与指定的CharSequence进行内容比较是否相等
     */
    public boolean contentEquals(CharSequence cs) {
        // Argument is a StringBuffer, StringBuilder
        if (cs instanceof AbstractStringBuilder) {
            if (cs instanceof StringBuffer) {
                synchronized (cs) {
                    return nonSyncContentEquals((AbstractStringBuilder) cs);
                }
            } else {
                return nonSyncContentEquals((AbstractStringBuilder) cs);
            }
        }
        // Argument is a String
        if (cs instanceof String) {
            return equals(cs);
        }
        // Argument is a generic CharSequence
        char v1[] = value;
        int n = v1.length;
        if (n != cs.length()) {
            return false;
        }
        for (int i = 0; i < n; i++) {
            if (v1[i] != cs.charAt(i)) {
                return false;
            }
        }
        return true;
    }
 
    /*
     * 能用一行代价解决的事就不用俩行，三元运算符?:直接解决。其中regionMatches(true, 0, anotherString, 0, value.length)是测试是否相等的函数
     * 第一个参数true代表忽略大小写
     */
    public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true
                : (anotherString != null) && (anotherString.value.length == value.length)
                        && regionMatches(true, 0, anotherString, 0, value.length);
    }