What is the best practice for initializing a String method (local) variable to avoid the "Variable might not have been initialized" error in Java?
String s=null; or String s="";
Does it make a difference? If so, which one is better and why?
I've read conflicting answers on the web.
Thanks!
Yes, it makes a difference. One is a reference to an empty string, one is a null reference. They're not the same.
Which is better? It depends whether you want a null value or a reference to an empty string... they behave differently, so pick the one which behaves the way you want it to.
I rarely need to assign a "dummy" value to a variable though - usually just initializing the variable at the point of declaration with the real value I want is fine. If you can give us more context, we may be able to help you structure your code better so this isn't a problem for you.
"" helps avoiding NPE, but also can result in uncaught bugs.Best practice is to make as many fields final as possible or use default values to avoid clients instantiating bad or incomplete objects. If it makes sense for the field to be an empty string by default (i.e. it will not risk logic errors) then by all means do it that way. Otherwise, at least null will throw an exception when a client invokes a method on an object that hasn't been properly instantiated.
So in general, try to force client code to create complete objects during construction. If you don't know what the string should be at construction time, then have them pass it in as a parameter. If the string is just used for internal logic, it may be better as a local variable or parameter - and in that case I generally prefer null to "" because == null is more explicit than isEmpty().
It all depends on what you want your program to do. Sometimes it can be useful to see whether a string has been set already or not at which null would be best. Other times you want to prevent NullPointers which makes "" better.
I prefer to initialize a String in Java as "", purely because I try to avoid null pointers. Null pointers add a lot of overhead that can be removed by assigning "" instead of null.
It's really depends what you're doing in your program.
"" (empty string) is connected only with String and it's safer than null. When you call methods from String class for example: replaceAll(), indexOf() the program will work correctly but when you have null, you have NullPointerException all time when you're calling method on it.
Consider if string empty value in your application is not something bad to you, then choose str="".
Notice that very often is better when NullPointerException is thrown because we know about an invalid state in our application, so when you want know about this set String to null by default.
Most often I would say: don't initialize your local variable at all when declaring it, if it would be a dummy value like "" or null. Put the real value in, or wait until you can put it in.
The compiler then will make sure that there is at least one assignment before any possible use of the variable. Only for the seldom cases where the compiler isn't smart enough to figure this out (since it needs information not available to it locally) I would use some initialization, and then usually null is better since it shows with a NullPointerException when I was wrong. (I might add an assert s != null after the point where I think the Initialization should be done to enforce this.)
