How Does the `final` Keyword Affect String Comparisons in Java?

String Comparison and Finality in Java

In Java, strings play a pivotal role, and their behavior can be influenced by the final keyword. Consider the following code snippet:

String str1 = "str";
String str2 = "ing";
String concat = str1 + str2;

System.out.println(concat == "string");

This code concatenates two strings and then compares it with the literal string string using the equality operator ==. The result, as expected, is false.

However, when the string variables are declared final, the outcome changes:

final String str1 = "str";
final String str2 = "ing";
String concat = str1 + str2;

System.out.println(concat == "string");

In this case, the comparison expression now returns true. This change in behavior raises the question of how final affects string comparisons.

The Interplay of Finality and Interning

In Java, when a string is created with a compile-time constant expression (e.g., a literal string) and the string variable is marked as final, it becomes a constant variable. Such constant variables are inlined by the compiler, meaning their value is substituted in place where they are used.

In our second code example, the concatenation operation effectively becomes:

String concat = "str" + "ing"; // Inlined from final variables

This results in:

String concat = "string";

The string string is interned, meaning it is stored in a pool of unique string instances. The same interned instance is used for any other string literal with identical content.

When we compare concat with "string", we are actually comparing two references to the same interned instance. Hence, the result is true.

The Non-Final Case

In the first code example, since the string variables are not final, they are not compile-time constant expressions. The concatenation operation happens at runtime, which creates a new String object. This object is not interned, so its reference is different from the interned reference of "string", resulting in a false comparison.

Conclusion

In Java, declaring string variables as final and initializing them with compile-time constant expressions can impact string comparisons. When the string is interned, as it is with final variables, comparisons are made based on shared references to the unique interned instance, leading to potentially different outcomes.

The above is the detailed content of How Does the `final` Keyword Affect String Comparisons in Java?. For more information, please follow other related articles on the PHP Chinese website!