background

An example

business model

Person has Car family and Car field,

Car, each car has Insurance, with Insurance field;

Insurance insurance. Each insurance has a name field;

Requirement: obtain the name of insurance purchased for a Person object;

Routine programming

    public String getCarInsuranceName(Person person) {
        return person.getCar().getInsurance().getName();
    }

Check programming

 public String getCarInsuranceName_check(Person person) {
        if (Objects.nonNull(person)) {
            final Car car = person.getCar();
            if (Objects.nonNull(car)) {
                final Insurance insurance = car.getInsurance();
                if (Objects.nonNull(insurance)) {
                    return insurance.getName();
                }
            }
        }
        return "unkown";
    }

Defensive programming

public String getCarInsuranceName_protect(Person person) {
        if (Objects.isNull(person)) {
            return "unkown";
        }
        final Car car = person.getCar();
        if (Objects.isNull(car)) {
            return "unkown";
        }
        final Insurance insurance = car.getInsurance();
        if (Objects.isNull(insurance)) {
            return "unkown";
        }
        return insurance.getName();
    }

Compare the following disadvantages:

NPE's pain spot

The modeling object of missing value in java8 is Optional, which can solve the pain point of NPE and design better API

Optional

Modeling evolution of domain model

1. Person, which contains an Optional car field. A person may or may not have a car;
2. Car, including an Optional insurance field. A car may or may not be insured;
3. Insurance, an insurance company must have a name. It has a field name;

Construction method

map method - extract and transform values from objects

The following code is equivalent.

public class Test {
    public static final String UNKNOWN = "unknown";
    /**
     * traditional method
     * @param insurance
     * @return
     */
    public static String getInsuranceName(Insurance insurance){
        if (Objects.isNull(insurance)){
            return UNKNOWN;
        }
        return insurance.getName();
    }
    /**
     * map How to extract
     * @param insurance
     * @return
     */
    public static String getInsuranceNameOp(Insurance insurance){
       return Optional.ofNullable(insurance).map(Insurance::getName).orElse(UNKNOWN);
    }
}

flatMap method - convert to Optional object output;

    public static String getInsuranceName(Person person) {
        return Optional.ofNullable(person)
                .flatMap(Person::getCar)
                .flatMap(Car::getInsurance)
                .map(Insurance::getName).orElse(UNKNOWN);
    }

Default setting method (5 suitable for different scenarios)

Usage value (get or consume)

Multiple Optional operations

Examples are as follows:

    public static String getCheapestPrizeIsuranceNameOp(Person person, Car car) {
        return Optional.ofNullable(person)
                .flatMap(p -> Optional.ofNullable(car).map(c -> getCheapest(p, c)))
                .orElse(UNKNOWN);
    }

    public static String getCheapestPrizeIsuranceName(Person person, Car car) {
        if (Objects.nonNull(person) && Objects.nonNull(car)) {
            return getCheapest(person, car);
        }
        return UNKNOWN;
    }

    /**
     * Simulate to get the cheapest insurance
     *
     * @param person people
     * @param car    vehicle
     * @return Cheapest vehicle insurance name
     */
    private static String getCheapest(Person person, Car car) {
        return "pinan";
    }

filter method (filtering)

Comparison code:

    public static Insurance getPinanInsurance(Person person){
        Optional<Insurance> insuranceOptional = Optional.ofNullable(person).map(Person::getCar).map(Car::getInsurance);
        if (insuranceOptional.isPresent() &&  Objects.equals("pinan", insuranceOptional.get().getName())){
            return insuranceOptional.get();
        }
        return null;
    }

    public static Insurance getPinanInsurance_filter(Person person){
        return Optional.ofNullable(person)
                .map(Person::getCar)
                .map(Car::getInsurance)
                .filter(item->Objects.equals(item.getName(),"pinan" ))
                .orElse(null);
    }

Empty method (construct an empty Optional object)

Optional modification history code

