Java8新特性Lambda、Stream、Optional

Lambda

Lambda 是一個匿名函數，我們可以把Lambda表達式理解爲一段可以傳遞的代碼（將代碼像數據一樣進行傳遞），可以寫出更簡潔、更靈活的代碼。

Lambda 表達式語法

Lambda 表達式在Java 語言中引入了一個新的語法元素和操作符。這個操作符爲 -> ， 該操作符被稱爲 Lambda 操作符或剪頭操作符。它將 Lambda 分爲兩個部分：
左側：指定了 Lambda 表達式需要的所有參數
右側：指定了 Lambda 體，即 Lambda 表達式要執行的功能。

• 語法格式一：無參，無返回值，Lambda 體只需一條語句

Runnable runnable = () -> System.out.println("aa");

• 語法格式二：Lambda 需要一個參數

Consumer<String> consumer = x -> System.out.println(x);

• 語法格式三：Lambda 需要兩個參數，並且有返回值

        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("實現函數接口方法！");
            return x + y;
        };

Lambda 表達式語法

上述 Lambda 表達式中的參數類型都是由編譯器推斷得出的。Lambda 表達式中無需指定類型，程序依然可以編譯，這是因爲 javac 根據程序的上下文，在後臺推斷出了參數的類型。Lambda 表達式的類型依賴於上下文環境，是由編譯器推斷出來的。這就是所謂的“類型推斷”

方法引用

當要傳遞給Lambda體的操作，已經有實現的方法了，可以使用方法引用！（實現抽象方法的參數列表，必須與方法引用方法的參數列表保持一致！）方法引用：使用操作符 :: 將方法名和對象或類的名字分隔開來。如下三種主要使用情況：

• 對象::實例方法
• 類::靜態方法
• 類::實例方法

Stream流

是數據渠道，用於操作數據源（集合、數組等）所生成的元素序列。集合講的是數據，流講的是計算！

注意：

• Stream 自己不會存儲元素。
• Stream 不會改變源對象。相反，他們會返回一個持有結果的新Stream。
• Stream 操作是延遲執行的。這意味着他們會等到需要結果的時候才執行。

創建Stream流

public static void main(String[] args) {
        // 1.可以通過 Collection 系列集合提供 stream()串行流 或 parallelStream()並行流
        List<String> list = new ArrayList<>();
        Stream<String> stringStream = list.stream();

        // 2.通過 Arrays 中的表態方法 stream() 獲取數組流
        Integer[] integers = new Integer[10];
        Stream<Integer> integerStream = Arrays.stream(integers);

        // 3.通過 Stream 類中的靜態方法 of()
        Stream<String> strStream = Stream.of("a", "b", "c");

        // 4.創建無限流
        // 迭代
        Stream<Integer> stream = Stream.iterate(0, (x) -> x + 2);
        stream.limit(10).forEach(System.out::println);

        //生成
        Stream.generate(Math::random)
                .limit(5).forEach(System.out::println);
    }

中間操作

	String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
	//中間操作：不會執行任何操作
    Stream<String> stringStream = Arrays.stream(strings)
                .filter((e) -> {
                    System.out.println("中間操作");
                    return "c".equals(e);
                });

	//終止操作：一次性執行全部內容，即"惰性求值"
    stringStream.forEach(System.out::println);

	String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
	//中間操作：不會執行任何操作
    Stream<String> stringStream = Arrays.stream(strings)
                .filter((e) -> {
                    System.out.println("中間操作");
                    return !"c".equals(e);
                }).limit(3).distinct();

	//終止操作：一次性執行全部內容，即"惰性求值"
    stringStream.forEach(System.out::println);

	List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f");
    list.stream().map(String::toUpperCase)
                 .forEach(System.out::println);

	public static void main(String[] args) {

        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");

        list.stream().map(String::toUpperCase)
                .forEach(System.out::println);

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

		//flatMap裏面返回又是一個Stream流
        list.stream().flatMap(Test::character)
                .forEach(System.out::println);
    }

    private static Stream<Character> character(String string) {
        List<Character> list = new ArrayList<>();
        for (char c : string.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

	List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);

    list.stream().sorted().forEach(System.out::println);
    System.out.println("-----------");

    list.stream().sorted((e1, e2) -> {
           return -e1.compareTo(e2);
    }).forEach(System.out::println);

終止操作

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        boolean b = list.stream().allMatch((e) -> {
            return e == 5;
        });
        System.out.println(b);

        boolean b1 = list.stream().anyMatch((e) -> {
            return e == 5;
        });
        System.out.println(b1);

        boolean b2 = list.stream().noneMatch((e) -> {
            return e == 5;
        });
        System.out.println(b2);

        Optional<Integer> first = list.stream().findFirst();
        System.out.println(first.get());

        // 在串行的流中，findAny和findFirst返回的，都是第一個對象；
        // 而在並行的流中，findAny返回的是最快處理完的那個線程的數據
        Optional<Integer> any = list.stream().findAny();
        System.out.println(any.get());

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        long count = list.stream().count();
        System.out.println(count);

        Optional<Integer> max = list.stream().max(Integer::compareTo);
        System.out.println(max.get());

        Optional<Integer> min = list.stream().min(Integer::compareTo);
        System.out.println(min.get());

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        Long collect = list.stream().collect(Collectors.counting());
        System.out.println(collect);

        Double collect1 = list.stream().collect(Collectors.averagingInt(Integer::intValue));
        System.out.println(collect1);

        Integer collect2 = list.stream().collect(Collectors.summingInt(Integer::intValue));
        System.out.println(collect2);

Optional 類

Optional 類(java.util.Optional) 是一個容器類，代表一個值存在或不在，
原來用 null 表示一個值不存在，現在 Optional 可以更好的表達這個概念。並且可以避免空指針異常。

常用方法：

• Optional.of(T t) : 創建一個 Optional 實例
• Optional.empty() : 創建一個空的 Optional 實例
• Optional.ofNullable(T t):若 t 不爲 null,創建 Optional 實例,否則創建空實例
• isPresent() : 判斷是否包含值
• orElse(T t) : 如果調用對象包含值，返回該值，否則返回t
• orElseGet(Supplier s) :如果調用對象包含值，返回該值，否則返回 s 獲取的值
• map(Function f): 如果有值對其處理，並返回處理後的Optional，否則返回 Optional.empty()
• flatMap(Function mapper):與 map 類似，要求返回值必須是Optional