一、Java 8新特性的介紹：

Java 8（又稱為 jdk 1.8）是Java語言發(fā)布的一個主要版本。
Java 8 是 oracle 公司于2014年3月發(fā)布，可以看成是自 Java 5 以來最具有革命性的版本。Java 8為Java語言、編譯器、類庫、開發(fā)工具與 JVM 帶來了大量新特性。

并行流與串行流：

并行流就是把一個內(nèi)容分成多個數(shù)據(jù)塊，并用不同的線程分別處理每一個數(shù)據(jù)塊的流。相比較串行的流，并行的流可以很大程度上提高程序的執(zhí)行效率。
Java 8中將并行進(jìn)行了優(yōu)化，我們可以很容易的對數(shù)據(jù)進(jìn)行并行操作。
Stream API可以聲明性地通過 parallel() 與 sequential() 在并行流與順序流之間進(jìn)行卻換。

二、Lambda 表達(dá)式：

2.1 為什么要使用 Lambda 表達(dá)式：

@Test
    public void test1(){

        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我愛北京天安門");
            }
        };

        r1.run();

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

        Runnable r2 = () -> System.out.println("我愛北京故宮");

        r2.run();
    }


    @Test
    public void test2(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        int compare1 = com1.compare(12,21);
        System.out.println(compare1);

        System.out.println("***********************");
        //Lambda表達(dá)式的寫法
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

        int compare2 = com2.compare(32,21);
        System.out.println(compare2);


        System.out.println("***********************");
        //方法引用
        Comparator<Integer> com3 = Integer :: compare;

        int compare3 = com3.compare(32,21);
        System.out.println(compare3);
    }

2.2 Lambda 表達(dá)式：語法

類型推斷：

package com.atguigu.java1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

 * Lambda表達(dá)式的使用
 *
 * 1.舉例： (o1,o2) -> Integer.compare(o1,o2);
 * 2.格式：
 *      -> :lambda操作符 或 箭頭操作符
 *      ->左邊：lambda形參列表 （其實就是接口中的抽象方法的形參列表）
 *      ->右邊：lambda體 （其實就是重寫的抽象方法的方法體）
 *
 * 3. Lambda表達(dá)式的使用：（分為6種情況介紹）
 *
 *    總結(jié)：
 *    ->左邊：lambda形參列表的參數(shù)類型可以省略(類型推斷)；如果lambda形參列表只有一個參數(shù)，其一對()也可以省略
 *    ->右邊：lambda體應(yīng)該使用一對{}包裹；如果lambda體只有一條執(zhí)行語句（可能是return語句），省略這一對{}和return關(guān)鍵字
 *
 * 4.Lambda表達(dá)式的本質(zhì)：作為函數(shù)式接口的實例
 *
 * 5. 如果一個接口中，只聲明了一個抽象方法，則此接口就稱為函數(shù)式接口。我們可以在一個接口上使用 @FunctionalInterface 注解，
 *   這樣做可以檢查它是否是一個函數(shù)式接口。
 *
 * 6. 所以以前用匿名實現(xiàn)類表示的現(xiàn)在都可以用Lambda表達(dá)式來寫。
 *
 * @author shkstart
 * @create 2019 上午 11:40

public class LambdaTest1 {
    //語法格式一：無參，無返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我愛北京天安門");
            }
        };

        r1.run();

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

        Runnable r2 = () -> {
            System.out.println("我愛北京故宮");
        };

        r2.run();
    }
    //語法格式二：Lambda 需要一個參數(shù)，但是沒有返回值。
    @Test
    public void test2(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("謊言和誓言的區(qū)別是什么？");

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

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

    }

    //語法格式三：數(shù)據(jù)類型可以省略，因為可由編譯器推斷得出，稱為“類型推斷”
    @Test
    public void test3(){

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

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

        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

    }

    @Test
    public void test4(){

        ArrayList<String> list = new ArrayList<>();//類型推斷

        int[] arr = {1,2,3};//類型推斷

    }

    //語法格式四：Lambda 若只需要一個參數(shù)時，參數(shù)的小括號可以省略
    @Test
    public void test5(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

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

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");


    }

    //語法格式五：Lambda 需要兩個或以上的參數(shù)，多條執(zhí)行語句，并且可以有返回值
    @Test
    public void test6(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        System.out.println(com1.compare(12,21));

        System.out.println("*****************************");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        System.out.println(com2.compare(12,6));


    }

    //語法格式六：當(dāng) Lambda 體只有一條語句時，return 與大括號若有，都可以省略
    @Test
    public void test7(){

        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };

        System.out.println(com1.compare(12,6));

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

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

        System.out.println(com2.compare(12,21));

    }

    @Test
    public void test8(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

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

        Consumer<String> con2 = s -> System.out.println(s);

        con2.accept("一個是聽得人當(dāng)真了，一個是說的人當(dāng)真了");

    }

}

