Question about == operator in java

Question

public class Demo {  

    public static void main(String[] args) {

        String s1 = "Hello";
        String s2 = "Hello";
        System.out.println("s1 == s2 " + (s1 == s2));

        String s5 = "Hel" + "lo";
        String s6 = "He" + "llo";
        System.out.println("s5 == s6 " + (s5 == s6));

        String s7 = "He";
        String s8 = "Hello";
        s7 = s7.concat("llo");
        System.out.println("s7 == s8 " + (s7 == s8));

        String s10 = "He";
        s10 = s10 + "llo";
        System.out.println("s1 == s10 "+(s1 == s10));
    }
}

In the preceding code s7 == s8 and s1 == s10 give false. Can someone please explain me, what is actually happened here in s7 = s7.concat ("llo"); and s10 = s10 + "llo"; I understand == operator checks reference and equal() checks content of object. But I need to know why s7 and s10 reference variables bit patterns are different from s8 and s1. If these things are related with compile time generated strings and run time generated strings then how can I identify whether it is compile time or run time string?

Answer 1

The reason this is happening is because Java is optimizing in the compiler. When it sees that you're assigning the literal string "Hello" to s1, it uses the same "Hello" for s2, since all Java String operations are non-destructive (eg they return a clone rather than modify the original), so that's a safe thing to do.

Same thing goes for "Hel" + "lo" vs "He" + "llo"; it's clever enough to figure out that they're the same thing.

The others are complex enough that it can't optimize them, and thus you end up with separate objects.

Answer 2

== doesn't check bit patterns, it will compare memory address for objects. Only the same object has the same memory address.

Answer 3

The equals operator tests if the references are the same (i.e. pointing at the same object), not if the values of the references are the same. If you need to test if one string equals another you should use the built-in .equals method. This will do a object value comparison. e.g.

final String expectedValue = "Foo";
final String actualValue = "F" + "oo";
if (expectedValue.equals(actualValue)) {
  // This will trigger where == would not
}

Additionally for safety's sake if you do compare two strings and one is a constant, it's usually best to invoke equals on the constant, i.e.

String myValue = getMyValue;
boolean theSame = "Some value".equals(myValue);

Rather than

String myValue = getMyValue;
boolean theSame = myValue.equals("Some Value");

The reason is the second form risks a null pointer exception which can be avoided by invoking equals() on the constant string which is guaranteed to be there.

Answer 4

You cannot make any assumption about string objects.

A VM could work hard to make sure that no two string objects containing exactly the same char array exist at the same time, while other VMs would allow duplicates.

Answer 5

The == operator only checks to see if two objects have the same address (pointer). Only for primitive types that aren't a referenece (like int, char, etc.) does it compare the value.

You need to use something like s1.equals(s2) to compare the contents of two strings.

Answer 6

In the example you provided this is what is happening:

String s7 = “He”;    //s7 is an object referencing a part of memory holding “He”
String s8 = “Hello”;   //s8 is an object referencing a part of memory holding “Hello”
s7 = s7.concat(“llo”); //s7.concat(“llo”) created a new object in memory that contains “Hello” and s7 now references this now object 

(s7==s8)             //checks if the equality of the object reference and this is false since they reference different memory addresses.

(s7.equals(s8))         //this will compare s7 and s8 however way the String class compares two String objects. 

Answer 7

Clint's answer is fine but I'll expand on it further and explain at the compiler level.

As you know, s1 and s2 will end up being references to the same string instance, "Hello".

For s5 and s6, the compiler sees constant expressions. That is, it sees an operation between two constants (the string literals). The compiler knows how to add strings and what the result would be. Since the values are known immediately at compile time, it does the addition for you, resulting in the literal string "Hello". Consequently, it has the same value as s1 and s2 so each will refer to the same instance as well.

s7 cannot be simplified the same way. s7 initially starts with "He" of course. The difference here is that s7 = s7.concat("llo"); as reassigning s7 to the result of a function call. This could not be simplified as is. As far as the Java compiler is concerned, the results of all function calls are not known at compile time. Since it doesn't know the resulting value, it cannot be simplified and is left as is. The resulting call returns a new instance of a "Hello" string which is not the same instance as the compile-time instance (which s8 shares).

s10 cannot be simplified the same way as well. s10 initially starts with "He" of course. Then is reassigned s10 = s10 + "llo"; This could not be simplified. Why you might ask? Well s10 is a non-final variable expression. Meaning technically, the compiler doesn't know it's value because it isn't a constant. If s10 was declared a final String, then this could be constant folded (when assigned to a different variable).

So consider this version of your test code:

public static void main(String[] args)
{
    String s1 = "Hello";
    String s2 = "Hello";
    System.out.println("1: s1 == s2 " + (s1 == s2));    // 1

    String s3 = "Hel" + "lo";
    String s4 = "Hel".concat("lo");
    System.out.println("2: s1 == s3 " + (s1 == s3));    // 2
    System.out.println("3: s1 == s4 " + (s1 == s4));    // 3

    String he = "He";
    String s5 = he + "llo";
    String s6 = he.concat("llo");
    System.out.println("4: s1 == s5 " + (s1 == s5));    // 4
    System.out.println("5: s1 == s6 " + (s1 == s6));    // 5

    final String fhe = "He";
    String s7 = fhe + "llo";
    String s8 = fhe.concat("llo");
    System.out.println("6: s1 == s7 " + (s1 == s7));    // 6
    System.out.println("7: s1 == s8 " + (s1 == s8));    // 7
}

Can you figure out which lines are true?

_{true, true, false, false, false, true, false
You might be wondering why the 3 and 7 aren't true. Short answer, the Java compiler wasn't programmed}
^{to be smart enough to recognize the concat() call so is treated as a regular function call.}