Is it wise to declare a String as final if I use it many times?

Question

I have a method repeatedMethod like this:

public static void repeatedMethod() {
    // something else
    anotherMethod("myString");
    // something else
}

public static void anotherMethod(String str) {
    //something that doesn't change the value of str
}

and I call the repeatedMethod many times.

I would like to ask if it is wise to declare myString as static final outside that method like this:

public static final String s = "myString";

public void repeatedMethod() {
    anotherMethod(s);
}

I think that when I do anotherMethod("myString"), a new instance of String is created. And since I do that many times, many instances of String are created.

Therefore, it might be better to create only one instance of String outside the repeatedMethod and use only that one every time.

score 6 · Accepted Answer · edited May 23 '17 at 12:29

What you are doing is right but for the wrong reason.

When you do anotherMethod("myString"), no new instance of String is actually going to be created: it might reuse a String from the String constant pool (refer to this question).

However, factoring common String values as constants (i.e. as private static final) is a good practice: if that constant ever needs to change, you only need to change it in one place of the source code (for example, if tomorrow, "myString" needs to become "myString2", you only have one modification to make)

janos · Answer 2 · 2015-10-31T12:33:02.217

String literals of the same text are identical, there won't be excessive object creation as you fear.

But it's good to put that string literal in a static final variable (a constant) with a descriptive name that documents the purpose of that string. It's generally a recommended practice to extract string literals to constants with good names.

This is especially true when the same string literal appears in more than one place in the code (a "magic string"), in which case it's strongly recommended to extract to a constant.

柯鴻儀 · Answer 3 · 2015-10-31T12:34:31.870

no, you don't need to do that ,there is a "constant pool" in the JVM ,for every inline string (ex:"myString") ,it will be treated as an constant variable implicitly, and every identical inline string will be put in the constant pool just once.

for example ,for

    String i="test",j="test";

there will be just one instance of constant variable "test" in the constant pool.

also refer to http://www.thejavageek.com/2013/06/19/the-string-constant-pool/

score 0 · Answer 4 · answered Oct 31 '15 at 13:33

Optimize for clarify before worrying about performance. String literals are only created once, ever (unless the literal is unloaded) Performance is not only less important usually but irreverent in this case.

You should define a constant instead repeating the same String to make it clear these strings don't happen to be the same, but must be the same. If someone trying to maintain the code later has to modify one String, does this mean they should all be changed or not.

BTW When you optimize for clarity you are also often optimizing for performance. The JIT looks for common patterns and if you try to out smart the optimizer you are more likely to confuse it resulting in less optimal code.

Is it wise to declare a String as final if I use it many times?

4 Answers4