Difference between null and empty (“”) Java String

问题:

What is the difference between null and the \"\" (empty string)?

I have written some simple code:

String a = \"\";
String b = null;

System.out.println(a == b); // false
System.out.println(a.equals(b)); // false

Both statements return false. It seems, I am not able to find what is the actual difference between them.

回答1:

\"\" is an actual string, albeit an empty one.

null, however, means that the String variable points to nothing.

a==b returns false because \"\" and null do not occupy the same space in memory--in other words, their variables don\'t point to the same objects.

a.equals(b) returns false because \"\" does not equal null, obviously.

The difference is though that since \"\" is an actual string, you can still invoke methods or functions on it like

a.length()

a.substring(0, 1)

and so on.

If the String equals null, like b, Java would throw a NullPointerException if you tried invoking, say:

b.length()

---

If the difference you are wondering about is == versus equals, it\'s this:

== compares references, like if I went

String a = new String(\"\");
String b = new String(\"\");
System.out.println(a==b);

That would output false because I allocated two different objects, and a and b point to different objects.

However, a.equals(b) in this case would return true, because equals for Strings will return true if and only if the argument String is not null and represents the same sequence of characters.

Be warned, though, that Java does have a special case for Strings.

String a = \"abc\";
String b = \"abc\";
System.out.println(a==b);

You would think that the output would be false, since it should allocate two different Strings. Actually, Java will intern literal Strings (ones that are initialized like a and b in our example). So be careful, because that can give some false positives on how == works.

回答2:

You may also understand the difference between null and empty string this way:

回答3:

String is an Object and can be null

null means that the String Object was not instantiated

\"\" is an actual value of the instantiated Object String like \"aaa\"

Here is a link that might clarify that point http://download.oracle.com/javase/tutorial/java/concepts/object.html

回答4:

What your statements are telling you is just that \"\" isn\'t the same as null - which is true. \"\" is an empty string; null means that no value has been assigned.

It might be more enlightening to try:

System.out.println(a.length()); // 0
System.out.println(b.length()); // error; b is not an object

\"\" is still a string, meaning you can call its methods and get meaningful information. null is an empty variable - there\'s literally nothing there.

回答5:

There is a pretty significant difference between the two. The empty string \"\" is \"the string that has no characters in it.\" It\'s an actual string that has a well-defined length. All of the standard string operations are well-defined on the empty string - you can convert it to lower case, look up the index of some character in it, etc. The null string null is \"no string at all.\" It doesn\'t have a length because it\'s not a string at all. Trying to apply any standard string operation to the null string will cause a NullPointerException at runtime.

回答6:

here a is an Object but b(null) is not an Object it is a null reference

System.out.println(a instanceof Object); // true

System.out.println(b instanceof Object); // false

here is my similar answer

回答7:

null means the name isn\'t referencing any instantiated object. \"\" means an empty string.

Here a is referencing some object which happens to be an empty string. b isn\'t referencing any object as it\'s null.

回答8:

In Java a reference type assigned null has no value at all. A string assigned \"\" has a value: an empty string, which is to say a string with no characters in it. When a variable is assigned null it means there is no underlying object of any kind, string or otherwise.

回答9:

\"\" and null both are different . the first one means as part of string variable declaration the string constant has been created in the string pool and some memory has been assigned for the same.

But when we are declaring it with null then it has just been instantiated jvm , but no memory has been allocated for it. therefore if you are trying to access this object by checking it with \"\" - blank variable , it can\'t prevent nullpointerexception . Please find below one use-case.

public class StringCheck {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    String s1 = \"siddhartha\";
    String s2 = \"\";
    String s3 = null;

    System.out.println(\"length s1 =\"+s1.length());
    System.out.println(\"length s2 =\"+s2.length());

    //this piece of code will still throw nullpointerexception . 
    if(s3 != \"\"){
        System.out.println(\"length s3 =\"+s3.length());
    }
}

}

回答10:

String s = \"\";
s.length();

String s = null;
s.length();

A reference to an empty string \"\" points to an object in the heap - so you can call methods on it.

But a reference pointing to null has no object to point in the heap and thus you\'ll get a NullPointerException.

回答11:

The empty string is distinct from a null reference in that in an object-oriented programming language a null reference to a string type doesn\'t point to a string object and will cause an error were one to try to perform any operation on it. The empty string is still a string upon which string operations may be attempted.

From the wikipedia article on empty string.

回答12:

A string can be empty or have a null value. If a string is null, it isn\'t referring to anything in memory. Try s.length()>0. This is because if a string is empty, it still returns a length of 0. So if you enter nothing for the same, then it will still continue looping since it doesn\'t register the string as null. Whereas if you check for length, then it will exit out of it\'s loop.

回答13:

This concept can be better understood from mathematics. Have you ever tried dividing a number (not zero) by 0 using a calculator e.g 7/0? You will get a result that looks like something this: undefined, not a number, null etc. This means that the operation is impossible, for some reasons (let\'s leave those reasons to be discussed another day).

Now, perform this: 0/7. You will get the output, 0. This means that the operation is possible and can be executed, but you the answer is just 0 because nothing is left after the division. There is a valid output and that output is zero.

In the first example, not only was the output invalid, the operation was not possible to execute. This is akin to null string in java. The second example is akin to empty string.