CODEWITHSUNDEEP
javanullinitializationstring
Martlark
Martlark

Reputation: 14581

Should I set the initial java String values from null to ""?

Often I have a class as such:

public class Foo
{
private String field1;
private String field2;

// etc etc etc
}

This makes the initial values of field1 and field2 equal to null. Would it be better to have all my String class fields as follows?

public class Foo
{
private String field1 = "";
private String field2 = "";

// etc etc etc
}

Then, if I'm consistent with class definition I'd avoid a lot of null pointer problems. What are the problems with this approach?

Upvotes: 50

Views: 95802

Answers (11)

vsingh
vsingh

Reputation: 6749

No way. Why do you want to do that? That will give incorrect results. nulls and """ are not same.

Upvotes: 1

Nilesh Tailor
Nilesh Tailor

Reputation: 146

I know this is an old question but I wanted to point out the following:

  String s = null;

  s += "hello";
  System.out.println(s);// this will return nullhello

whereas

  String s = "";

  s += "hello";
  System.out.println(s); // this will return hello

obviously the really answer to this is that one should use StringBuffer rather than just concatenate strings but as we all know that for some code it is just simpler to concatenate.

Upvotes: 7

kunal
kunal

Reputation: 11

I think when you use String s = null it will create variable "s" on stack only and no object will exists on heap,but as soon as you declare things as like String s=""; what it will does is like it will create "" object on heap.As we know that Strings are immutable so whenever u wil assign new value to string varible everytime it will create new Object on heap...So I think String s=null is efficient than String s = "";

Suggestions are welcome!!!!!

Upvotes: 1

Peter Lawrey
Peter Lawrey

Reputation: 533492

I would suggest neither.

Instead you should give your fields sensible values. If they don't have to change, I would make them final.

public class Foo { 
    private final String field1; 
    private final String field2;
    public Foo(String field1, String field2) {
       this.field1 = field1;
       this.field2 = field2;
    }
    // etc. 
}

No need to assign, i'm-not-initialised-yet values. Just give it the initial values.

Upvotes: 5

John
John

Reputation: 1653

I disagree with the other posters. Using the empty string is acceptable. I prefer to use it whenever possible.

In the great majority of cases, a null String and an empty String represent the exact same thing - unknown data. Whether you represent that with a null or an empty String is a matter of choice.

Upvotes: 11

vinaynag
vinaynag

Reputation: 271

Null is better, that is why they are called unchecked exceptions {Null pointer exception}. When the exception is thrown, it tells you that you have to initialize it to some non null value before calling any methods on it.

If you do

private String field1 = "";

You are trying to supress the error. It is hard to find the bug, later.

Upvotes: 1

Michael Borgwardt
Michael Borgwardt

Reputation: 346260

Does it actually make sense in a specific case for the value to be used before it is set somewhere else, and to behave as an empty String in that case? i.e. is an empty string actually a correct default value, and does it make sense to have a default value at all?

If the answer is yes, setting it to "" in the declaration is the right thing to do. If not, it's a recipe for making bugs harder to find and diagnose.

Upvotes: 13

Paul Tomblin
Paul Tomblin

Reputation: 182772

Absolutely not. An empty string and a null string are entirely different things and you should not confuse them.

To explain further:

  • "null" means "I haven't initialized this variable, or it has no value"
  • "empty string" means "I know what the value is, it's empty".

As Yuliy already mentioned, if you're seeing a lot of null pointer exceptions, it's because you are expecting things to have values when they don't, or you're being sloppy about initializing things before you use them. In either case, you should take the time to program properly - make sure things that should have values have those values, and make sure that if you're accessing the values of things that might not have value, that you take that into account.

Upvotes: 57

Eric Petroelje
Eric Petroelje

Reputation: 60498

Generally it would be best to avoid this. A couple of reasons:

  1. Getting a NullPointerException is generally a good warning that you are using a variable before you should be, or that you forgot to set it. Setting it to an empty string would get rid of the NullPointerException, but would likely cause a different (and harder to track down) bug further down the line in your program.

  2. There can be a valid difference between null and "". A null value usually indicates that no value was set or the value is unknown. An empty string indicates that it was deliberately set to be empty. Depending on your program, that subtle difference could be important.

Upvotes: 7

Yuliy
Yuliy

Reputation: 17718

That way lies madness (usually). If you're running into a lot of null pointer problems, that's because you're trying to use them before actually populating them. Those null pointer problems are loud obnoxious warning sirens telling you where that use is, allowing you to then go in and fix the problem. If you just initially set them to empty, then you'll be risking using them instead of what you were actually expecting there.

Upvotes: 78

NSherwin
NSherwin

Reputation: 184

I would avoid doing this, you need to know if your instances aren't getting populated with data correctly.

Upvotes: 1

Related Questions