常用Java8語法小結

import java.time.*;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * Java8Test
 *
 *@author yanguoqing
 *@date 2019/2/13
*/
public class Java8Test {

    class Stu {
        Integer id;
        String name;
        Integer sex;
        Boolean flag;

        public Stu() {
        }

        public Stu(Integer id, String name, Integer sex, Boolean flag) {
            this.id = id;
            this.name = name;
            this.sex = sex;
            this.flag = flag;
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getSex() {
            return sex;
        }

        public void setSex(Integer sex) {
            this.sex = sex;
        }

        public Boolean getFlag() {
            return flag;
        }

        public void setFlag(Boolean flag) {
            this.flag = flag;
        }
    }

    // 1. Lambda 表示式  java.util.function.*
    {
        // 提供者
        Supplier<Integer> supplier = () -> 5;
        // 消費者
        Consumer<Integer> consumer = (Integer a) -> System.out.println(a);
        // 消費者（縮寫）
        Consumer<Integer> consumer2 = a -> System.out.println(a);
        // 二元消費者
        BiConsumer<Integer, Integer> biConsumer = (a, b) -> System.out.println(a + b);
        // 函式 接收一個引數，返回一個結果
        Function<Integer, Integer> function = a -> a + 1;
        // 二元函式 接收兩個引數，返回一個結果
        BiFunction<Integer, Integer, Integer> biFunction = (a, b) -> a + b;
        // 二元操作 接收兩個同型別的引數，返回一個同型別結果 繼承BiFunction
        BinaryOperator<Integer> binaryOperator = (a, b) -> a + b;
        // 接收一個引數，返回一個boolean型別的結果
        Predicate<Integer> predicate = a -> a > 5;

        // 如果一個介面只有一個方法 就可以使用Lambda表示式代表這個介面的一個例項 如 Runnable Comparator
        new Thread(() -> {});
    }

    // 2. 函式引用
    {
        // 方法引用
        List<String> list = Arrays.asList("1", "2", "3");
        list.forEach(System.out::println);
        // 構造器引用
        Supplier<Stu> supplier = Stu::new;
    }

    // 3. Stream 流式介面
    {
        Stu stu1 = new Stu(1, "stu1", 1, Boolean.TRUE);
        Stu stu2 = new Stu(3, "stu2", 2, Boolean.FALSE);
        Stu stu3 = new Stu(2, "stu3", 1, Boolean.TRUE);
        Stu stu4 = new Stu(4, "stu4", 2, Boolean.FALSE);
        List<Stu> stus = Arrays.asList(stu1, stu2, stu3, stu4);

        // id正序 等價於stus.sort((o1, o2) -> o1.getId().compareTo(o2.getId()));
        stus.sort(Comparator.comparing(Stu::getId));
        // id倒序
        stus.sort((o1, o2) -> o2.getId().compareTo(o1.getId()));
        // 特殊排序 flag為ture排在前面
        stus.sort((o1, o2) -> o2.getFlag() ? 1 : -1);

        // 提取id 獲得id集合
        stus.stream().map(Stu::getId).collect(Collectors.toList());
        // 過濾 獲得flag為ture的Stu
        stus.stream().filter(Stu::getFlag).collect(Collectors.toList());
        // 過濾 獲得flag為false的Stu
        stus.stream().filter(o -> !o.getFlag()).collect(Collectors.toList());

        // list轉map key為id value為Stu
        // Function.identity() 等效 a -> a 返回物件本身
        Map<Integer, Stu> stuMap = stus.stream().collect(Collectors.toMap(Stu::getId, Function.identity()));

        // 根據性別分組
        Map<Integer, List<Stu>> stuMap2 = stus.stream().collect(Collectors.groupingBy(Stu::getSex));

        // 合併姓名 以逗號分割
        stus.stream().map(Stu::getName).collect(Collectors.joining(","));

        // 取id最大值
        OptionalInt max = stus.stream().mapToInt(Stu::getId).max();
        // Optional 參見https://www.cnblogs.com/KingKirito1024/p/10346690.html
        // max.isPresent() ? max.getAsInt() : 0;
        max.orElse(0);

    }

    // CompletableFuture 多執行緒
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        // 非同步執行 使用的是預設的ForkJoinPool
        list.forEach(o -> CompletableFuture.runAsync(() -> System.out.println(Thread.currentThread().getName() + "------" + o * 2)));
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        // 使用自己定義的執行緒池
        list.forEach(o -> CompletableFuture.runAsync(() -> System.out.println(Thread.currentThread().getName() + "------" + o * 2), executorService));

        List<Integer> result = new ArrayList<>();
        CompletableFuture[] completableFutures = list.stream().map(o -> CompletableFuture.supplyAsync(() -> o + 1)
//                .thenApply(t -> t + 2) // 可以不要
                .whenComplete((r, e) -> {
                    if (e != null) {
                        System.out.println(e.getMessage());
                    }else {
                        result.add(r);
                    }
                })
        ).toArray(CompletableFuture[]::new);
        // join會阻塞主執行緒，等待所以任務執行緒執行完成
        CompletableFuture.allOf(completableFutures).join();
        result.forEach(System.out::println);
    }

    // 時間類
    {
        // Instant
        Instant.now(); // 獲取當前時間戳
        // LocalDate
        LocalDate.now(); // 2019-02-13
        // LocalTime
        LocalTime.now(); // 18:19:15
        // LocalDateTime
        LocalDateTime.now(); // 2019-02-13 18:19:15
    }
}