二、函數(shù)式（Functional）接口：

2.1 什么是函數(shù)式（Functional）接口：

2.2 如何理解函數(shù)式接口：

2.3 函數(shù)式接口舉例：

2.4 自定義函數(shù)式接口：

2.5 作為參數(shù)傳遞 Lambda 表達(dá)式：

2.6 Java 內(nèi)置四大核心函數(shù)式接口以及其它接口：

package com.atguigu.java1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * java內(nèi)置的4大核心函數(shù)式接口
 *
 * 消費型接口 Consumer<T>     void accept(T t)
 * 供給型接口 Supplier<T>     T get()
 * 函數(shù)型接口 Function<T,R>   R apply(T t)
 * 斷定型接口 Predicate<T>    boolean test(T t)
 *
 *
 * @author shkstart
 * @create 2019 下午 2:29
 */
public class LambdaTest2 {

    @Test
    public void test1(){

        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble {
                System.out.println("學(xué)習(xí)太累了，去天上人間買了瓶礦泉水，價格為：" + aDouble);
            }
        });

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

        happyTime(400,money -> System.out.println("學(xué)習(xí)太累了，去天上人間喝了口水，價格為：" + money));
    }

    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }


    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津","東京","西京","普京");

        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });

        System.out.println(filterStrs);


        List<String> filterStrs1 = filterString(list,s -> s.contains("京"));
        System.out.println(filterStrs1);
    }

    //根據(jù)給定的規(guī)則，過濾集合中的字符串。此規(guī)則由Predicate的方法決定
    public List<String> filterString(List<String> list, Predicate<String> pre){

        ArrayList<String> filterList = new ArrayList<>();

        for(String s : list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }

        return filterList;

    }

}

三、方法引用與構(gòu)造器引用：

3.1 方法引用的概述：

package com.atguigu.java2;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用的使用
 *
 * 1.使用情境：當(dāng)要傳遞給Lambda體的操作，已經(jīng)有實現(xiàn)的方法了，可以使用方法引用！
 *
 * 2.方法引用，本質(zhì)上就是Lambda表達(dá)式，而Lambda表達(dá)式作為函數(shù)式接口的實例。所以
 *   方法引用，也是函數(shù)式接口的實例。
 *
 * 3. 使用格式：  類(或?qū)ο? :: 方法名
 *
 * 4. 具體分為如下的三種情況：
 *    情況1     對象 :: 非靜態(tài)方法
 *    情況2     類 :: 靜態(tài)方法
 *
 *    情況3     類 :: 非靜態(tài)方法
 *
 * 5. 方法引用使用的要求：要求接口中的抽象方法的形參列表和返回值類型與方法引用的方法的
 *    形參列表和返回值類型相同?。ㄡ槍τ谇闆r1和情況2）
 *
 * Created by shkstart.
 */
public class MethodRefTest {

    // 情況一：對象 :: 實例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        System.out.println("*******************");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("beijing");
    }
    
    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void test2() {
        Employee emp = new Employee(1001,"Tom",23,5600);

        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());

        System.out.println("*******************");
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());

    }

    // 情況二：類 :: 靜態(tài)方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(12,21));

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

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12,3));

    }
    
    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        Function<Double,Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };

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

        Function<Double,Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));

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

        Function<Double,Long> func2 = Math::round;
        System.out.println(func2.apply(12.6));
    }

    // 情況三：類 :: 實例方法  (有難度)
    // Comparator中的int comapre(T t1,T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc","abd"));

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

        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("abd","abm"));
    }

    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc","abc"));

        System.out.println("*******************");
        BiPredicate<String,String> pre2 = String :: equals;
        System.out.println(pre2.test("abc","abd"));
    }
    
    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
        Employee employee = new Employee(1001, "Jerry", 23, 6000);


        Function<Employee,String> func1 = e -> e.getName();
        System.out.println(func1.apply(employee));

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


        Function<Employee,String> func2 = Employee::getName;
        System.out.println(func2.apply(employee));


    }

}

3.2 構(gòu)造器引用的概述：

3.3 數(shù)組引用：

package com.atguigu.java2;

