Question

在String类重写方法equal中使用count，value和offset。它们是什么，为什么我们不使用非常简单的数字，我们可以使用length（）函数，我们可以使用toCharArray();数组的值，对于偏移，我们可以使用length（）-1。我试图在Java文档中搜索那些关键字的数量，值和偏移但是没找到....

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

Answer 1

以下是定义：

value  -> array of char holding the chars present in the String
count  -> number of chars in the String
offset -> offset of first character to be considered in the value array

例如，考虑数组

char[] chars = new char[]{'a', 'b', 'c', 'd', 'e'};
String str = new String(chars, 1, 2);
System.out.println(str);   // Prints bc  

char[] chars2 = new char[]{'b', 'c'};
String str2 = new String(chars2, 0, 2);
System.out.println(str2);   // Prints bc

System.out.println(str.equals(str2));  // Prints true

您可以想象['a', 'b', 'c', 'd', 'e'] String的{{1}}和str ['b', 'c']的{{1}}值。{/ p>

事实并非如此。两个字符串内部都使用大小为2的字符数组，即数组String。

但是，当您要求str2时，它会创建一个新的['b', 'c']，其substring和String以及value的值不同。

此处有offset，count，value的说明，并附有一些示例

offset

Answer 2

来自JDK 1.8.0_65 - ＆gt; java.lang包裹 - ＆gt; String.java课程：

/**
 * Compares this string to the specified object.  The result is {@code
 * true} if and only if the argument is not {@code null} and is a {@code
 * String} object that represents the same sequence of characters as this
 * object.
 *
 * @param  anObject
 *         The object to compare this {@code String} against
 *
 * @return  {@code true} if the given object represents a {@code String}
 *          equivalent to this string, {@code false} otherwise
 *
 * @see  #compareTo(String)
 * @see  #equalsIgnoreCase(String)
 */
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;
}

其中value定义为

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

所以我希望这几乎可以回答你的疑问。

Answer 3

使用offset和count字段，因为String比较可能是另一个String的子字符串。在这种情况下，不会创建新的String对象，但该字符串指向另一个String内的位置。这就是count和offset字段存在的原因。

示例：

String s1 = "DoTheHuzzle";
String s2 = s1.subString(2, 5);   // "The"

在这种情况下，s2的{{1}}为2，offset为3。

解释String类中相等的重写方法

3 个答案: