Concat an integer to a String - use String literal or primitive from performance and memory point of view?

Question

Option 1:

String newStr = someStr + 3 + \"]\";

Option 2:

String newStr = someStr + \"3\" + \"]\";

Which o

Answer 1

Whenever you concatenate a string, on each concatenation, you create a new copy of the string and both strings are copied over, one character at a time. This results in a time complexity of O(n²) (McDowell).

If you want to improve performance, use

StringBuilder

One of its constructors has the following syntax:

public StringBuilder(int size); //Contains no character. Initial capacity of 'size'. 

StringBuilder (mutable sequence of characters. Remember strings are immmutable) helps resolve this problem by simply creating a resizable array of all the strings. copying them back to a string only when necessary (McDowell).

StringBuilder str = new StringBuilder(0);
str.append(someStr);
str.append(3);
str.append("]");

Reference:

McDowell, Gayle Laakmann. Cracking The Coding Interview, 6th Edition. Print.

"Stringbuilder (Java Platform SE 8 )". Docs.oracle.com. N.p., 2016. Web. 4 June 2016.

Answer 2

The first will become:

StringBuilder sb = new StringBuilder (String.valueOf (someStr));
sb.append (3);
sb.append ("]");
String newStr = sb.toString ();

the second will become:

StringBuilder sb = new StringBuilder (String.valueOf (someStr));
sb.append ("3");
sb.append ("]");
String newStr = sb.toString ();

Here is disassembly:

public String foo (String someStr)
{
    String newStr = someStr + 3 + "]";
    return newStr;
}

public String bar (String someStr)
{
    String newStr = someStr + "3" + "]";
    return newStr;
}

public java.lang.String foo(java.lang.String);
Code:
   0: new           #16                 // class java/lang/StringBuilder
   3: dup
   4: aload_1
   5: invokestatic  #18                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   8: invokespecial #24                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
  11: iconst_3
  12: invokevirtual #27                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  15: ldc           #31                 // String ]
  17: invokevirtual #33                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  20: invokevirtual #36                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  23: astore_2
  24: aload_2
  25: areturn

public java.lang.String bar(java.lang.String);
Code:
   0: new           #16                 // class java/lang/StringBuilder
   3: dup
   4: aload_1
   5: invokestatic  #18                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
   8: invokespecial #24                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
  11: ldc           #44                 // String 3
  13: invokevirtual #33                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  16: ldc           #31                 // String ]
  18: invokevirtual #33                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  21: invokevirtual #36                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  24: astore_2
  25: aload_2
  26: areturn

Answer 3

I would recommend Jprofiler as a great java application profiling tool that helped me find lots of memory problems.

I don't think option 1 and 2 have a big difference in terms of memory usage, especially if it is for a desktop application.

Answer 4

Assuming that someString is constant, both are constant expressions and will be evaluated at compile time. They will result in identical class files and runtime behavior.

Source: The Java Language Specification writes:

A compile-time constant expression is an expression denoting a value of primitive type or a String that does not complete abruptly and is composed using only the following:

• Literals of primitive type and literals of type String (§3.10.1, §3.10.2, §3.10.3, §3.10.4, §3.10.5)

• The additive operators + and - (§15.18)

• ...

Compile-time constant expressions of type String are always "interned" so as to share unique instances, using the method String.intern.

If someString is not a constant, most modern compilers will use a StringBuilder, which is explicitly permitted by the Java Language Specification:

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 compile-time constant expression (§15.28).

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.

For primitive types, an implementation may also optimize away the creation of a wrapper object by converting directly from a primitive type to a string.

Answer 5

There won't be any noticeable difference between both. Use what you find the most logical and readable. I would use

String newStr = someStr + "3]";