summary

• 1. The biggest highlight of JDK8 is the introduction of Optional class to solve NPE (NullPointerException)
• 2. The Alibaba development manual also recommends the use of the Optional class to prevent NPE
• 3. To sum up, solving NPE is the function of the Optional class and a highlight of JDK8

Optional Preview

• 1. Declaration of the Optional class
  • 1) It is declared final, that is, it cannot be inherited
  • 2) Use generic T, which specifies the type of object contained in option

    public final class Optional<T>

• 2. Important properties of the Optional class
  • 1) The value of the final type is the Optional containing object, where T is the type specified through the generic type when creating the Optional
  • 2) The global static constant EMPTY calls the parameterless construction of the Optional class, where the representative value is set to null

    private final T value;

	private static final Optional<?> EMPTY = new Optional<>();

• 3. Construction method of Optional class
  • It can be seen that the two construction methods of Optional are declared as private, which means that the external world cannot create Optional objects through new, that is, they are generally used internally

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

Optional - API

Optional delve - Demo

Note: only the frequently used methods are studied here, and other methods are not difficult to understand.

• Generally, the ofNullable method is used to create an Optional, because it can receive both non Null and Null
• Generally, the map method is used to replace the getter operation after non empty judgment
• Generally, the last value is obtained through the orElse method, in which null is generally passed in

package com.gezq.optionaldemos;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Optional;

/**
 * Desc: Simple test Optional
 *
 * @author gezq0714
 * @version MyDemo:1.0.0
 * @email ge051799qi@163.com
 * @date 2021/10/1 - 20:49
 * @since MyDemo:1.0.0
 */
public class Demo {
    public static void main(String[] args) {
        // Suppose User is an object queried in the database, and what we want to get is skillName
        User user = new User("gezq", "123456", new Skill("sing", Optional.of("you like sing")));
        // General operation
        String skillName1 = null;
        // 1. Judge user is not empty
        if (user != null) {
            // 2. Get skill
            final Skill skill = user.getSkill();
            // 3. Judge skill is not empty
            if (skill != null) {
                // 4. Get skillName
                skillName1 = skill.getSkillName();
            }
        }

        // Use Optional -- use map to get the value of common attributes
        final String skillName2 = Optional.ofNullable(user).map(User::getSkill).map(Skill::getSkillName).orElse(null);
        // Use Optional -- use flatMap to get the value of the attribute wrapped by Optional
        final String skillIntroduction = Optional.ofNullable(user).map(User::getSkill).flatMap(Skill::getIntroduction).orElse(null);

        System.out.println("General operation acquisition skillName: " + skillName1);
        System.out.println("use Optional obtain skillName: " + skillName2);
        System.out.println("use Optional obtain skillIntroduction: " + skillIntroduction);
        /*
            The output results are as follows:
            General operation: get skillName: sing
            Use Optional to get skillName: sing
            Use Optional to get skillIntroduction: you like sing
         */
    }

}

@AllArgsConstructor
@NoArgsConstructor
@Data
class User {
    private String username;
    private String password;
    private Skill skill;
}

@AllArgsConstructor
@NoArgsConstructor
@Data
class Skill {
    private String skillName;
    private Optional<String> introduction;
}