Manipulation of a string in constant pool vs Manipulation of a string in non-constant pool - Perfomance

问题

I wanted to change a code which was like

if("T".equalsIgnoreCase(bo.getSubjectType()))  //method-1

if(String.valueOf('T').equalsIgnoreCase(bo.getSubjectType()))  //method-2

So for that reason I wrote a sample code

String s1 = "T";
String s2 = "T";
char c1 = 'T';
char c2 = 'T';
System.out.println(String.valueOf(c1) == String.valueOf(c2));   //  false
System.out.println(s1 == s2);   //  true

Which pretty much says String.valueOf(arg) produces a String literal and places it in constant pool. So my question is whether there would be any contrast in performance when we try to manipulate a String in non-constant pool and that in a constant pool - basically which one would be better approach method-1 or method-2?

回答1:

if(String.valueOf('T').equalsIgnoreCase(bo.getSubjectType()))

There is no advantage whatsoever to writing it like this.

String.valueOf('T') will always return a new string, equal to "T", because the result of String.valueOf(char) (or any valueOf overload, for that matter) is not cached. There is no reason to keep on creating the same string over and over.

Plus, it's more verbose.

Just stick with method 1.

回答2:

Method 2 is hard-readable and has no improvements at all.

String created using new operator operator, it always creates a new object in heap memory. String created using String literal may return an existing object from the String pool, if it already exists.

It will not return a String from the pool and creates a String using new operator (Oracle JDK 10 source):

 /**
 * Returns the string representation of the {@code char}
 * argument.
 *
 * @param   c   a {@code char}.
 * @return  a string of length {@code 1} containing
 *          as its single character the argument {@code c}.
 */
public static String valueOf(char c) {
    if (COMPACT_STRINGS && StringLatin1.canEncode(c)) {
        return new String(StringLatin1.toBytes(c), LATIN1);
    }
    return new String(StringUTF16.toBytes(c), UTF16);
}

If you want to define a String constant and that always will be loaded from the pool, just create a:

public static final String T = "T";

From JLS about string literals and pools:

class Test {
   public static void main(String[] args) {
   String hello = "Hello", lo = "lo";
   System.out.print((hello == "Hello") + " ");
   System.out.print((Other.hello == hello) + " ");
   System.out.print((other.Other.hello == hello) + " ");
   System.out.print((hello == ("Hel"+"lo")) + " ");
   System.out.print((hello == ("Hel"+lo)) + " ");
   System.out.println(hello == ("Hel"+lo).intern());
 }
}
class Other { static String hello = "Hello"; }
and the compilation unit:
package other; 
public class Other { 
    public static String hello = "Hello"; 
}
produces the output:

true true true true false true

This example illustrates six points:

• Literal strings within the same class (§8 (Classes)) in the same package (§7 (Packages)) represent references to the same String object (§4.3.1).

• Literal strings within different classes in the same package represent references to the same String object.

• Literal strings within different classes in different packages likewise represent references to the same String object.

• Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.

• Strings computed by concatenation at run time are newly created and therefore distinct.

• The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

来源：https://stackoverflow.com/questions/54343097/manipulation-of-a-string-in-constant-pool-vs-manipulation-of-a-string-in-non-con

标签

java

string

performance

pool