3.6 The Binary String Concatenation Operator

3.6 The Binary String Concatenation Operator +

The binary operator + is overloaded in the sense that the operation performed is determined by the type of the operands. When one of the operands is a String object, the other operand is implicitly converted to its string representation and string concatenation is performed. Non- String operands are converted as follows :

• For a operand of a primitive data type, its value is converted to a String object with the string representation of the value.

• Values like true , false , and null are represented by string representations of these literals. A reference variable with the value null also has the string representation "null" in this context.

• For all reference value operands, a string representation is constructed by calling the toString() method on the referred object. Most classes override this method from the Object class in order to provide a more meaningful string representation of their objects. Discussion of the toString() method can be found in Section 10.2.

The result of the concatenation is always a new String object. The String class is discussed in Section 10.5.

 String theName = " Uranium"; theName = " Pure" + theName;                  // " Pure Uranium" String trademark1 = 100 + "%" + theName;      // "100% Pure Uranium"      (1) 

The integer literal 100 is implicitly converted to the string "100" before concatenation. This conversion is corresponds to first creating an object of the wrapper class Integer , which represents the integer 100 , and then creating a string from this object by using the toString() method supplied by this class:

 new Integer(100).toString(); 

Note that using the character literal '%' , instead of the string literal "%" in line (1) above, does not give the same result:

 String trademark2 = 100 + '%' + theName;      // "137 Pure Uranium" 

Integer addition is performed by the first + operator: 100 + '%' , that is, (100 + 37) . Caution should be exercised as the + operator might not be applied as intended, as shown by the following example:

 System.out.println("We put two and two together and get " + 2 + 2); 

The above statement prints "We put two and two together and get 22" and not "We put two and two together and get 4" . The first integer literal 2 is promoted to a String literal "2" for the first concatenation, resulting in the String literal "We put two and two together and get 2" . This result is then concatenated with the String literal "2" . The whole process proceeds as follows:

 "We put two and two together and get " +  2  +  2 "We put two and two together and get " + "2" +  2 "We put two and two together and get 2" +  2 "We put two and two together and get 2" + "2" "We put two and two together and get 22" 

Both occurrences of the + operator are treated as string concatenation. A pair of parentheses might be in order to perform arithmetic addition, to convey the intended meaning of the sentence

 System.out.println("We put two and two together and get " + (2 + 2)); 

The compiler uses a string buffer to avoid the overhead of temporary String objects when applying the string concatenation operator ( + ), as explained in Section 10.6 on page 424.