Reference is not created while using + operator to concat two strings

Question

I am trying to concatenate two strings, one string with some value and another with empty.

Example:

String string1="Great"
String string2="";

and concatenating these two string with concat function and + operator

Example:

 String cat=string1.concat(string2)
 String operator=string1+string2

As per my understanding, while using empty string in concat function as the string2 is empty no new reference will be created. But while using + operator a new reference will be created in the string pool constant. But in the below code while using the + operator new reference is not created.

public class Main {
    
    public static void main(String[] args) {
        String string1="Great",string2="";

        String cat=string1.concat(string2);
        if(string1==cat)
        {
            System.out.println("Same");
        }
        else
        {
            System.out.println("Not same");
        }
        String operator=string1+string2;
        if(operator==string1)
            System.out.println("Same");
        else
            System.out.println("Not same");
    }
}

Output:

string 1 :69066349

cat :69066349

Same

string1 :69066349

operator :69066349

Not same

From the above code, as it's using + operator, the reference for the variable : operator should refer to the new memory, but it's pointing to the string1 reference. Please explain the above code.

String.hashCode() is a function of the value of the string, not its address — Ahmad, Dec 22 '21 at 05:47
Ya, But I checked the address reference by debugging the code. hashCode is for my reference. — Techguy, Dec 22 '21 at 05:48
hashCode has nothing to do with the reference here, it is solely a function of the string value — Ahmad, Dec 22 '21 at 05:50
Exactly, I removed the line now. My doubt is how "Not same" is printing for the second time instead of "Same" — Techguy, Dec 22 '21 at 05:54
it's because the two references are pointing to different objects in memory — Ahmad, Dec 22 '21 at 05:55
Does this answer your question? [String concatenation: concat() vs "+" operator](https://stackoverflow.com/questions/47605/string-concatenation-concat-vs-operator) — tgdavies, Dec 22 '21 at 06:02
No its pointing to the same reference, I checked the address by debugging. I mentioned it in the question. Read question carefully. — Techguy, Dec 22 '21 at 06:05

Stephen C · Accepted Answer · 2021-12-23T07:14:44.170

It is all in the documentation.

For String.concat, the javadoc states this:

If the length of the argument string is 0, then this String object is returned.

For the + operator, JLS 15.8.1 states:

The result of string concatenation is a reference to a String object that is the concatenation of the two operand strings. The characters of the left-hand operand precede the characters of the right-hand operand in the newly created string.

The String object is newly created (§12.5) unless the expression is a constant expression (§15.29).

As you can see, the results will be different for the case where the 2nd string has length zero and this is not a constant expression.

That is what happens in your example.

You also said:

But while using + operator a new reference will be created in the string pool constant.

This is not directly relevant to your question, but ... actually, no it won't be created there. It will create a reference to a regular (not interned) String object in the heap. (It would only be in the class file's constant pool ... and hence the string pool ... if it was a constant expression; see JLS 15.29)

Note that the string pool and the classfile constant pool are different things.

Can I add a couple of things:

You probably shouldn't be using String.concat. The + operator is more concise, and the JIT compiler should know how to optimize away the creation of unnecessary intermediate strings ... in the few cases where you might consider using concat for performance reasons.
It is a bad idea to exploit the fact that no new object is created so that you can use == rather than equals(Object). Your code will be fragile. Just use equals always for comparing String and the primitive wrapper types. It is simpler and safer.

In short, the fact that you are even asking this question suggests that you are going down a blind alley. Knowledge of this edge-case difference between concat and + is ... pointless ... unless you are planning to enter a quiz show for Java geeks.

Reference is not created while using + operator to concat two strings

1 Answers1