可序列化的类和 == 运算符

Question

Here is the source code of the String.equals method:

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

Since String is Serializable, does it make sense to use the == operator in the String.equals method? If we try to compare two different String objects, maybe with the same memory address, located on different VM, will this work correctly?

In my own code I use equals method to compare two strings. I know what == does. I am asking if it make sense to have a == comparison in the equals method of the String class.

Answer 1

It makes perfect sense to use the == because if both the instance of string point to same reference they have to be equal so no need to compare the characters

Answer 2

Yes it makes sense, because java uses a pool of Strings, so when you create a String without using the new keyword, as long as both reference variables are the same String == will always be true.

Say you have "" in your string pool, if you do

String a = "";
String b = "";

Since "" is in the string pool, they will in fact be pointing to the same memory location and therefore

a == b 

Would be true

In fact as long as you don't use

 String c = new String("");

The reference variable will always be pointing to the "" in the String pool.

However when you use the new keyword a new memory allocation is created outside of the String pool. Therefore if you do:

 c == b

This will return false, because the reference to b is in the String pool, but the reference for c is not, it is outside the pool

However if we did

 String d = c.intern()
 d == b

This will return true, what intern does per the comments on the String class is

Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class String.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

As some already pointed out when the object is deserialized on the other JVM, it will be using that JVM String pool

Answer 3

Serializable means that an instance of the class can be converted into bytes and back into a an object instance using Java's default serialization mechanisms. When an object is deserialized, a new object instance is created based on the bytes and that instance exists in the JVM where it was deserialized. Serialization/deserialization does not magically make the same object instance accessible in multiple JVMs, but it just creates new object instances which are copies of each other.

Two JVMs cannot share object instances, so it's not possible that the == operator could be used to compare the addresses of object instances from different address spaces.

Answer 4

This IF case in the java api is an optimization. Because the Virtual Machine holds a String Cache and optimizes some (not all) Strings to literals. Some literals hold the same object reference.

With my JDK eg

String a = "ABCD";
String b = "ABCD";
if (a==b)

equals to true. Because both are in the Literal cache of my jvm. But its not enough to compare the object reference because not every String is saved in the literal cache.

eg

String a = new String("ABCD");
String b = new String("ABCD");
if (a==b)

will always be false because you explicitly call for a new object reference.

But even in the above case

if(a.intern()==b.intern())

will also equal to true.

There is also another post on this: Using static variables for Strings

Answer 5

Assuming that you are speaking about the following code snippet:

if (this == anObject) {
    return true;
}

It makes sense to use the == operator, since it will be only true when both strings are pointing to the same memory address. This is probably done in java.lang.String to optimize string comparison when string literals are used. You can check http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html for detailed description of how string literals are pooled in Java.

Answer 6

If we try to compare two different String objects, maybe with the same memory address, located on different VM, will this work correctly?

You can't do that. There is no way of comparing Strings in two VMs, with or without the == operator. Your question therefore isn't about anything. You would have to get them both into the same VM, whereupon you would call String.equals().

The == test is just a shorthand to avoid going through all the rest of the code. It is has nothing to do with Serialization whatsoever. And different VMs cannot possibly come into it.

Answer 7

No. Since "String" is not a primative type using == simply compares the address of the object and not the contents itself. By executing:

String a = "ABCD";
String b = "ABCD";

if (a == b)

You would get false because although string a & string b are the same their representations in memory are different.

The.equals() method is used to compare Strings (also, Objects) within Java as it compares the contents of the Object.