Java-8-Optional类

java8新特性之Optional类

空指针异常是一个运行时异常，对于这一类异常，如果没有明确的处理策略，那么最佳实践在于让程序早点挂掉，但是很多场景下，不是开发人员没有具体的处理策略，而是根本没有意识到空指针异常的存在。当异常真的发生的时候，处理策略也很简单，在存在异常的地方添加一个if语句判定即可，但是这样的应对策略会让我们的程序出现越来越多的null判定，我们知道一个良好的程序设计，应该让代码中尽量少出现null关键字，而java8所提供的Optional类则在减少NullPointException的同时，也提升了代码的美观度。但首先我们需要明确的是，它并 不是对null关键字的一种替代，而是对于null判定提供了一种更加优雅的实现，从而避免NullPointException

在Java程序开发中使用 null 会带来理论和实际操作上的种种问题

• 它是错误之源。NullPointerException 是目前Java程序开发中最典型的异常。

• 它会使你的代码膨胀。它让你的代码充斥着深度嵌套的 null 检查，代码的可读性糟糕透顶。

• 它自身是毫无意义的。null 自身没有任何的语义，尤其是，它代表的是在静态类型语言中以一种错误的方式对缺失变量值的建模。

• 它破坏了Java的哲学。Java一直试图避免让程序员意识到指针的存在，唯一的例外是： null 指针

• 它在Java的类型系统上开了个口子。null 并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。这会导致问题，原因是当这个变量被传递到系统中的另一个部分后，你将无法获知这个 null 变量最初的
  赋值到底是什么类型。

类方法

static <T> Optional<T> empty()
返回空的 Optional 实例。

boolean equals(Object obj)
判断其他对象是否等于 Optional。

Optional<T> filter(Predicate<? super <T> predicate)
如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。

<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional

T get()
如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException

int hashCode()
返回存在值的哈希码，如果值不存在 返回 0。

void ifPresent(Consumer<? super T> consumer)
如果值存在则使用该值调用 consumer , 否则不做任何事情。

boolean isPresent()
如果值存在则方法会返回true，否则返回 false。

<U>Optional<U> map(Function<? super T,? extends U> mapper)
如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。

static <T> Optional<T> of(T value)
返回一个指定非null值的Optional。

static <T> Optional<T> ofNullable(T value)
如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。

T orElse(T other)
如果存在该值，返回值， 否则返回 other。

T orElseGet(Supplier<? extends T> other)
如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。

<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

String toString()
返回一个Optional的非空字符串，用来调试

使用

创建Optional类

public class M1 {

    public static void main(String[] args) {

        // Optional.ofNullable - 允许传递为 null 参数
        Optional<Integer> op1 = Optional.ofNullable(null);

//        System.out.println(op1.get());
        /*
        Exception in thread "main" java.util.NoSuchElementException: No value present
         */

        Optional<String> op2 = Optional.of("hello");

        // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
//        Optional<String> op3 = Optional.of(null);

        System.out.println(op2.get());

        // 返回一个空的Optional

        Optional<Integer> op4 = Optional.empty();

        System.out.println(op4.get());
        /*
        Exception in thread "main" java.util.NoSuchElementException: No value present
         */
        
    }
}

获取值

T get() T orElse(T other) T orElseGet(Supplier<? extends T> other)

public class M2 {

    public static void main(String[] args) {


        Optional<List<Employee>> op1 = Optional.of(Employee.supply_Ems());

        op1.get()
                .stream()
                .limit(5)
                .forEach(System.out::println);

        /*
        Employee{name='0号员工', age=28, partment='管理部', salary=5892}
        Employee{name='1号员工', age=43, partment='管理部', salary=2216}
        Employee{name='2号员工', age=24, partment='设计部', salary=7463}
        Employee{name='3号员工', age=32, partment='技术部', salary=3475}
        Employee{name='4号员工', age=48, partment='管理部', salary=5221}
         */

        System.out.println("--------------------------------------");
        Optional<Integer> o1 = Optional.of(100);
        Optional<Integer> o2 = Optional.of(100);
        Optional<Integer> o3 = Optional.ofNullable(null);

        System.out.println("");
        System.out.println(addFunction(o1,o2));

        System.out.println();
        System.out.println(addFunction(o1,o3));

        System.out.println("--------------------------------------");


        Optional<String> p1 = Optional.of("hello");
        Optional<String> p2 = Optional.of("world");
        Optional<String> p3 = Optional.ofNullable(null);

        System.out.println(function(p1,p2));

        System.out.println("");

        System.out.println(function(p1,p3));

    }


    public static Integer addFunction(Optional<Integer> x,Optional<Integer> y){

        // Optional.isPresent - 判断值是否存在

        System.out.println("第一个参数是否存在  " + x.isPresent()  );

        System.out.println("第二个参数是否存在  " + y.isPresent()  );

        // Optional.orElse - 如果值存在，返回它，否则返回默认值

        Integer i1 = x.orElse(0);

        Integer i2 = y.orElse(0);

        return i1+i2;
    }

    public static String function(Optional<String> o1, Optional<String> o2){
        
        return  o1.orElseGet(()->"o1 空参数")+"-----"+o2.orElseGet(()->"o2 空参数");

    }
}

判断isPresent

public class M3 {

    public static void main(String[] args) {

        // 创建Optional
        String mayBeNull = null;
        Optional<String> opt1 = Optional.of(" Hello, rensanning! ");
        Optional<String> opt2 = Optional.ofNullable(mayBeNull);
        Optional<String> opt3 = Optional.empty();

        // isPresent
        boolean b1 = opt1.isPresent();
        boolean b2 = opt2.isPresent();
        boolean b3 = opt3.isPresent();
        System.out.println(b1 + "\t" + b2 + "\t" + b3); // true false   false


    }
}

ifPresent

public class M4 {

    public static void main(String[] args) {

        Optional<String> op1 = Optional.of("helio");

        // 如果值存在  转换成大写字母
        op1.ifPresent(s -> System.out.println(s.toUpperCase()));

        System.out.println("---------------------------");

        List<Employee> employees = Employee.supply_Ems();

        Optional<List<Employee>> op2 = Optional.of(employees);

        op2.ifPresent(employees1 ->
        {
            employees1.stream().limit(3).forEach(System.out::println);
        });
        
        /*
        Employee{name='0号员工', age=24, partment='技术部', salary=6731}
        Employee{name='1号员工', age=29, partment='市场部', salary=4524}
        Employee{name='2号员工', age=29, partment='管理部', salary=3430}
         */
        
    }
}

其余操作

public class M5 {

    public static void main(String[] args) {

        List<Employee> employees = Employee.supply_Ems();

        Random random = new Random();

        Optional<Employee> op1 = Optional.of(employees.get(random.nextInt(employees.size())));


        // 如果这个员工工资高于 5000 则输出
        op1.filter(
                employee -> employee.getSalary() > 5000
        ).ifPresent(System.out::print);
        /*
        Employee{name='5号员工', age=29, partment='技术部', salary=8441}
         */


        System.out.println("--------------------------");

        Optional<Integer> op3 = Optional.of(100);

        Optional<String> stringOptional = op3.map(integer -> integer+100 + "");

        System.out.println(stringOptional.get());

        System.out.println("--------------------------");

        Optional<String> lastName = Optional.of("last");
        Optional<String> firstName = Optional.of("first");
        Optional<String> fullName = lastName.flatMap(
                ln -> firstName.map(f->String.join("  ",ln,f))
        );

        System.out.println(fullName.get());


    }
}