Java 8 新特性

Lambda表达式 
Lambda允许把函数作为一个方法的参数(函数作为参数传递到方法中), 使用Lambda表达式可以使代码变的更加简洁紧凑。
示例：
// Java 8之前：
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Before Java8, too much code for too little to do");
    }
}).start();

//Java 8方式：
new Thread(()-> System.out.println("Before Java8, too much code for too little to do")).start();

lambda 表达式的语法格式如下：
() -> {}()
Lambda语法解析：
括号就是接口方法的括号，接口方法如果有参数，也需要写参数。只有一个参数时, 括号可以省略。
-> : 分割左右部分的, 没啥好讲的。
{} : 要实现的方法体。只有一行代码时, 可以不加括号, 可以不写return。
注意：Lambda表达式要求首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。

Lambda表达式简单例子：
// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

代码示例：
package com.erayt;
public class Java8Tester {
    interface MathOperation {
        int operation(int a, int b);
    }

    interface GreetingService {
        void sayMessage(String message);
    }

    public static void main(String args[]){
        Java8Tester tester = new Java8Tester();
        // 类型声明
        MathOperation addition = (int a,int b) -> a + b;
        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> { return a * b; };
        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));

        // 不用括号
        GreetingService greetService1 = message1 -> System.out.println("Hello " + message1);
        // 用括号
        GreetingService greetService2 = (message2) -> System.out.println("Hello " + message2);
        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
    }

    private int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
    }
}

 

Java 8 Optional类
Optional 是个容器：是Java8为了解决null值判断问题, 使用Optional类可以避免显式的null值判断(null的防御性检查), 避免null导致的NPE(NullPointerException)。

常用方法：
Optional类的两个构造方法都是private型的，因此类外部不能显示的使用new Optional()的方式来创建Optional对象，
但是Optional类提供了三个静态方法empty()、of(T value)、ofNullable(T value)来创建Optinal对象。
static <T> Optional<T> empty()
返回空的 Optional 实例。

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

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

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

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

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

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

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

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

代码示例：
public class Java8Tester {
    public static void main(String args[]){
        Java8Tester tester = new Java8Tester();
        Integer value1 = null;
        Integer value2 = new Integer(10);
        //允许传递为null的参数
        Optional<Integer> a = Optional.ofNullable(value1);
        Optional<Integer> b = Optional.of(value2);
        System.out.println(tester.sum(a,b));
        User user = new User("Anker.Yan",18);
        User user2 = null;
        //由于ifPresent()方法内部做了null值检查，调用前无需担心NPE问题
        Optional.ofNullable(user).ifPresent(u-> System.out.println("The username is "+u.getUserName()));
        //filter()方法接受参数为Predicate对象，用于对Optional对象进行过滤，如果符合Predicate的条件，返回Optional对象本身，否则返回一个空的Optional对象
        Optional.ofNullable(user).filter(u->u.getAge() >= 18).ifPresent(u->System.out.println("符合大约18岁的条件: "+u.getUserName()));
        //map()方法的参数为Function（函数式接口）对象，map()方法将Optional中的包装对象用Function函数进行运算，并包装成新的Optional对象
        //先用ofNullable()方法构造一个Optional<Student>对象，然后用map()计算学生的年龄，返回Optional<Integer>对象（如果student为null, 返回map()方法返回一个空的Optinal对象）.
        Optional.ofNullable(user).map(u -> u.getAge()).ifPresent(age->System.out.println("用户年龄："+ age));
        //orElseThrow()方法适用于包装对象值为空时需要抛出特定异常的场景。
        Optional.ofNullable(user2).orElseThrow(()-> new IllegalAccessError());
        //Optional.orElse - 如果值存在则返回它，否则返回默认值
        Integer age5 = Optional.ofNullable(user).map(u->u.getAge()).orElse(new Integer(20));
        System.out.println("若用户年龄为空，则设置为："+age5);
    }

    public Integer sum(Optional<Integer> a,Optional<Integer> b){
        //Optional.isPrsent - 判断值是否村子
        System.out.println("第一个参数存在："+a.isPresent());
        System.out.println("第二个参数存在："+b.isPresent());
        //Optional.orElse - 如果值存在则返回它，否则返回默认值
        Integer value1 = a.orElse(new Integer(0));
        //Optional.get - 获取值，值需要存在,否则抛出异常：NoSuchElementExceptio
        Integer value2 = b.get();
        return value1 + value2;
    }
}