Java String initialization

The idiomatic way is to use ternary/conditional operator (JLS 15.25):

String myString = (someCondition ? "something" : "something else");

But you can also do the more verbose if-else statement if you really feel you must:

final String myString;
if(someCondition) {
   myString = "something";
} else {
   myString = "something else";
}

Note that I've added final modifier in the above snippet. If you're planning on further reassignments to the variable, then of course it can't be final, so you can remove the modifier and of course the code would still work.

Why final?

The point of the final in the above snippet is to show that the if-else construct will assign to myString once and exactly once in all possible execution paths. That is the main idea of the proposed if-else solution: if you're going to assign a value to a local variable only once, even if it can be one of several possibilities, then make it final to enhance readability.

Contrast that with this "alternative" proposal for example:

// DON'T DO THIS! Example only!
String myString = "something else";
if (someCondition) myString = "something";

With this construct, you may be assigning to myString twice, thus you couldn't put final here even if there was no further reassignment. You also couldn't put final in either of the original = null; or = ""; proposals, and this is one of the main reasons why they're not recommendable.

There's no point in assigning a value to a variable if you're just going to overwrite it before you're going to use it. It hurts readability, and may potentially even hide bugs, e.g. when one execution path fails to overwrite this "initial" value.

References

• JLS 4.12.4 final Variables
• JLS 16 Definite Assignment

Summary

• Don't "initialize" a local variable just for the sake of doing it if you're going to overwrite it anyway
  • Let it be uninitialized, so that the compiler can help you identify a possible bug by pointing out any use of the variable while it's still uninitialized
  • If the code compiles, then the variable is assigned a "real" value at least once before all uses
• If you don't need to reassign a local variable, make it final to enhance readability
  • final immediately assures readers that no further reassignments are possible
  • The compiler can help you prevent making the mistake of subsequent reassignment
  • If the code compiles, then the variable is assigned a "real" value exactly once before all uses
• Generally speaking, you should let the compiler help you write the best, most readable code.

The initialization step is not necessary, and may confuse future readers.

My personal opinion is that this kind of variable should only be assigned once, hence it is a perfect candidate for the final keyword.

final String myString;
if (someCondition) {
   myString = "something";
} else {
   myString = "something else";
}

Note that the myString definition does not include an assignment (as this would prohibit later assignments) and that after the assignment it is read-only. This gives robust code and shows your intent more clearly.

Please also note that I believe in braces even for single lines. Probably a Perl habit, but if you don't, it will bite you someday.

String myString = "something else";
if(someCondition) myString = "something"; // (use curly braces if you prefer)

I prefer first one, because String myString = "" will create additional object in the pool

String mystring = null;
mystring.length() 
// Cause error

Above will cause error due to null pointer.

string myString = new String();
myString.length()
// will not cause error

I like to use later, but I think it's personal preference.

How about this follwing code ,anyways he wants to set something.

String myString = (someCondition)  ? "something " : "else something";

or this

String myString = "else something"; 

if (someCondition)
   myString = "something";

in the above case , if you are 90% sure that someCondition is always true. otherwise unnecessary object creation in declaration.Expecting comments from Gurus.