Playing with the == and the pool of strings

Java uses a mechanism called string interning, putting the Strings in a pool to try to store only one copy of each string in memory.

When Java finds string literals in the code, it always returns the same String instance, which points to an entry in the JVM's internal pool. Thus, it is quite possible to use the operator == to compare two variables that receive string literals:

String literal = "str";
String outraLiteral = "str";

System.out.println(literal == outraLiteral); //exibe true

Inclusive, because Java treats string literals as instances it is possible to compare a literal directly, like this:

System.out.println(literal == "str"); //também retorna true

On the other hand, we cannot rely on the comparison operator when we do not know how the String was created, since it is possible to create other instances in various ways. Example:

String novaInstancia = new String("str");
System.out.println("str" == novaInstancia); //retorna false

The above code creates a new String instance, which is not the same returned by the JVM for the literal "str".

But, however, in the meantime, that doesn't mean we have two entries of "str" in Java's pool. How can we verify this? Using the String.intern() method, which returns a reference to the String that is in the pool. Example:

String novaInstancia = new String("str");
System.out.println("str" == novaInstancia.intern()); //retorna true

Applying this to in the example of the question, we would have:

public class TesteString {
    public static void main(String[] args) {

        String str1 = "teste";
        String str2 = "Oteste".substring(1);

        System.out.println("str1: " + str1 + ", str2: " + str2);
        if(str1 == str2.intern()) {
            System.out.println("str1 igual a str2");
        }
        else {
            System.out.println("str1 diferente de str2");
        }
    }
}

And the result:

Str1: heads, str2: heads

Str1 equals str2

All very Interesting. But what if we created a string in a stunning way?

StringBuilder sb = new StringBuilder();
sb.append('s');
sb.append('t');
sb.append('r');
System.out.println("str" == sb.toString().intern()); //continua sendo true

But what about equals()?

If the comparison with == is faster than the equals() method, should we abandon the equals() and use the intern() everywhere? The answer is not .

Not all Strings are internalized in the pool immediately. When we call the intern() method, if it is not there, then Java will add it. The problem is that once in the pool a String goes to permanent memory and will no longer be collected by the garbage collector.

When you want speed and the set of values is relatively small, using the intern() method can be advantageous. But if we use this feature, for example, for processing text files, XML, databases, then we will soon see a OutOfMemoryError.

Also, adding A Strings in pool can also be an "expensive"operation. In addition, it is necessary to check if the String is already there is, Java will probably have to treat concurrent accesses.

And, finally, a big disadvantage is the code becoming more prone to bugs ( error prone ), since it is necessary that the developer always put the intern() when necessary.

Other ways to compare

Going a little further than the exact comparison of Strings, we have other interesting ways of comparison:

case insensitive (not considering capital and lowercase)

System.out.println("STR".equalsIgnoreCase("str")); //retorna true

A string contained in another

System.out.println("###STR###".contains("STR")); //retorna true

Which string is "bigger" than the other?

System.out.println("str1".compareTo("str2")); //retorna -1, pois "str1" é menor que "str2"

Or:

System.out.println("str1".compareToIgnoreCase("STR2")); //retorna -1, ignorando a capitalização

Method compareTo returns:

• 1 if the first String is greater than the second
• 0 if they are equal
• -1 if the first String is less than the second

Starts with...

System.out.println("str1".startsWith("str")); //returna true, pois "str1" começa com "str"

Ends with...

System.out.println("str1".endsWith("r1")); //return true, pois "str1" termina com "r1"

Regular expression

System.out.println("str2".matches("\\w{3}\\d")); //return true, pois corresponde à expressão regular

Is empty?

String str1 = "";
System.out.println(str1.isEmpty());
System.out.println(str1.length() == 0);
System.out.println(str1.equals(""));

Particularly I prefer the first method for Java >= 6 and the second for earlier versions.