Java源代碼閱讀——字符串相關

一 String類

 

字符串存貯在一個final數組value中，並且未對外提供修改其內元素的方法，所以String類是不可變的。

 

 

 

private final char value[];

 

 

 

1.1 構造方法

 

 

 

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

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

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

通過上述構造方法可知，字符串的構造是通過將一個數組賦給當前String的value數組完成的。

 

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

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

由上述可知，用StringBuffer構造字符串是線程安全的，而StringBuilder是線程不安全的，通常應該優先使用StringBuilder類，因爲它支持所有與StringBuffer相同的操作，但由於它不執行同步，所以速度更快。

 

1.2 length()和empty（）

 

 

public int length() {
        return value.length;
}

 

 

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

 

length通過返回數組的長度取得。

1.3 charAt()

 

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

返回該索引對飲的數組值。

 

1.5 indexOf()

 

public int indexOf(int ch, int fromIndex) {
        final int max = value.length;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= max) {
            // Note: fromIndex might be near -1>>>1.
            return -1;
        }

        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            // handle most cases here (ch is a BMP code point or a
            // negative value (invalid code point))
            final char[] value = this.value;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == ch) {
                    return i;
                }
            }
            return -1;
        } else {
            return indexOfSupplementary(ch, fromIndex);
        }
    }

通過返回ch在value中的所有取得。

 

1.6 subString()

 

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

若beginIndex==0則直接返回當前String，否則new一個新String。

 

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

如果確實發生了字符替換，將會new 一個新的String返回。toUpperCase（）等若發生改變也返回的是新的String。

 

1.8 intern

 

public native String intern();

 

如果池已經包含一個等於此 String 對象的字符串（該對象由 equals(Object) 方法確定），則返回池中的字符串。否則，將此 String 對象添加到池中，並且返回此 String 對象的引用。 

二 StringBuffer類

2.1 構造函數

 

public StringBuffer() {
        super(16);
}

其父類構造函數爲：

 

 

AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}

即默認構造了大小爲16的數組。

 

public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
}

構造一個比當前字符串長16的字符串。

 

2.2 append（）

 

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
}

 

private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
}

void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
}

每次擴容爲原數組長度的2倍+2，若不夠則取count+len，即每次擴容胡至少爲minimumCapacity=count+len。

 

三 StringBuilder類

3.1 構造函數

 

public StringBuilder() {
        super(16);
}

 

類似StringBuffer。

四 StringBuffer VS StringBuilder

StringBuffer類的成員方法前面多了一個關鍵字：synchronized，所以它是線程安全的，由此帶來的問題是效率低。