import org.junit.Test;

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一、構(gòu)造器引用
 *      和方法引用類似，函數(shù)式接口的抽象方法的形參列表和構(gòu)造器的形參列表一致。
 *      抽象方法的返回值類型即為構(gòu)造器所屬的類的類型
 *
 * 二、數(shù)組引用
 *     大家可以把數(shù)組看做是一個特殊的類，則寫法與構(gòu)造器引用一致。
 *
 * Created by shkstart
 */
public class ConstructorRefTest {
    //構(gòu)造器引用
    //Supplier中的T get()
    //Employee的空參構(gòu)造器：Employee()
    @Test
    public void test1(){

        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("*******************");

        Supplier<Employee>  sup1 = () -> new Employee();
        System.out.println(sup1.get());

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

        Supplier<Employee>  sup2 = Employee :: new;
        System.out.println(sup2.get());
    }

    //Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

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

        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);

    }

    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));

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

        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002,"Tom"));

    }

    //數(shù)組引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

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

        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

    }
}

四、強大的 Stream API：

4.1 簡單概述下：

4.2 為什么要使用 Stream API：

4.3 什么是 Stream：

4.4 Stream 的操作三個步驟：

4.5 創(chuàng)建 Stream 方式：

4.51 使用集合：

//創(chuàng)建 Stream方式一：通過集合
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

//        default Stream<E> stream() : 返回一個順序流
        Stream<Employee> stream = employees.stream();

//        default Stream<E> parallelStream() : 返回一個并行流
        Stream<Employee> parallelStream = employees.parallelStream();

    }

4.52 通過數(shù)組：

//創(chuàng)建 Stream方式二：通過數(shù)組
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //調(diào)用Arrays類的static <T> Stream<T> stream(T[] array): 返回一個流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001,"Tom");
        Employee e2 = new Employee(1002,"Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }

4.53 通過 Stream 的 of( )：

//創(chuàng)建 Stream方式三：通過Stream的of()
    @Test
    public void test3(){

        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    }

4.54 創(chuàng)建無限流：

//創(chuàng)建 Stream方式四：創(chuàng)建無限流
    @Test
    public void test4(){

//      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍歷前10個偶數(shù)
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);


//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        //生成十個隨機數(shù)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }

4.6 中間操作：

4.61 篩選與切片：

//1-篩選與切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)——接收 Lambda ， 從流中排除某些元素。
        Stream<Employee> stream = list.stream();
        //練習(xí)：查詢員工表中薪資大于7000的員工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        System.out.println();
//        limit(n)——截斷流，使其元素不超過給定數(shù)量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

//        skip(n) —— 跳過元素，返回一個扔掉了前 n 個元素的流。若流中元素不足 n 個，則返回一個空流。與 limit(n) 互補
        list.stream().skip(3).forEach(System.out::println);

        System.out.println();
//        distinct()——篩選，通過流所生成元素的 hashCode() 和 equals() 去除重復(fù)元素

        list.add(new Employee(1010,"劉強東",40,8000));
        list.add(new Employee(1010,"劉強東",41,8000));
        list.add(new Employee(1010,"劉強東",40,8000));
        list.add(new Employee(1010,"劉強東",40,8000));
        list.add(new Employee(1010,"劉強東",40,8000));

//        System.out.println(list);

        list.stream().distinct().forEach(System.out::println);
    }

4.62 映射：

//映射
    @Test
    public void test2(){
//        map(Function f)——接收一個函數(shù)作為參數(shù)，將元素轉(zhuǎn)換成其他形式或提取信息，該函數(shù)會被應(yīng)用到每個元素上，并將其映射成一個新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

//        練習(xí)1：獲取員工姓名長度大于3的員工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println();


        //練習(xí)2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();
//        flatMap(Function f)——接收一個函數(shù)作為參數(shù)，將流中的每個值都換成另一個流，然后把所有流連接成一個流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);

    }

    //將字符串中的多個字符構(gòu)成的集合轉(zhuǎn)換為對應(yīng)的Stream的實例
    public static Stream<Character> fromStringToStream(String str){//aa
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
       return list.stream();

    }

    //與上面的功能類似
    @Test
    public void test3(){
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

//        list1.add(list2);
        list1.addAll(list2);
        System.out.println(list1);

    }

4.63 排序

//3-排序
    @Test
    public void test4(){
//        sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        //拋異常，原因:Employee沒有實現(xiàn)Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);


//        sorted(Comparator com)——定制排序

        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted( (e1,e2) -> {

           int ageValue = Integer.compare(e1.getAge(),e2.getAge());
           if(ageValue != 0){
               return ageValue;
           }else{
               return -Double.compare(e1.getSalary(),e2.getSalary());
           }

        }).forEach(System.out::println);
    }

