【学习源码】String类

最新推荐文章于 2025-07-21 17:38:25 发布

原创最新推荐文章于 2025-07-21 17:38:25 发布 · 127 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#String #equals #hashcode

本文深入解析了Java中String类的方法实现原理，包括字符串拼接、替换、比较等核心功能，并探讨了hashCode的计算方式。

1. 学习 jdk 的 String 类。

-----------------------------------------------------------------

concat(String str) : 拼接 String。

public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
 }

char buf [] = Arrays.copyOf(value, len+ otherLen); 将 value 转换为一个长度合适的字符数组。

public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
}

str.getChars(buf, len) : 将 str 的value 复制到 buf 上，从 index = len 开始赋值。

void getChars(char dst[], int dstBegin) {
        System.arraycopy(value, 0, dst, dstBegin, value.length);
}

-------------------------------------------------------------

replace(char oldChar, char newChar) : 替换 String 中的某个字符

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

1. 判断是否没有符合条件的字符。没有的话，就直接结束了。

2. 如果需要替换，先将前面不用替换的字符存储起来。

3. 从开始替换的位置，循环判断。

equals（）：

比较两个 String 是否相等。为什么重写，因为 Object 只能比较是同一个，而 new String() 会创建一个新的对象

所以，涉及到对象的比较或者 map 的key值的类，都需要重写。

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

1. 先判断是否是同一个对象、

2. 判断是否属于 String 类型，

3. 获取长度，循环比较每个字符。

equalsIgnoreCase()：

public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true
                : (anotherString != null)
                && (anotherString.value.length == value.length)
                && regionMatches(true, 0, anotherString, 0, value.length);
}

regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) :

public boolean regionMatches(boolean ignoreCase, int toffset,
            String other, int ooffset, int len) {
        char ta[] = value;
        int to = toffset;
        char pa[] = other.value;
        int po = ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0)
                || (toffset > (long)value.length - len)
                || (ooffset > (long)other.value.length - len)) {
            return false;
        }
        while (len-- > 0) {
            char c1 = ta[to++];
            char c2 = pa[po++];
            if (c1 == c2) {
                continue;
            }
            if (ignoreCase) {
                // If characters don't match but case may be ignored,
                // try converting both characters to uppercase.
                // If the results match, then the comparison scan should
                // continue.
                char u1 = Character.toUpperCase(c1);
                char u2 = Character.toUpperCase(c2);
                if (u1 == u2) {
                    continue;
                }
                // Unfortunately, conversion to uppercase does not work properly
                // for the Georgian alphabet, which has strange rules about case
                // conversion.  So we need to make one last check before
                // exiting.
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }

hashcode() :

 public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
}