java源码-String

1. String类定义

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

a. String类被 final修饰，说明String不能被继承，其中的成员方法不能被覆盖重写。

b. 实现了序列化Serializable接口

c. 实现了用于比较两个字符串大小的Comparable接口

d. 实现了char的有序可读序列CharSequence

2. String本质

private final char value[];

String本质是char的数组

3. String常用方法源码

3.1. 构造函数

  public String(char value[]) {
// 复制 赋值给value
        this.value = Arrays.copyOf(value, value.length);
    }

3.2. 字符串长度

public int length() {
// 返回数组的长度
        return value.length;
}

3.3 是否为空

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

3.4 获取指定位置的字符

public char charAt(int index) {
// 判断index 是否越界
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
// 返回数组指定位置的字符
    return value[index];
}

3.5 比较两个字符串是否相等

    public boolean equals(Object anObject) {
// 如果是当前对象 直接返回
        if (this == anObject) {
            return true;
        }
// 入参是String 才进一步比较
        if (anObject instanceof String) {
// 强制类型转换
            String anotherString = (String)anObject;
// 获取当前String的长度
            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;
    }

3.6 字符串比较大小

public int compareTo(String anotherString) {
// 获取当前字符串大小
        int len1 = value.length;
// 获取入参字符串大小
        int len2 = anotherString.value.length;
// 获取长度最小的
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
// 遍历字符串
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
// 不相等时
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
// 字符串开始部分完全相同，则比较长度
        return len1 - len2;
    }

3.7 判断字符串是否以另外一个字符串开始

 public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;
// 当前字符串从指定位置开始判断
        int to = toffset;
        char pa[] = prefix.value;
// 入参字符串从0开始
        int po = 0;
        int pc = prefix.value.length;
        // Note: toffset might be near -1>>>1.
// 如果toffset小于0 或者 toffset 大于 当前字符串的长度 减去比较的字符串长度(去掉toffset前的字符串，剩下字符串长度 小于 入参字符串长度 ，直接不用比较)
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
// 遍历 比较每一个字符
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

3.8 字符串截取

    public String substring(int beginIndex) {
// 开始位置小于0 直接抛异常
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
// 如果字符串长度小于开始位置 抛异常
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
// beginIndex=0时，放回当前字符串对象， 否则生成新的字符串对象
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }