JDK1.4, 1.5 的 String Class 代码如下

[code]

public final class String

    implements java.io.Serializable, Comparable<String>, CharSequence

{

    /** The value is used for character storage. */

    private final char value[];

    /** The offset is the first index of the storage that is used. */

    private final int offset;

    /** The count is the number of characters in the String. */

    private final int count;

[/code]

[code]

    /**

     * Initializes a newly created <code>String</code> object so that it

     * represents the same sequence of characters as the argument; in other

     * words, the newly created string is a copy of the argument string. Unless

     * an explicit copy of <code>original</code> is needed, use of this

     * constructor is unnecessary since Strings are immutable.

     *

     * @param   original   a <code>String</code>.

     */

    public String(String original) {

            int size = original.count;

            char[] originalValue = original.value;

            char[] v;

            if (originalValue.length > size) {

                // The array representing the String is bigger than the new

                // String itself.  Perhaps this constructor is being called

                // in order to trim the baggage, so make a copy of the array.

                v = new char[size];

                System.arraycopy(originalValue, original.offset, v, 0, size);

            } else {

                // The array representing the String is the same

                // size as the String, so no point in making a copy.

                v = originalValue;

            }

            this.offset = 0;

            this.count = size;

            this.value = v;

    }

[/code]

从这段构造函数中，我们可以看出，不同Reference的String之间有可能共享相同的 char[]。

[code]

    /**

     * Compares this string to the specified object.

     * The result is <code>true</code> if and only if the argument is not

     * <code>null</code> and is a <code>String</code> object that represents

     * the same sequence of characters as this object.

     *

     * @param   anObject   the object to compare this <code>String</code>

     *                     against.

     * @return  <code>true</code> if the <code>String </code>are equal;

     *          <code>false</code> otherwise.

     * @see     java.lang.String#compareTo(java.lang.String)

     * @see     java.lang.String#equalsIgnoreCase(java.lang.String)

     */

    public boolean equals(Object anObject) {

            if (this == anObject) {

                return true;

            }

            if (anObject instanceof String) {

                String anotherString = (String)anObject;

                int n = count;

                if (n == anotherString.count) {

                        char v1[] = value;

                        char v2[] = anotherString.value;

                        int i = offset;

                        int j = anotherString.offset;

                        while (n-- != 0) {

                            if (v1[i++] != v2[j++])

                                    return false;

                        }

                        return true;

                }

            }

            return false;

    }

[/code]

但是，equals 方法似乎忽略了这个可能。没有直接对两者的char[]的reference进行比较。

按照我的想法，应该加入这么一段。

[code]

            if (anObject instanceof String) {

                String anotherString = (String)anObject;

                int n = count;

                if (n == anotherString.count) {

                        char v1[] = value;

                        char v2[] = anotherString.value;

                        int i = offset;

                        int j = anotherString.offset;

                        ////{{

                        if(i == j && v1 == v2) return true; // NOTE: this line is added by me

                        ////}}

                        while (n-- != 0) {

                            if (v1[i++] != v2[j++])

                                    return false;

                        }

[/code]

这样就能够对应共享 char[] 的情况，能够加快比较速度。