OpenJDK 源代码阅读之 String

概要

类继承关系

java.lang.Object
    java.lang.String

定义

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

要点

一旦创建就不可改变

实现

storage

/** The value is used for character storage. */
private final char value[];

可以看出

String

中的数据是如何存储的。

初始化

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

可以看出使用

String

类型初始化，新

String

实际上与原来的

String

指向同一块内存。

public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

如果用

char[]

初始化，可以看出，新分配了内存，并复制，保证了两者相互独立，只是内容相同。

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

注意用

StringBuffer

初始化时，对同一

buffer

是线程安全的，即初始化

String

的过程中，其它线程不会改变

buffer

的内容。

另外，能告诉我下面这段代码是怎么回事么？

public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

为啥这次不同步了呢？

equals

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)

value

直接通过点访问了，

value

是

private

的啊，怎么能这样？

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

String

的

hashCode

公式：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

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

从中可以看出，虽然说是

replace

，但是实际上还是新生成了

buf

，然后再生成新的

String

，而不是在原来的

value

上修改。如果有大量的替换，还是自己实现比较好诶～

indexOf

/**
 * Code shared by String and StringBuffer to do searches. The
 * source is the character array being searched, and the target
 * is the string being searched for.
 *
 * @param   source       the characters being searched.
 * @param   sourceOffset offset of the source string.
 * @param   sourceCount  count of the source string.
 * @param   target       the characters being searched for.
 * @param   targetOffset offset of the target string.
 * @param   targetCount  count of the target string.
 * @param   fromIndex    the index to begin searching from.
 */
static int indexOf(char[] source, int sourceOffset, int sourceCount,
        char[] target, int targetOffset, int targetCount,
        int fromIndex) {
    if (fromIndex >= sourceCount) {
        return (targetCount == 0 ? sourceCount : -1);
    }
    if (fromIndex < 0) {
        fromIndex = 0;
    }
    if (targetCount == 0) {
        return fromIndex;
    }

    char first = target[targetOffset];
    int max = sourceOffset + (sourceCount - targetCount);

    for (int i = sourceOffset + fromIndex; i <= max; i++) {
        /* Look for first character. */
        if (source[i] != first) {
            while (++i <= max && source[i] != first);
        }

        /* Found first character, now look at the rest of v2 */
        if (i <= max) {
            int j = i + 1;
            int end = j + targetCount - 1;
            for (int k = targetOffset + 1; j < end && source[j]
                    == target[k]; j++, k++);

            if (j == end) {
                /* Found whole string. */
                return i - sourceOffset;
            }
        }
    }
    return -1;
}

这段代码从

source

中寻找

target

第一次出现的位置，

for

循环每次都先让

i

停留在一个位置，此位置上内容与

target

首字符相同，然后开始遍历。可以看出这是一个

O(n^2)

的算法，所以，标准库也不一定是最高效的，要是要高效，还是需要自己实现，或者找其它库的。

matches

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

正则表达式匹配函数。可以看出，是直接调用了

Pattern

中的相应函数。

public String[] split(String regex, int limit) {
    /* fastpath if the regex is a
     (1)one-char String and this character is not one of the
        RegEx's meta characters ".$|()[{^?*+\\", or
     (2)two-char String and the first char is the backslash and
        the second is not the ascii digit or ascii letter.
     */
    char ch = 0;
    if (((regex.value.length == 1 &&
         ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
         (regex.length() == 2 &&
          regex.charAt(0) == '\\' &&
          (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
          ((ch-'a')|('z'-ch)) < 0 &&
          ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
         ch > Character.MAX_LOW_SURROGATE))
    {
        int off = 0;
        int next = 0;
        boolean limited = limit > 0;
        ArrayList<String> list = new ArrayList<>();
        while ((next = indexOf(ch, off)) != -1) {
            if (!limited || list.size() < limit - 1) {
                list.add(substring(off, next));
                off = next + 1;
            } else {    // last one
                //assert (list.size() == limit - 1);
                list.add(substring(off, value.length));
                off = value.length;
                break;
            }
        }
        // If no match was found, return this
        if (off == 0)
            return new String[]{this};

        // Add remaining segment
        if (!limited || list.size() < limit)
            list.add(substring(off, value.length));

        // Construct result
        int resultSize = list.size();
        if (limit == 0)
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
                resultSize--;
        String[] result = new String[resultSize];
        return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

按

regex

将字符串分割，思路是如果是单个字符，或者转义字符，就手工分割，否则就直接调用

Pattern.comile(regex).split

函数。手工分割时每次都将

[off,
 next]

之间的内容加入

list

，最后将 剩余的

[off,
 ]

加入。另外注意

limit

对分割次数的限制。