4.7 終止操作(終端操作)：

• 終端操作會從流的流水線生成結(jié)果。其結(jié)果可以是任何不是流的值，例如：List、Integer、void。
• 流進(jìn)行了終止操作后，不能再次使用。

4.71 匹配與查找：

//1-匹配與查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

//        allMatch(Predicate p)——檢查是否匹配所有元素。
//          練習(xí)：是否所有的員工的年齡都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

//        anyMatch(Predicate p)——檢查是否至少匹配一個元素。
//         練習(xí)：是否存在員工的工資大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch(Predicate p)——檢查是否沒有匹配的元素。
//          練習(xí)：是否存在員工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
//        findFirst——返回第一個元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);
//        findAny——返回當(dāng)前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);

    }

    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的總個數(shù)
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
//        max(Comparator c)——返回流中最大值
//        練習(xí)：返回最高的工資：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);
//        min(Comparator c)——返回流中最小值
//        練習(xí)：返回最低工資的員工
        Optional<Employee> employee = employees.stream().min(
                (e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);
        System.out.println();
//        forEach(Consumer c)——內(nèi)部迭代
        employees.stream().forEach(System.out::println);

        //使用集合的遍歷操作
        employees.forEach(System.out::println);
    }

4.72 歸約：

//2-歸約
    @Test
    public void test3(){
//        reduce(T identity, BinaryOperator)——可以將流中元素反復(fù)結(jié)合起來，得到一個值。返回 T
//        練習(xí)1：計算1-10的自然數(shù)的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);


//        reduce(BinaryOperator) ——可以將流中元素反復(fù)結(jié)合起來，得到一個值。返回 Optional<T>
//        練習(xí)2：計算公司所有員工工資的總和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get());

4.73 收集：

//3-收集
    @Test
    public void test4(){
//        collect(Collector c)——將流轉(zhuǎn)換為其他形式。接收一個 Collector接口的實現(xiàn)，用于給Stream中元素做匯總的方法
//        練習(xí)1：查找工資大于6000的員工，結(jié)果返回為一個List或Set

        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());

        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());

        employeeSet.forEach(System.out::println);
}

五、Optional 類：

5.1 簡單概述：

5.2 所屬方法：

5.3 代碼演示：

package com.atguigu.java4;

import org.junit.Test;

import java.util.Optional;

/**
 * Optional類：為了在程序中避免出現(xiàn)空指針異常而創(chuàng)建的。
 *
 * 常用的方法：ofNullable(T t)
 *            orElse(T t)
 *
 * @author shkstart
 * @create 2019 下午 7:24
 */
public class OptionalTest {

/*
Optional.of(T t) : 創(chuàng)建一個 Optional 實例，t必須非空；
Optional.empty() : 創(chuàng)建一個空的 Optional 實例
Optional.ofNullable(T t)：t可以為null

 */
    @Test
    public void test1(){
        Girl girl = new Girl();
//        girl = null;
        //of(T t):保證t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);

    }

    @Test
    public void test2(){
        Girl girl = new Girl();
//        girl = null;
        //ofNullable(T t)：t可以為null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);
        //orElse(T t1):如果單前的Optional內(nèi)部封裝的t是非空的，則返回內(nèi)部的t.
        //如果內(nèi)部的t是空的，則返回orElse()方法中的參數(shù)t1.
        Girl girl1 = optionalGirl.orElse(new Girl("趙麗穎"));
        System.out.println(girl1);

    }


    public String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }

    @Test
    public void test3(){
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName(boy);
        System.out.println(girlName);

    }
    //優(yōu)化以后的getGirlName():
    public String getGirlName1(Boy boy){
        if(boy != null){
            Girl girl = boy.getGirl();
            if(girl != null){
                return girl.getName();
            }
        }

        return null;

    }

    @Test
    public void test4(){
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName1(boy);
        System.out.println(girlName);

    }

    //使用Optional類的getGirlName():
    public String getGirlName2(Boy boy){

        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //此時的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪麗熱巴")));

        Girl girl = boy1.getGirl();

        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));

        return girl1.getName();
    }

    @Test
    public void test5(){
        Boy boy = null;
        boy = new Boy();
        boy = new Boy(new Girl("蒼老師"));
        String girlName = getGirlName2(boy);
        System.out.println(girlName);

    }



}