String类源码——java常见API一

无论看什么源码，我们都应该尽可能的先看个大概。不能死扣细节，遇到看不懂的可以先填过，等对大体有一定了解之后在回头看（细节扣不完，有的细节还看不懂，会直接把看源码的想法扼杀在摇篮里）

1.首先我们看一下String类的结构

        String类被final修饰，表示String不能被继承

        String类实现了Serializable接口（序列化的标志性接口）：说明String可以通过ObjectOut/inStream转化为字节流，实现在网络中的传输

        Comparable排序接口（内部比较器）：表示String该类支持排序。eg: 当调用Arrays.sort(strs)会使用该方法进行比较

        CharSequence字符序列接口（StringBuffer，Stringbulider都实现了该接口）：常见的charAt，sbSequence等字符串公共方法

String类通过字符数组来构成字符串，而字符数组value被final修饰，表名String的内容不可被修改

2.String类中的构造方法

        基础的简单构造方法就不过多赘述了

        来个稍微复杂一点点的（就看了这一个，别的咱现在也看不懂）

//codePoints为unicode编码数组
//offset起始
//count个数
//从codePoints拿出数组，按nuicode编码进行转义字符串，填充到value中
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;
//判断value的大小
//代码点的范围 0x00 0000 - 0x10 ffff
        // Pass 1: Compute precise size of char[]
        int n = count;
        for (int i = offset; i < end; i++) {
            int c = codePoints[i];
//判断c是否在0x0000 与 0xffff 的范围内
            if (Character.isBmpCodePoint(c))
                continue;
//判断c是否在0xffff 与 0x10 ffff的范围内
            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;
    }

3.一些比较复杂的工具方法

       先让大家来看看equals和compareTo的方法：

public boolean equals(Object anObject) {
//指向地址相同则为同一个对象
        if (this == anObject) {
            return true;
        }
//是否为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;
                while (n-- != 0) {
//如果其中有一个字符不相等则为false
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

compareTo

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;
//当比较遇到不同的字符，则返回两个字符asc码的差值返回。否则这返回两者长度的差值作为返回
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

通过上面两个方法，我们可以很清楚的发现equals与compareTo的区别：

        两者都是比较方法

        equals用于判断两者是否相等，compareTo更偏向于比较大小

        equals重写Object类中的方法。compareTo需要实现Comparable接口

replace方法

public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */
//i指向第一个oldChar的下标
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }

            if (i < len) {
                char buf[] = new char[len];
//将旧数组复制到新数组中
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
//开始替换元素
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

本来想要阅读Spring的源码，但是看了半天，发现完全扛不住，还是从基础慢慢开始。先从java最基础的源码开始读。发现基础的源码照样有很多读不懂~~~~加油吧