Shulou(Shulou.com)06/02 Report--

This article introduces the knowledge of "how to avoid null pointer exceptions with Java8 Optional". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Programmers who say they haven't encountered null pointer exceptions are not Java programmers, and null does cause a lot of problems. A new class called java.util.Optional was introduced in Java 8 to avoid many of the problems caused by null.

Let's take a look at what harm a null reference can cause. First, create a class Computer with the structure shown in the following figure:

What happens when we call the following code?

String version = computer.getSoundcard (). GetUSB (). GetVersion ()

The above code seems fine, but many computers (for example, raspberry pie) actually don't have a sound card, so calling the getSoundcard () method is sure to throw a null pointer exception.

A regular but bad approach is to return a null reference to indicate that the computer does not have a sound card, but this means that the getUSB () method is called on an empty reference, obviously throwing a control exception while the program is running, causing the program to stop running. Think about how embarrassing it is to suddenly make such an error when your program is running on a client computer.

The great computer science Tony Hoare once wrote: "I think the creation of null references in 1965 led to a billion-dollar loss. The biggest temptation for me to use null references was that it was easy to implement."

So how do you avoid null pointer exceptions when the program is running? You need to be vigilant and constantly check for possible null pointers, like this:

String version = "UNKNOWN"; if (computer! = null) {Soundcard soundcard = computer.getSoundcard (); if (soundcard! = null) {USB usb = soundcard.getUSB (); if (usb! = null) {version = usb.getVersion ();}

However, you can see that there are too many null checks in the above code, and the whole code structure becomes very ugly. However, we have to use this judgment to ensure that there is no null pointer when the system is running. If there are a large number of such null reference judgments in our business code, it is simply exasperating, and the readability of our code will be very poor.

Null references are also potentially problematic if you forget to check whether the value to be given is empty. In this article, I will demonstrate that it is not a good idea to use a null reference as a representation of a value that does not exist. Instead of using null references, we need a better model that represents that the value does not exist.

Java 8 introduces a new class called java.util.Optional, which is inspired by Haskell and Scala, as long as you wrap the data in Optional, which is a container that wraps objects. This class can contain an arbitrary value, as shown in the following figure and code. You can think of Optional as a value that may contain a value, and if Optional does not contain a value, then it is empty, as shown in the following figure.

Public class Computer {private Optional soundcard; public Optional getSoundcard () {...}} public class Soundcard {private Optional usb; public Optional getUSB () {...}} public class USB {public String getVersion () {...}}

The above code shows that it is possible for a computer to replace a sound card (which may or may not exist). It is also possible for a sound card to contain a USB port. This is an improvement, and the model can reflect more clearly that a given value may not exist.

But what do you do with the Optional object? After all, what you want is the port number of USB. Quite simply, the Optional class contains methods to handle the presence or absence of a value. Compared to null references, the Optional class forces you to handle whether the values are relevant or not, thus avoiding null pointer exceptions.

It is important to note that the Optional class is not intended to replace the null reference. Instead, it is designed to make the API easier to understand. When you see the signature of a function, you can determine whether the value to be passed to the function may not exist. This prompts you to open the Optional class to handle situations that are really worth it.

Adopt Optional mode

After talking so much, let's take a look at some code! Let's first take a look at how to use Optional to rewrite traditional null reference detection. You will understand how to use Optional at the end of this article.

String name = computer.flatMap (Computer::getSoundcard) .flatMap (Soundcard::getUSB) .map (USB::getVersion) .orElse ("UNKNOWN")

Create an Optional object

You can create an empty Optional object:

Optional sc = Optional.empty ()

The next step is to create an Optional that contains non-null values:

SoundCard soundcard = new Soundcard (); Optional sc = Optional.of (soundcard)

If the sound card null, the null pointer exception will be thrown immediately (this is better than throwing when getting the sound card properties).

By using ofNullable, you can create an Optional object that may contain a null reference:

Optional sc = Optional.ofNullable (soundcard)

If the sound card is a null reference, the Optional object is empty.

Handling of values in Optional

Now that you have the Optional object, you can call the appropriate method to process whether the value in the Optional object exists. Instead of doing null detection, we can use the ifPresent () method, like this:

Optional soundcard =...; soundcard.ifPresent (System.out::println)

This eliminates the need for null detection, and if the Optional object is empty, the information will not be printed.

You can also use the isPresent () method to see if the Optional object actually exists. In addition, there is a get () method that returns the value contained in the Optional object, if it exists. Otherwise, a NoSuchElementException exception will be thrown. These two methods can be used together as follows to avoid exceptions:

If (soundcard.isPresent ()) {System.out.println (soundcard.get ());

But this method is not recommended (it has no improvement over null detection), so let's take a look at the usual ways to work.

Return default values and related actions

When you encounter null, a regular operation is to return a default value, which you can do with a ternary expression:

Soundcard soundcard = maybeSoundcard! = null? MaybeSoundcard: new Soundcard ("basic_sound_card")

If you use the Optional object, you can orElse () using overrides, and orElse () can return a default value when Optional is empty:

Soundcard soundcard = maybeSoundcard.orElse (new Soundcard ("defaut"))

Similarly, you can use orElseThrow () to throw an exception when Optional is empty:

Soundcard soundcard = maybeSoundCard.orElseThrow (IllegalStateException::new)

Use filter to filter specific values

We often call the method of an object to determine its properties. For example, you may need to check whether the USB port number is a specific value. To be safe, you need to check that the medical use pointing to USB is null, and then call the getVersion () method, like this:

USB usb =...; if (usb! = null & & "3.0" .equals (usb.getVersion () {System.out.println ("ok");}

If you use Optional, you can use the filter function to override:

Optional maybeUSB =...; maybeUSB.filter (usb-> "3.0" .equals (usb.getVersion ()) .ifPresent (()-> System.out.println (" ok "))

The filter method requires a predicate orientation as a parameter. If the value in Optional exists and satisfies predicate, the filter function will return the value that meets the condition; otherwise, it will return an empty Optional object.

Using map method to extract and transform data

A common pattern is to extract some properties of an object. For example, for a Soundcard object, you might need to get its USB object and determine its version number. Usually our implementation is like this:

If (soundcard! = null) {USB usb = soundcard.getUSB (); if (usb! = null & & "3.0" .equals (usb.getVersion ()) {System.out.println ("ok");}}

We can use the map method to override this detection null, and then extract objects of object type.

Optional usb = maybeSoundcard.map (Soundcard::getUSB)

This is the same as using the map function of stream. To use stream, you need to pass a function as an argument to the map function, which will be applied to every element in the stream. When stream time and space, nothing happens.

The value contained in Optional will be converted by the function passed in (here is a function to get USB from the sound card). If the Optional object is spatio-temporal, nothing will happen.

Then, we combine the map method and the filter method to filter out the sound card whose version number of USB is not 3.0.

MaybeSoundcard.map (Soundcard::getUSB) .filter (usb-> "3.0" .equals (usb.getVersion ()) .ifPresent (()-> System.out.println (" ok "))

So our code starts to look a bit like what we gave at first, without null detection.

Pass an Optional object using the flatMap function

Now that we have introduced an example where code can be refactored using Optional, how should we implement the following code in a secure way?

String version = computer.getSoundcard (). GetUSB (). GetVersion ()

Note that the above code extracts one object from another, which can be achieved using the map function. In the previous article, we set up that Computer contains an Optional object and Soundcard contains an Optional object, so we can ReFactor the code like this

String version = computer.map (Computer::getSoundcard) .map (Soundcard::getUSB) .map (USB::getVersion) .orElse ("UNKNOWN")

Unfortunately, the above code compiles errors, so why? The computer variable is of type Optional, so it has no problem calling the map function. But the getSoundcard () method returns an object of Optional and an object of type Optional. After a second call to the map function, the call to the getUSB () function becomes illegal.

The following figure depicts this scenario:

The source code implementation of the map function is as follows:

Public Optional map (Function

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.