4

I come from a C#.net background and whenever I had a string I was declaring it as String.Empty Now I am looking at a Java code from a co-worker and he has declared his strings in a method like this:

String myStr = null;

I don't like it, and even worse, he is assigning values to these strings in an "IF" block where it may or may not even qualify, and then at the end of the method he is calling a myStr.length() on them.

So my question is what is a preferred way in Java? do you think is it better to define them as String.Empty OR leave them as null and do a null check just before calling .length() on them?

Improve this question
5
  • Do you mean myStr = ""; by String.Empty? Commented Jul 30, 2012 at 22:04
  • 2
    Won't that depend on what you are doing? Given that null and empty are different it could allow for more options in the flow. However, in general, I find it is better to NOT use null unless you have to have it. Commented Jul 30, 2012 at 22:05
  • @Eng.Fouad : Yes, an empty string. In .NET we could use String.Empty so I was just used to that syntax but yes that's what I meant to say. Commented Jul 30, 2012 at 22:06
  • 1
    That pattern of assigning a local variable a null value at the point of declaration and then reassigning it later under various circumstances is one i see quite a bit. It is a bad idea, because it defeats the compiler's ability to check whether it has been properly ("definitely") assigned. As you have observed, it leaves you in danger of NullPointerExceptions. I take it as a reliable sign of an unreliable programmer! Commented Jul 30, 2012 at 22:47
  • and about another point in using null as assignment u can use it with quite of less worry about being thrown null pointer exception as there are many tools like(FindBugs, checker framework which uses annotations to check for the possibilities of NullPointerException and warns you during compilation itself. Commented Jul 30, 2012 at 23:28

4 Answers 4

Reset to default
6

In general, using null values is a bad idea, especially if they are returned from a method or passed to another method. Using the Null Object pattern is better, and in a string's case the Null Object is an empty string. By consistently avoiding nulls, the probability of getting a NullPointerException gets smaller and the code becomes more readable (this is discussed at length in Clean Code chapter 7, pages 110-112).

In Java String s = "" does not allocate any memory, because the JVM will have interned the string literal, so there isn't even a performance difference (and even if there were, it would be a premature optimization).

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

The Null Object pattern defeats the compiler flow analysis that triggers 'variable not initialized' and also the use of sentinels unless you can show that the null object cannot occur in-band.
@esko valid point but that intern is a static method of String class so the strings created with it including that "" will never be garbage collected. so cost of using intern() increases linearly
@exex Wrong on all counts. 1. intern() is not a static method. 2. Even if it was, it wouldn't imply no GC. 3. Interned strings can be garbage collected. 4. The cost of using intern() increases linearly with the number of distinct strings, subject to garbage collection.
@EJP ohh my mistake- yeah that intern is not static method I saw String.intern() and interpreted it as being static
Returning blank string is in-band signaling is a sign of code smell. If a method's result is "none", then null is the appropriate value. Blanks string is just a magic value for those that are too lazy to do a null check.
|
4

They both have their uses. Empty strings are in-band, i.e. can occur in the input, so they are no use as sentinels. Null is only useful as a sentinel. If you're going to append to it you should initialize it with "" of course. If you're going to immediately reassign it there's no need to provide any value at all, and you should probably combine the declaration with the reassignment. I see far too much of this:

String s = new String();
s = "some string";

All this tells me is that somebody doesn't understand the language.

Improve this answer

1 Comment

+1 on the in-band. If the return value from a method is "no value", then null is the appropriate value.
3

thought both are applicable for different scenarios, assigning it null will be better(saves memory and less error prone) provided you later on set some string to that else you will be getting a null pointer exception.

Improve this answer

Comments

2

An empty String is often a sign that you should either be using a StringBuilder if you're appending (which is a common case). A null reference is 'better' because it uses less memory and it's faster to check if a String is null compared to checking if it's empty. I would advice against using empty Strings instead of declaring them as null, though you should still check for null reference before you use it unless you're 100% sure that it would have been assigned a value at some stage.

Improve this answer

4 Comments

The empty string is interned. Having multiple references to empty strings doesn't cost any memory.
@paranoid +1 - gud point empty string is usable to work with append of StringBuilder
@exex Actually, I meant that empty strings are often declared as such preceding a loop where the string is 'appended' to using +=. (Bad)
@MikeSamuel That's a very good point, thanks for pointing that out. +1

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.