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

This article mainly explains "how to use Java Optional class". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn how to use Java Optional class.

Note: the sample code requires Java 11 and later. All the code is tested in the Vavr0.10.2 environment.

Introduction to Java Optional

Optional is not a new concept, and functional programming languages such as Haskell and Scala already provide implementations. After the method is called, Optional processing is very useful in cases where the return value is unknown or does not exist (such as null). The following is introduced by an example.

Create a new Optional instance

First, you need to get an Optional instance, and there are several ways to create a new Optional instance. Not only that, you can also create an empty Optional. Method 1, create through value, the process is very simple:

Optional four = Optional.of (Integer.valueOf (4))

If (four.isPresent) {

System.out.println ("Hoorayy! We have a value")

} else {

System.out.println ("No value")

}

Create a new Optional instance for Integer 4. The Optional obtained by this method always contains a value and is not null, as in the example above. Use ifPresent () to check for the existence of value. Notice that four is not an Integer, but a container containing integers. If you confirm that value exists, you can use the get () method to perform the unboxing operation. Ironically, if you don't check before calling get (), you might throw a NoSuchElementException.

Method two, another way to get an Optional object is to use stream. Some of the methods provided by Stream return Optional, which can be used to check whether the result exists, such as:

FindAny

FindFirst

Max

Min

Reduce

View the following code snippet:

Optional car = cars.stream () .filter (car- > car.getId () .equalsIgnoreCase (id)) .findFirst ()

Method 3, create a new Optional using Nullable. Null may be generated:

Optional nullable = Optional.ofNullable (client.getRequestData ())

Finally, you can create a new empty Optional:

Optional nothing = Optional.empty ()

How to use Optional

After you get the Optional object, you can use it. A typical scenario is to find records based on Id in an Spring repository. You can use Optional to implement code logic and avoid null checking (by the way, Spring also supports Vavr Option). For example, look up a book from the book warehouse.

Optional book = repository.findOne ("some id")

First of all, if you have this book, you can continue to execute the corresponding business logic. In the previous chapter, we implemented the function with if-else. Of course, there are other ways: Optional provides a method that accepts a Consumer object as input:

Repository.findOne ("some id") .ifPresent (book-> System.out.println (book))

You can also use method references directly, which looks simpler:

Repository.findOne ("some id") .ifPresent (System.out::println)

If the book is not available in the warehouse, you can use ifPresentOrElseGet to provide a callback function:

Repository.findOne ("some id") .ifPresentOrElseGet (book- > {

/ / if value exists

}, ()-> {

/ / if value does not exist

});

If the result does not exist, you can return another value:

Book result = repository.findOne ("some id") .orElse (defaultBook)

However, Optional also has its disadvantages, which need to be paid attention to when using it. In the last example, "make sure" can get a book anyway, either in the warehouse or from orElse. But what if the default return value is not a constant or needs to support some complex methods? First, Java executes findOne anyway, and then calls the orElse method. The default return value can be constant, but as I said before, the execution process is time-consuming.

Another example

Here's a simple example of how to actually use the Optional and Option classes. There is a CarRepository that can find a car based on the provided ID (such as the license plate number), and then use this example to show how to use Optional and Option.

First, add the following code

Start with the POJO class Car. It follows the immutable pattern, where all fields are marked final, with only getter and no setter. Provide all data during initialization:

Public class Car {

Private final String name

Private final String id

Private final String color

Public Car (String name, String id, String color) {

This.name = name

This.id = id

This.color = color

}

Public String getId () {

Return id

}

Public String getColor () {

Return color

}

Public String getName () {

Return name

}

@ Override

Public String toString () {

Return "Car" + name+ "with license id" + id+ "and of color" + color

}

}

Next, create the CarRepository class. There are two ways to find a car based on Id: one is the old way, using Optional. Similar to the previous practice in the Spring warehouse, the result may be null.

