What is null in Java?
Is null an instance of anything?
No, there is no type which null
is an instanceof
.
15.20.2 Type Comparison Operator instanceof
RelationalExpression:
RelationalExpression instanceof ReferenceType
At run time, the result of the
instanceof
operator istrue
if the value of the RelationalExpression is notnull
and the reference could be cast to the ReferenceType without raising aClassCastException
. Otherwise the result isfalse
.
This means that for any type E
and R
, for any E o
, where o == null
, o instanceof R
is always false
.
What set does 'null' belong to?
JLS 4.1 The Kinds of Types and Values
There is also a special null type, the type of the expression
null
, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. Thenull
reference is the only possible value of an expression of null type. Thenull
reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend thatnull
is merely a special literal that can be of any reference type.
What is null?
As the JLS quote above says, in practice you can simply pretend that it's "merely a special literal that can be of any reference type".
In Java, null == null
(this isn't always the case in other languages). Note also that by contract, it also has this special property (from java.lang.Object
):
public boolean equals(Object obj)
For any non-
null
reference valuex
,x.equals(null)
shouldreturn false
.
It is also the default value (for variables that have them) for all reference types:
JLS 4.12.5 Initial Values of Variables
- Each class variable, instance variable, or array component is initialized with a default value when it is created:
- For all reference types, the default value is
null
.
How this is used varies. You can use it to enable what is called lazy initialization of fields, where a field would have its initial value of null
until it's actually used, where it's replaced by the "real" value (which may be expensive to compute).
There are also other uses. Let's take a real example from java.lang.System
:
public static Console console()
Returns: The system console, if any, otherwise
null
.
This is a very common use pattern: null
is used to denote non-existence of an object.
Here's another usage example, this time from java.io.BufferedReader
:
public String readLine() throws IOException
Returns: A
String
containing the contents of the line, not including any line-termination characters, ornull
if the end of the stream has been reached.
So here, readLine()
would return instanceof String
for each line, until it finally returns a null
to signify the end. This allows you to process each line as follows:
String line;
while ((line = reader.readLine()) != null) {
process(line);
}
One can design the API so that the termination condition doesn't depend on readLine()
returning null
, but one can see that this design has the benefit of making things concise. Note that there is no problem with empty lines, because an empty line "" != null
.
Let's take another example, this time from java.util.Map<K,V>
:
V get(Object key)
Returns the value to which the specified key is mapped, or
null
if this map contains no mapping for the key.If this map permits
null
values, then a return value ofnull
does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key tonull
. ThecontainsKey
operation may be used to distinguish these two cases.
Here we start to see how using null
can complicate things. The first statement says that if the key isn't mapped, null
is returned. The second statement says that even if the key is mapped, null
can also be returned.
In contrast, java.util.Hashtable
keeps things simpler by not permitting null
keys and values; its V get(Object key)
, if returns null
, unambiguously means that the key isn't mapped.
You can read through the rest of the APIs and find where and how null
is used. Do keep in mind that they aren't always the best practice examples.
Generally speaking, null
are used as a special value to signify:
- Uninitialized state
- Termination condition
- Non-existing object
- An unknown value
How is it represented in the memory?
In Java? None of your concern. And it's best kept that way.
Is null
a good thing?
This is now borderline subjective. Some people say that null
causes many programmer errors that could've been avoided. Some say that in a language that catches NullPointerException
like Java, it's good to use it because you will fail-fast on programmer errors. Some people avoid null
by using Null object pattern, etc.
This is a huge topic on its own, so it's best discussed as answer to another question.
I will end this with a quote from the inventor of null
himself, C.A.R Hoare (of quicksort fame):
I call it my billion-dollar mistake. It was the invention of the
null
reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in anull
reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
The video of this presentation goes deeper; it's a recommended watch.
What does null mean?
Formally, null
is a singleton member of the null
type, which is defined to be the subtype of every other Java type.
null
is a reference type and its value is the only reference value which doesn't refer to any object. Therefore there is no representation of null
in memory. The binary value of a reference-typed variable whose value is null
is simply zero (all zero bits). Even though this is not explicitly specified, it follows from the general initialization semantics of objects and any other value would cause major problems to an implementation.
Best way to check for null values in Java?
Method 4 is best.
if(foo != null && foo.bar()) {
someStuff();
}
will use short-circuit evaluation, meaning it ends if the first condition of a logical AND
is false.
Difference between null and empty () Java String
"" 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.
What is the difference between null, 0 and nothing?
null
means that a variable contains a reference to a space in memory that does not contain an object.
0
is a numeric data type with a value of 0.
Nothing
doesn't really exist, however I think you may be viewing this as an empty String ""
which is simply a String
data type that does not contain a value.
If your looking at this from a Javascript
paradigm it may be confusing. In Java variables are not truthy and falsey therefore the type is considered in comparisons.
Is null a Java keyword?
No.It is not a keyword.
Difference between null and empty string
String s1 = "";
means that the empty String
is assigned to s1
.
In this case, s1.length()
is the same as "".length()
, which will yield 0
as expected.
String s2 = null;
means that (null
) or "no value at all" is assigned to s2
. So this one, s2.length()
is the same as null.length()
, which will yield a NullPointerException
as you can't call methods on null
variables (pointers, sort of) in Java.
Also, a point, the statement
String s1;
Actually has the same effect as:
String s1 = null;
Whereas
String s1 = "";
Is, as said, a different thing.
Related Topics
Show Jdbc Resultset in HTML in Jsp Page Using MVC and Dao Pattern
Solving a "Communications Link Failure" With Jdbc and MySQL
How Do the Post Increment (I++) and Pre Increment (++I) Operators Work in Java
What Is a Numberformatexception and How to Fix It
Why Are Only Final Variables Accessible in Anonymous Class
In Java, How to Determine the Size of an Object
Why Is Char[] Preferred Over String For Passwords
How to Create a File and Write to It
How to Import the Javax.Servlet/Jakarta.Servlet API in My Eclipse Project
How to Read/Convert an Inputstream into a String in Java
Converting Iso 8601-Compliant String to Java.Util.Date
How to Parse Invalid (Bad/Not Well-Formed) Xml
What Is a Serialversionuid and Why Should I Use It
The Asynctask API Is Deprecated in Android 11. What Are the Alternatives
Xss Prevention in Jsp/Servlet Web Application
Problems Submitting a Login Form With Jsoup
How to Save the Current Date/Time When I Add New Value to Firebase Realtime Database
How to Stop Repeated Keypressed()/Keyreleased() Events in Swing