Java源码阅读之String（2）

Java源码阅读之String（2）

这一篇博客用于记录String类的部分方法。

//获取字符串长度，返回的是value数组的长度
public int length() {
    return value.length;
}

//根据value数组长度判断字符串是否为空
public boolean isEmpty() {
    return value.length == 0;
}

//根据index返回所在位置的字符
public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

//返回指定位置的Unicode码点，如果（index-1）处的char值处于低位范
//围内，（index-2）不是负数，并且（index-2）处的char值处于高位
//范围内，则补充代码点的值被返回。 如果index-1中的char值是
//不成对的低位，则返回码值。
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码点。 范围从指定的
//beginIndex开始，并扩展到索引endIndex-1处的char。并且计算是否为高
//低位合并的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 中从给定的 index 处偏移 codePointOffset 个代码点
//的索引。文本范围内由 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);
}

//从dstBegin开始，将这个字符串中的字符复制到dst中。 
//此方法不执行任何范围检查。
void getChars(char dst[], int dstBegin) {
    System.arraycopy(value, 0, dst, dstBegin, 
        value.length);
}

//将此字符串中的字符复制到目标字符数组中。
//复制范围为srcBegin到srcEnd-1，复制到从索引dstBegin开始到索引处结
//束的dst子数组中
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);
}

//根据所给的编码方式返回byte字节序列，给定编码方式为编码名称
public byte[] getBytes(String charsetName)
    throws UnsupportedEncodingException {
    if (charsetName == null) 
        throw new NullPointerException();
    return StringCoding.encode(charsetName, value, 0, 
        value.length);
}

//根据所给的编码方式返回byte字节序列，给定编码方式为编码对象
public byte[] getBytes(Charset charset) {
    if (charset == null) 
        throw new NullPointerException();
    return StringCoding.encode(charset, value, 0, 
        value.length);
}

//根据默认的编码方式返回byte字节序列，默认编码方式为"ISO-8859-1"
public byte[] getBytes() {
    return StringCoding.encode(value, 0, value.length);
}

//判断当前String对象与anObject对象是否相等
public boolean equals(Object anObject) {
    //判断两者引用地址是否相等，即是否指向同一个对象
    if (this == anObject) {
        return true;
    }
    //如果不指向同一个对象，需要判断两者内容是否相等，在判断两者内容
    //相等之前需要确定anObject也是一个String对象
    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;
            //对当前对象的value和anObject的value逐一对比，有一个
            //不相同则返回false
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

//判断当前对象和StringBuffer 的对象sb内容是否相同
public boolean contentEquals(StringBuffer sb) {
    return contentEquals((CharSequence)sb);
}

//判断当前对象的内容和实现了CharSequence 接口的cs对象的
//内容是否相同
public boolean contentEquals(CharSequence cs) {
    //判断cs是否为StringBuffer或StringBuilder
    if (cs instanceof AbstractStringBuilder) {
        //如果是StringBuffer（线程安全）需要先锁住cs再判断
        if (cs instanceof StringBuffer) {
            synchronized(cs) {
                return nonSyncContentEquals((AbstractStringBuilder)cs);
            }
        } else {
            //如果是StringBuilder（非线程安全）直接对cs进行判断
            return nonSyncContentEquals((AbstractStringBuilder)cs);
        }
    }
    //如果是String对象 直接调用equals方法判断
    if (cs instanceof String) {
        return equals(cs);
    }
    //如果是是一个通用的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;
}

//非线程安全方式判断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;
}

//忽略大小写判断当前对象和anotherString的值是否相等
public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true: (anotherString != null)
          && (anotherString.value.length == value.length)
          && regionMatches(true, 0, anotherString, 0, value.length);
}