What are the commonly used Optional methods in Java?

Preface

Optional in Java is a container object, which can contain a non-null value or be empty. Its main purpose is to avoid null pointer exceptions when writing code.

The complete usage of Optional in Java 8 is as follows:

1. Create Optional object

You can create an Optional object containing non-null values ​​through the of() method, for example:

Optional<String> optional = Optional.of("value");

You can also create an Optional object containing a possibly null value through the ofNullable() method, for example:

Optional<String> optional = Optional.ofNullable(null);

2. Get the value of the Optional object

You can use The get() method obtains the non-null value in the Optional object, for example:

String value = optional.get();

If the value in the Optional object is null, calling the get() method will throw a NoSuchElementException exception. Therefore, before calling the get() method, it is best to use the isPresent() method to determine whether the Optional object contains a non-null value.

3. Determine whether the Optional object contains a non-null value

You can use the isPresent() method to determine whether the Optional object contains a non-null value, for example:

if (optional.isPresent()) {
    // Optional对象包含非空值
} else {
    // Optional对象为空
}

You can also use The ifPresent() method performs some operations when the Optional object contains a non-null value, for example:

optional.ifPresent(value -> System.out.println(value));

4. Get the value or default value in the Optional object

You can use the orElse() method to get the Optional The value or default value in the object, for example:

String value = optional.orElse("default");

If the value in the Optional object is empty, the specified default value is returned.

5. Get the value in the Optional object or throw an exception

You can use the orElseThrow() method to get the value in the Optional object or throw an exception, for example:

String value = optional.orElseThrow(() -> new RuntimeException("value is null"));

If the value in the Optional object is null, the specified exception is thrown.

6. Convert the value in the Optional object

You can use the map() method to convert the value in the Optional object to another type of value, for example:

Optional<Integer> optional = Optional.of("123").map(Integer::parseInt);

If If the value in the Optional object is empty, an empty Optional object is returned.

7. Filter the value in the Optional object

You can use the filter() method to filter the value in the Optional object, for example:

Optional<String> optional = Optional.of("value").filter(value -> value.startsWith("v"));

If the value in the Optional object does not satisfy If the specified filter condition is specified, an empty Optional object is returned.

Java 9 Enhancements

We introduced the features of Java 8. Java 9 adds three methods to the Optional class: or(), ifPresentOrElse() and stream().

The or() method is similar to orElse() and orElseGet(), both of which provide alternative situations when the object is empty. The return value of or() is another Optional object produced by the Supplier parameter.

If the object contains a value, the Lambda expression will not be executed:

@Test
public void whenEmptyOptional_thenGetValueFromOr() {
    User result = Optional.ofNullable(user)
      .or( () -> Optional.of(new User("default","1234"))).get();

    assertEquals(result.getEmail(), "default");
}

In the above example, if the user variable is null, it will return an Optional, the User object it contains, Its email is "default".

The ifPresentOrElse() method requires two parameters: a Consumer and a Runnable. If the object contains a value, the Consumer's action will be executed, otherwise the Runnable will be executed.

If you want to perform an action when there is a value, or just track whether a certain value is defined, then this method is very useful:

Optional.ofNullable(user).ifPresentOrElse( u -> logger.info("User is:" + u.getEmail()),
  () -> logger.info("User not found"));

Additional: Optional dispute point

In fact, there is still a lot of controversy in the industry about whether Optional should be used. On the one hand, Optional can force developers to deal with null values, but on the other hand, Optional is very easy to abuse, especially when some developers get Optional. Then the get() or ifPresent() method is called directly, which hardly solves any problem and increases the coding burden.

Therefore, my suggestion is that if you don’t know whether to use Optional, don’t use it yet.

The following are some reference scenarios for using Optional, as follows:

1. Optional is generally used to return values ​​
   Optional is mostly used to return values ​​and is not recommended for members in variables or method parameters.

2. Optional itself does not judge null
   Never assign null to Optional, and do not judge whether Optional itself is null. This is because Optional is originally designed to solve null, and then introduce null. It’s boring. This should become the consensus of the industry.

3. Collections do not use Optional
   Because collections have better processing methods such as Collections.emptyList(), there is no need to use Optional.

4. Functional processing of values
   As you can see from the above usage introduction, Optional provides many lambda functional processing methods, such as filter, map, etc., which are used by Optional It is recommended to use Optional because it can help you automatically handle null value situations and avoid NPE exceptions.

5. Multi-layer attribute acquisition
   I mentioned this code sample before. I think this is the scenario where the benefits of using Optional are most obvious.

6. Not returning null is better than returning Optional
   Returning Optional to the caller will force the caller to handle the null situation, which will add some coding burden to the caller, especially for reuse. Very high degree of function.
   But if the caller does not expect to get null in most cases, it should implement a method that either returns a value or an exception, as follows:

/**
 * 查询订单，要么返回订单，要么异常
 */
public Order getOrderByIdOrExcept(Long orderId){
    Order order = orderMapper.getOrderById(orderId);
    if(order == null){
        throw new BizException("根据单号" + orderId + "未查询到订单！");
    }
    return order;
}
 
/**
 * 查询订单，值可能为null
 */
public Optional<Order> getOrderById(Long orderId){
    Order order = orderMapper.getOrderById(orderId);
    return Optional.ofNullable(order);
}

Because of the following The processing code relies on order data. If the order data cannot be obtained, the code cannot go down. Therefore, in most cases, it is better to use the getOrderByIdOrExcept method, which avoids NPE and increases the coding burden!

The above is the detailed content of What are the commonly used Optional methods in Java?. For more information, please follow other related articles on the PHP Chinese website!