String类源码解读

一.String类实现的类

1.String类是日常开发中用到的最多的类，它实现了Serializable, Comparable, CharSequence接口，类被final关键字修饰，所以类不能不能被继承，并且是线程安全的。

类实现的关系如下图：

android String 类型怎么确保原子性 string类的源码分析_数组

二、String类的成员变量

1.通过源码我们可以知道String底层依靠的是一个不可变得char数组

//用来存储String字符数组
    private final char value[];

    //缓存String的hash值
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

三、String类的构造方法

1.无参构造

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

2.有参构造

2.1参数为String类型的源数据,将字符串转换成char数组存储，并缓存String的hash值

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

2.2将字符数组转换为String,先进行参数判断，后使用Arrays的方法将char数组中指定范围的转换成String

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);
    }

四、String中常用的方法

  1. length()判断字符串长度,直接返回value数组的长度
public int length() {
        return value.length;
    }

2.isEmpty()判断字符串是否为空，直接判断value数组的长度是否为0

public boolean isEmpty() {
    return value.length == 0;
}

3.charAt()取下标为多少的String字符串中的字符，先判断索引值是否小于0或大于等于数组的最大长度，然后取出数组中指定下标的元素

public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

4.equals()判断两个字符串是否相等

public boolean equals(Object anObject) {
    //判断引用是否相等，如果引用相等则两个字符串相等
    if (this == anObject) {
        return true;
    }
    //判断是否为String类
    if (anObject instanceof String) {
        //强制转换成String类型
        String anotherString = (String)anObject;
        //获取当前字符的长度
        int n = value.length;
        //判断两个字符串的长度是否相等
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            //判断数组长度是否不等于0
            while (n-- != 0) {
                //取出相同位置的字符比较是否相等
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

5.startWith()判断是否以某个字符串开头

public boolean startsWith(String prefix, int toffset) {
    char ta[] = value;
    int to = toffset;
    char pa[] = prefix.value;
    int po = 0;
    int pc = prefix.value.length;
    // Note: toffset might be near -1>>>1.
    if ((toffset < 0) || (toffset > value.length - pc)) {
        return false;
    }
    while (--pc >= 0) {
        //判断String中的字符从toffset开始是否和传递进来的顺序一致
        if (ta[to++] != pa[po++]) {
            return false;
        }
    }
    return true;
}

6.indexOf():判断字符从0开始位于字符串的哪个位置

public int indexOf(int ch) {
        return indexOf(ch, 0);
    }

7.lastIndexOf():判断字符从字符串尾部开始位于字符串的哪个位置

public int lastIndexOf(int ch) {
    return lastIndexOf(ch, value.length - 1);
}

8.截取字符串中指定位置的字符

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    //判断起始和结束的位置是否为字符串本身如果是则返回该字符串，否则重新创建一个对象并返回指定位置的字符9
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

9.concat():拼接字符串

public String concat(String str) {
    //获取字符串的长度
    int otherLen = str.length();
    //判断长度是否为0,如果为0则返回调用该方法的字符串
    if (otherLen == 0) {
        return this;
    }
    //获取调用该方法的字符串长度
    int len = value.length;
    //复制数组的长度
    char buf[] = Arrays.copyOf(value, len + otherLen);
    //将str转换成Char数组存储进buf
    str.getChars(buf, len);
   //重新创建一个String对象
    return new String(buf, true);
}
10.replace():将源字符替换成目标字符
public String replace(char oldChar, char newChar) {
        //判段源字符和新字符是否相等
        if (oldChar != newChar) {
            //获取源字符串的数组长度
            int len = value.length;
            int i = -1;
            //将源数据中的字符数组复制给一个临时变量
            char[] val = value; /* avoid getfield opcode */
            //判断源数据中的第几个满足为指定需要被替换的字符
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            //判断i是否小于数组长度
            if (i < len) {
            //新建字符数组，将原先的数组中元素赋值给新的字符
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
              //将需要替换的字符赋值给新的字符数组buf
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                //创建一个新的字符串对象并返回
                return new String(buf, true);
            }
        }
        return this;
    }

11.matches()：判断是否匹配传递进来的字符串

public boolean matches(String regex) {
    return Pattern.matches(regex, this);
}
//创建一个新的字符串对象并返回
                return new String(buf, true);
            }
        }
        return this;
    }

11.matches()：判断是否匹配传递进来的字符串

public boolean matches(String regex) {
    return Pattern.matches(regex, this);
}