Encapsulate potentially null objects

    public Object getFromMap(String key){

        Map<String,Object> map = new HashMap<>(4);
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");

        Object value = map.get(key);
        if (Objects.isNull(value)){
            throw new NoSuchElementException("Non-existent key");
        }
        return value;

    }


    public Object getFromMapOp(String key){

        Map<String,Object> map = new HashMap<>(4);
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");

        Object value = map.get(key);

        return Optional.ofNullable(value).orElseThrow(()->new NoSuchElementException("Non-existent key"));
    }

The model with exception can be replaced with Optional object

 /**
     * If the string is not a number, an exception is thrown
     * @param a Character string
     * @return number
     */
    public Integer string2Int(String a){
        return Integer.parseInt(a);
    }

    /**
     * Optional.empty Corresponding to the abnormal situation, it is easy to handle later;
     * @param a Character string
     * @return The integer that may fail to convert is delayed to the user.
     */
    public Optional<Integer> string2Int_op(String a){
        try{
            return Optional.of(Integer.parseInt(a));
        }catch (Exception ex){
            return Optional.empty();
        }
    }

Try not to use encapsulated Optional

In general, the use of Optional simplifies the code and makes the code more readable and maintainable.

Here's an example:

    public Integer getFromProperties(Properties properties, String key) {
        String value = properties.getProperty(key);
        if (Objects.nonNull(value)) {
            try {
                Integer integer = Integer.parseInt(value);
                if (integer > 0) {
                    return integer;
                }
            } catch (Exception ex) {
                //No exception to handle
                return 0;
            }
        }
        return 0;
    }


    public Integer getFromProperties_op(Properties properties, String key) {
        return Optional.ofNullable(properties.getProperty(key))
                .map(item -> {
                    try {
                        return Integer.parseInt(item);
                    } catch (Exception ex) {
                        return 0;
                    }
                })
                .orElse(0);
    }

Optional source reading

A container object may or may not have a non null value. If the value exists, isPresent() returns true. If there is no value, the object is treated as null and isPresent() returns false;
More methods depend on whether the container contains a value, such as orelse (return a default value when there is no value)
ifPresent(Consumer c) is to execute an action when the value exists;

This is a value based class, which uses identity sensitive operations, including comparison reference = =, hashcode, and synchronization for an Optional object, which may have unexpected results, and should be avoided.

Note for API writing:
Optional was originally designed as the return value of a method when it was explicitly required to represent a situation where there was no value.
If NULL is returned, there may be an error; if Optional object is not a null object, it always points to an instance of Optional object.
/**
 * A container object which may or may not contain a non-{@code null} value.
 * If a value is present, {@code isPresent()} returns {@code true}. If no
 * value is present, the object is considered <i>empty</i> and
 * {@code isPresent()} returns {@code false}.
 *
 * <p>Additional methods that depend on the presence or absence of a contained
 * value are provided, such as {@link #orElse(Object) orElse()}
 * (returns a default value if no value is present) and
 * {@link #ifPresent(Consumer) ifPresent()} (performs an
 * action if a value is present).
 *
 * <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
 * class; use of identity-sensitive operations (including reference equality
 * ({@code ==}), identity hash code, or synchronization) on instances of
 * {@code Optional} may have unpredictable results and should be avoided.
 *
 * @apiNote
 * {@code Optional} is primarily intended for use as a method return type where
 * there is a clear need to represent "no result," and where using {@code null}
 * is likely to cause errors. A variable whose type is {@code Optional} should
 * never itself be {@code null}; it should always point to an {@code Optional}
 * instance.
 *
 * @param <T> the type of value
 * @since 1.8
 */

Other codes are relatively simple. The model contains a value of type T. empty() is a special Optional object, and its value is null;

public final class Optional<T> {
    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * If non-null, the value; if null, indicates no value is present
     */
    private final T value;

    /**
     * Constructs an empty instance.
     *
     * @implNote Generally only one empty instance, {@link Optional#EMPTY},
     * should exist per VM.
     */
    private Optional() {
        this.value = null;
    }

Summary