Strings and things
Written by Antoni Boucher   
Article Index
Strings and things
Solution
Solution

Many Java programmers use the == operator to compare strings.

Nevertheless, if you want to compare the value of two String objects, you need to use a method.

The equals() method compares the text of the two String objects.

If the text is the same, it will return true.

Otherwise, it returns false.

So, this snippet works as expected:

public class StringEquality {
 public static void main(String[] args) {
  String string1 = "abc", string2 = "def";
  if((string1 + string2).equals("abcdef")) {
   System.out.println("Equal");
  }
 }
}

But why does the == operator work sometimes and at other times not?

It is because String objects in Java are immutable and the == operator is comparing object references, not the text of the strings. These two facts work together to make it look as if the == is sometimes correctly comparing string values.

Therefore, if you create two strings using this syntax:

String string1 = "abc";
String string2 = "abc";

Java will not create two String objects with the same value - just a single object containing "abc".

So, string1 and string2 will be referencing the same object in memory.

This is the reason why:

string1 == string2

is true.

The == operator checks if both objects reference the same object in memory and in this case this also means that the two strings are equal in value.

However if you use the String constructor, a new space in memory will be used for the new String object. That is following:

String string1 = "abc";
String string2 = new String("abc");

We have two string objects both holding the same text but now:

string1 == string2

is false because the two variables reference different object. The same thing happens if you compute a result on the fly or compare a string to a literal. For example:

string1 + string2 == "abcdef"

is false for two reasons. First string1 and string2 are concatenated as a new object and "abcdef" is yet another string object, and so they cannot be equal as references to an object.

Pattern

You should always use the equals() method if you want to compare the text of two String objects.

You might think that it is a disadvantage to be unable to compare String objects with the == operator.

But, don't forget that String in Java is not a primitive type; it is a class and hence uses reference semantics not value semantics.

Thus, we use == to know if two string objects are actually the same object in memory which also, almost as a side effect, ensures that they have the same text.

 

Banner

More Puzzles

Sharpen Your Coding Skills
Sharpen your Coding Skills - Elevator Puzzle

Introducing Melvin and Bugsy, characters who figure in a series of challlenges from Joe Celko. Sharpen your coding skills with puzzles that will both amuse and torment you.


C#
Programmer Puzzle - Class and struct

This C# puzzle shouldn't be difficult as long as you are secure in your understanding of class and structs. See if you can spot the danger as soon as you read it.


C++
Strange Initialization

Are you always speaking the same syntax as your compiler? This C++ puzzle looks at how you can put things together thinking they mean one thing when in fact they mean another...


Other Articles

 

<ASIN:0132130807>

<ASIN:0672330768>
<ASIN:0136091814>

<ASIN:0321356683>