java options 配置 java options类

一、四类函数式接口

随着java8 lambda表达式的兴起，在java中定义了最基本的四类函数式接口，其中，Optional 类大量的使用了函数式接口

1. java.util.function.Consumer (消费式)

// 传入一个参数， 没有返回值，只是在处理出入的参数
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

1. java.util.function.Function （函数式）

// 传入一个参数，对参数做完处理后，并返回相应的结果
@FunctionalInterface
public interface Function<T, R> {
		R apply(T t);
}

1. java.util.function.Predicate（断言式）

传入一个参数，并对这个参数做完判断后，返回一个布尔类型的值
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

1. java.util.function.Supplier (供应式)

// 没有参数，提供一个对象
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

其实这些个函数式接口相当于是回调的函数，以函数式的为例：

举例：

// 比如我们现在，封装一个函数，要对一个数字进行处理，我们不知道要怎么处理，
// 处理的方式要交给调用者

public class FunctionTest {
    Integer num;

    public FunctionTest(Integer num) {
        this.num = num;
    }
		
		// 处理数字的方法
		//在这里我们并没有，完全的规定处理数字的方法，而是交给了客户端去处理
    public Integer handlerDigital(Function<Integer, Integer> mapper ) {
        return mapper.apply(this.num);
    }
		

		// 客户端编写处理的方式，在这里我把 num * 100
    public static void main(String[] args) {
        Integer result = new FunctionTest(20).handlerDigital(a -> a * 100);
        System.out.println(result);
    }
}

二、Optional的错误使用

例如有一个Person类，只有person对象不为空时才去处理

if (person != null) {
	 doSomething();
}

// 如果你使用这种方法, 即增加了代码的复杂性， 又增加了理解的难度
Optional<Person> person = Optional.ofNullable(person);
if (person.isPresent()) {
    doSomething();
}

注： 尽量不要去使用Optional类中的isPresent()和get()
方法去做逻辑的处理，我认为，Optional类虽然增加类这些方法，但是它是为了自己内部方法更好的使用

三、个人对Optional的理解

对Optional类的理解分类四步

1. Optional对象的组成

public final class Optional<T> {
		
		// 一个空的Optional对象， 其实也就是value为空
    private static final Optional<?> EMPTY = new Optional<>();
		
		// 一个value值， 也就是用户传入的值
    private final T value;

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

2. Optional对象的创建

• 创建的方法

/**
 * 有三个静态的方法
 *  1. Optional.ofNullable(T value)  第一个最常用： 因为可以传入null值
 *  2. Optional.of(T value)          第二个： 如果传入的是null值，则会抛出空指针的异常
 *  3， Optional.empty()              返回一个空的Optional 对象
 */

• 创建的原理

Optional.of(T value)

Optional.ofNullable(T value)

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

1. Optional对象的中间处理
   分为两种

• 过滤处理 filter(Predicate<? super T> predicate)（使用断言式函数式接口）
• 映射处理 map(Function<? super T, ? extends U> mapper)和 flatMap(Function<? super T, Optional<U>> mapper) （使用函数式函数式接口）

2. Optional对象的最终转化为普通的对象或抛出异常
   orElse(T other)orElseGet(Supplier<? extends T> other)orElseThrow(Supplier<? extends X> exceptionSupplier)

四、应用

1. 解决上面的错误示例

Optional.ofNullable(person).ifPresent(p -> {
    doSomething();
});

1. 多层的嵌套需要判断null

//  以前的写法
if (person != null) {
    Address address = person.getAddress();
    if (address != null) {
        String province = address.getProvince();
    }
}

//  现在的写法
String province = Optional.ofNullable(person)
                .map(p -> p.getAddress())
                .map(a -> a.getProvince())
                .orElseThrow(() -> new Exception("有空值"));

3. 如果一个对象为空，则赋初值

if (person != null) {
    new Person();
}

Optional.ofNullable(person)
        .orElse(new Person());