Publicclass CarRepository {

Private List cars

Public CarRepository () {

GetSomeCars ()

}

Car findCarById (String id) {

For (Car car: cars) {function () {/ / Foreign Exchange documentary www.gendan5.com if (car.getId () .equalsIgnoreCase (id)) {

Return car

}

}

Return null

}

Optional findCarByIdWithOptional (String id) {

Return cars.stream () .filter (car- > car.getId () .equalsIgnoreCase (id)) .findFirst ()

}

Private void getSomeCars () {

Cars = new ArrayList ()

Cars.add (new Car ("tesla", "1A9 4321", "red"))

Cars.add (new Car ("volkswagen", "2B1 1292", "blue"))

Cars.add (new Car ("skoda", "5C9 9984", "green"))

Cars.add (new Car ("audi", "8E4 4321", "silver"))

Cars.add (new Car ("mercedes", "3B4 5555", "black"))

Cars.add (new Car ("seat", "6U5 3123", "white"))

}

}

Note: the initialization process will add some car simulation data to the warehouse for easy demonstration. To highlight the point and avoid complication, the following discussion focuses on Optional and Option.

Use Java Optional

Create a new test using JUnit:

@ Test

Void getCarById () {

Car car = repository.findCarById ("1A9 4321")

Assertions.assertNotNull (car)

Car nullCar = repository.findCarById ("M432 KT")

Assertions.assertThrows (NullPointerException.class, ()-> {

If (nullCar = = null) {

Throw new NullPointerException ()

}

});

}

The above code snippet follows the old way. Find the car corresponding to the Czech license plate 1A9 4321 and check if the car exists. You can't find the corresponding car by entering the Russian license plate, because there are only Czech cars in the warehouse. The result is that null may throw a NullPointerException.

Next, use Java Optional. The first step is to get the Optional instance and return Optional from the repository using the specified method:

@ Test

Void getCarByIdWithOptional () {

Optional tesla = repository.findCarByIdWithOptional ("1A9 4321")

Tesla.ifPresent (System.out::println)

}

At this point, the findCarByIdWithOptional method is called to print the vehicle information, if any. Run the program and get the following results:

Car tesla with license id 1A9 4321 and of color red

But what if there is no specific method in the code? In this case, an Optional that may contain null, called nullable, can be returned from the method.

Optional nothing = Optional.ofNullable (repository.findCarById ("5T1 0965"))

Assertions.assertThrows (NoSuchElementException.class, ()-> {

Car car = nothing.orElseThrow (()-> new NoSuchElementException ())

});

In the above code snippet, we found another way. Create an Optional through findCarById, and return null if the car is not found. When the license plate number 5T1 0965 is not found, the NoSuchElementException can be thrown manually with orElseThrow. Alternatively, if the requested data is not in the warehouse, you can use orElse to return the default value:

Car audi = repository.findCarByIdWithOptional ("8E4 4311")

.orElse (new Car ("audi", "1W3 4212", "yellow")

If (audi.getColor () .equalsIgnoreCase ("silver")) {

System.out.println ("We have silver audi in garage!")

} else {

System.out.println ("Sorry, there is no silver audi, but we called you a taxi")

}

OK, I didn't find a silver Audi in the garage, so I had to take a taxi!

Use Vavr Option

Vavr OptionOption offers another solution. First, add dependencies to the project (using Maven) to install Vavr:

Io.vavr

Vavr

0.10.2

In short, Vavr provides a similar new Option instance of API. You can create a new Option instance from nullable, as shown below:

Option nothing = Option.of (repository.findCarById ("T543 KK"))

You can also use the none static method to create an empty container:

Option nullable = Option.none ()

In addition, there is another way to create a new Option with Java Optional. Look at the following code:

Option result = Option.ofOptional (repository.findCarByIdWithOptional ("5C9 9984"))

With Vavr Option, you can use the same API as Optional to accomplish the above tasks. For example, set the default value:

Option result = Option.ofOptional (repository.findCarByIdWithOptional ("5C9 9984"))

Car skoda = result.getOrElse (new Car ("skoda", "5E2 4232", "pink"))

System.out.println (skoda)

Alternatively, an exception can be thrown if the requested data does not exist:

Option nullable = Option.none ()

Assertions.assertThrows (NoSuchElementException.class, ()-> {

Nullable.getOrElseThrow ()-> new NoSuchElementException ()

});

In addition, when data is not available, you can do the following:

Nullable.onEmpty (()-> {

/ runnable

});

How to perform the operation based on whether the data exists, similar to ifPresent in Optional? There are several ways to implement it. Similar to isPresent in Optional, the corresponding method in Option is called isDefined:

If (result.isDefined ()) {

/ / implement the function

}

However, you can get rid of if-else by using Option. Can it be done in the same way as Optional? To use peek operations:

Result.peek (val-> System.out.println (val). OnEmpty (()-> System.out.println ("Result is missed"))

In addition, Vavr Option provides some other very useful methods that work better than Optional classes in functional programming. Therefore, it is recommended that you spend some time exploring Vavr Option javadocs trying to use these API. I will continue to follow up on some interesting features like map, narrow, isLazy and when.

Thank you for your reading, the above is the content of "how to use the Java Optional class", after the study of this article, I believe you have a deeper understanding of how to use the Java Optional class, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.