Java8新特性速览

一、接口中的默认方法

JDK1.8之前接口中定义的方法都是没有方法体的（抽象方法），都需要实现类去实现：

public interface demo {
    int add(int a, int b);  // interface 中的方法默认是 public abstract 修饰，且不能有方法体
}

JDK1.8之后接口中的方法可以通过加上default或者 static 关键字进行实现，也就是可以带上方法体：

public interface demo {
    
    default int add(int a, int b) { // 通过 default 关键字在 interface 中定义的方法可以带方法体
        return a + b;
    }
    
    static int sub(int a, int b) { // 通过 static 关键字在 interface 中定义的方法也可以带方法体
        return a - b;
    }
    
}

但需要注意的是static修饰的方法是静态的，只能通过接口类进行访问，不能通过对象访问；而default方法是可以通过对象访问的，并且在该实现类中重写，但不强制重写

二、Lambda表达式

2.1 什么是Lambda

Lambda表达式是一个匿名函数，简化我们调用匿名函数的过程。Java中Lambda表达式的作用就是为了简化匿名内部类对象的创建

创建线程时，是否使用Lambda表达式的对比：

// 不用lambda的写法：
public class Main {
    public static void main(String[] args) {
        new Thread(new Runnable() { // 使用匿名内部类对象实现
            @Override
            public void run() {
                // 子线程逻辑代码...
            }
        }).start();
    }
}

// 使用lambda的写法：
public class Main {
    public static void main(String[] args) {
        new Thread(() -> { // 使用lambda实现
            // 子线程逻辑代码...
        }).start(); 
    }
}

显然使用lambda表达式代码更少，并且代码结构更清晰。

2.2 Lambda表达式规范

使用Lambda时必须是函数式接口（只存在一个抽象方法的接口，使用@FunctionalInterface注解修饰）

JDK中自带的函数式接口有：

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

需要注意的是，函数式接口的要求仅仅是只存在一个抽象方法，意味着用户可以额外定义多个静态方法或默认方法。此外，Object类中的方法也可以在函数式接口中重写，如equals()、toString()等方法

2.3 Lambda表达式基础语法

Lambda表达式写法：() -> {}

• () 表示参数列表，参数不需要写类型，但需要定义名称

• -> 用来分隔 () 和 {}

• {} 表示方法体

注意：当方法体中只有一行代码时，{}可省略。其余情况 {} 不可省略

2.4 Lambda表达式用法实例

// 实例一：集合遍历
strings.forEach( s -> { System.out.println(s); });

// 实例二：集合排序
people.sort((a, b) ->  a.getAge() - b.getAge());

// 实例三：线程调用
new Thread(() -> System.out.println(Thread.currentThread.getName())).start();

三、Stream流

3.1 什么是Stream流

Stream流以非常简便的方式（类似于SQL的方式）遍历集合实现过滤、排序等操作

3.2 Java8内置四种函数接口

1. 消费型接口：需要参数、不返回结果，只进不出，只负责消费

   // 一般的消费型接口
   interface Consumer<T> {
       void accept(T t);
   }
   
   // 需要两个参数的消费型接口
   interface BiConsumer<T> {
       void accept(T t, U u);
   }
   

2. 供给型接口：不需要参数、只有返回值，只出不进，只负责生产

   interface Supplier<T> {
       T get();
   }
   

3. 函数型接口：需要参数也有返回值，有进有出，只负责加工数据

   // 一般的函数型接口
   interface Function<T, R> {
       R apply(T t);
   }
   
   // 返回值类型与参数类型一致
   interface UnaryOperator<T> {
       T apply(T t);
   }
   
   // 需要两个参数的函数型接口
   interface BiFunction<T, U, R> {
       R apply(T t, U u);
   }
   
   //  需要两个相同类型的参数，且返回值类型与参数类型一致
   interface BinaryOperator<T> {
       T apply(T t1, T t2);
   }
   

4. 断言型接口：返回值为Boolean值的接口

   interface Predicate<T> {
       boolean test(T t);
   }
   

3.3 Stream流的基础用法实例

• Stream流的创建
  Stream流分串行流和并行流，串行流是单线程的，并行流是多线程的。一般情况下并行流效率高于串行流

  Collection.stream();             // 创建串行流
  Collection.parallelStream(); // 创建并行流 
  

• Stream集合转换

  // 将List转换为Set
  Set<User> userSet = users.stream().collect(Collectors.toSet());
  // 将List转换为Map
  Map<String, User> userMap = users.stream().collect(Collectors.toMap(u -> u.getName(), u -> u));
  

• Stream计算求和

  Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6,7);
  integerStream.reduce((a1, a2) -> a1 + a2);
  

• Stream求最值

  // stream求最大值
  Optional<User> max = stream.max((u1, u2) -> u1.getAge() - u2.getAge());
  System.out.println(max.get());
  // stream求最小值
  Optional<User> min = stream.min((u1, u2) -> u1.getAge() - u2.getAge());
  System.out.println(min.get());
  

• StreamMatch匹配

  1. anyMatch表示当前Stream中有一个元素满足条件就为真，返回true，否则false
  2. allMatch表示当前Stream中所有元素都满足条件才为真，返回true，否则false
  3. noneMatch与allMatch相反，表示当前Stream中所有元素都不满足条件才为真，否则false

  boolean result = stream.anyMatch(user -> user.getAge() > 20);
  

• Stream过滤

  // 列出集合中所有年龄大于30的用户
  users.stream()
      .filter(user -> user.getAge() > 30)
      .forEach(user -> System.out.println(user));
  

• Stream分页

  // 类似mysql的limit(0, 5)，从0开始取5条数据
  users.stream()
      .skip(0)
      .limit(5)
      .forEach(user -> System.out.println(user));
  

• Stream排序

  user.stream()
      .sorted((u1, u2) -> u1.getAge() - u2.getAge())
      .forEach(user -> System.out.println(user));
  

3.4 方法引入

方法引入是与Lambda表达式配合使用的一种简化代码的操作，主要包括：

1. 静态方法引入：类名 :: 静态方法名
2. 对象方法引入：类名 :: 对象方法名
3. 实例方法引入：实例名 :: 实例方法名
4. 构造方法引入：类名 :: new

四、Optional

Optional类是一个可以为null的容器对象，如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional是个容器，可以保存任意类型的值，包括null。但Optional提供了很多有用的API让我们可以不用手动判空。

写法对比：

public static String getOrderName() {
    Order order = new Order("1001", "订单1");
    // 不使用Optional
    if (order != null) {
        String orderName = order.getOrderName();
        if (orderName != null) {
            return orderName.toLowerCase();
        }
    }
    
    // 使用Optional
    return Optional.ofNullable(order)
        .map((order -> order.getOrderName()))
        .map((orderName) -> orderName.toLowerCase())
        .orElse("默认订单名");
}

显然Optional的引入很好地解决了空指针异常的问题。

Optional核心API

API介绍：

• Optional.ofNullable(T t)：可以传递一个空值对象
• Optional.of(T t)：不允许传递空值对象
• Optional.isPresent()：判空，返回 true 不为空，返回 false 为空
• Optional.ifPresent(Consumer)：如果不为空则直接执行lambda中的语句，隐式判空
• Optional.orElse()：设定默认值，如果为空则取默认值

Integer num1 = 1;
Optional<Integer> num = Optional.ofNullable(num1);
System.out.println(num.isPresent());