JDK8 超详细，肝

/**Lambda语法：*/
	(参数列表) -> { 代码块 }

/**说明：*/
/*Lambda表达式是前提基于：函数式接口来实现的： 只包含一个抽象方法的接口，称为函数式接口 */
	左侧：指定了 Lambda 表达式需要的参数列表
	右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能

@Test
public void test1(){
/** JDK8之前,定义Runnable 接口实现多线程.*/
    //1.  类——>实现Runnable接口,创建实例...填入Thread(Runnable r); .start(); 启动线程
    //2.  匿名内部类方式,获取Runnable 接口实例: 创建一个接口实例
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("匿名内部类实现Runnable 接口实例");
        }
    };
    Thread thread1 = new Thread(runnable);
    thread1.start();

/**JDK8之后,定义Runnable Lambda接口实现多线程.*/
    //Lambda
    //  ->左侧: 指定了 Lambda 表达式需要的参数列表, 这里参数列表是空
    //  ->右侧: 指定了 Lambda 体,是抽象方法的实现逻辑,也即Lambda 表达式要执行的功能;
    Runnable runnable2 = () -> { System.out.println("Lambda实现Runnable 接口实例");};
	Thread thread2 = new Thread(runnable2);
    thread2.start();
    
    //Lambda 优化:
    //  lambda形参列表的参数类型可以省略(类型推断), 如果lambda形参列表只有一个参数,  其一对()也可以省略
    //  lambda体应该使用一对{}包裹, 如果lambda体只有一条执行语句,可能是return语句, 可以省略这一对{}和return关键字.
    Runnable runnable3 = () -> System.out.println("Lambda优化实现Runnable 接口实例");
    Thread thread3 = new Thread(runnable3);
    thread3.start();
    
    System.out.println();
    System.out.println("创建的 Runnable接口实例,正常使用！");
}

匿名内部类实现Runnable 接口实例
Lambda实现Runnable 接口实例

创建的 Runnable接口实例,正常使用！
Lambda优化实现Runnable 接口实例

@Test
public void test2(){
    /** 练习: Comparator 定制排序
         *      Comparator接口,也是一个 "函数式接口": 只包含一个抽象方法的接口，称为函数式接口
         */
        /** JDK8之前,定义Runnable 接口实现多线程.*/
        System.out.println("自然排序/定制排序: 比较基本/引用数据类型,A>B=1 A<B=-1 A==B=0");
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println("定制排序1: "+com1.compare(1, 2));


        /**JDK8之后,定义Runnable Lambda接口实现多线程.*/
        //Lambda
        Comparator<Integer> com2 = (Integer o1, Integer o2) -> { return Integer.compare(o1,o2); };
        System.out.println("定制排序2: "+com2.compare(3, 2));

        //Lambda 优化:
        //类型推断: 省略类型
        //如果lambda体只有一条执行语句,可能是return语句, 可以省略这一对{}和return关键字.
        Comparator<Integer> com3 = (o1,o2) ->  Integer.compare(o1,o2);
        System.out.println("定制排序3: "+com3.compare(4, 3));

        /** 方法引用 */
        Comparator<Integer> com4 = Integer :: compare;      //后面介绍
        System.out.println("定制排序4: "+com4.compare(2, 2));
}

自然排序/定制排序: 比较基本/引用数据类型A>B=1 A<B=-1 A==B=0
定制排序1: -1
定制排序2: 1
定制排序3: 1
定制排序4: 0

/** 注解可以省略,没有影响,注解只是对程序编写的一个提醒标识~
 *  提示你: 这是一个函数式接口！ */
@FunctionalInterface
public interface WsmInterface {
    public abstract void show();
}

import org.junit.Test;
import java.util.function.Consumer;

/** 四大核心函数式接口Function */
public class LambdaTest2 {
/** 正常情况下,函数式接口 实例,当作方法参数传递在方法中完成事情~ */

/** 消费型接口 Consumer<T>     void accept(T t) */
    /** ① 声明一个方法传入Consumer<T> 对象实例:  */
    public void con(Double money, Consumer<Double> con){        //<T> 泛型规范了传入的类型~ Double~
        /** ②方法内,使用Consumer<T>类型参数,调用,它对应的方法,还有自己方法内部的一下操作~  */
        System.out.println("con方法调用~");
        con.accept(money);
        System.out.println("");
    };
/** ③实现 */
    /** J8前 */
    @Test
    public void ConsumerTest(){
        //要传入的参数！
        Double dd = 540.0;
        System.out.println("调用 con(Double,Consumer<Double>) 方法");

        //方式一 创建函数式接口的对象,传入接口的实例: (创建方式,匿名内部类~
        Consumer<Double> con1 = new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("接口实例类,参数传递实现: 身上还有"+aDouble+"块钱!");
            }
        };
        //调用方法
        this.con(dd,con1);

        //方式二: 参数匿名内部类实现
        this.con(dd, new Consumer<Double>() {
            @Override
            public void accept(Double adouble) {
                System.out.println("匿名内部类实现: 身上还有"+adouble+"块钱!");
            }
        });
    }

    /** J8后 */
    @Test
    public void ConsumerTest2(){
        //要传入的参数！
        Double dd = 540.0;

        //JDK8 后Lambda表达式,对 参数匿名内部类 的升级
        /** 调用 con(Double,Consumer<Double>) 方法 */
        this.con(dd, (adouble) -> System.out.println("Lambda表达式实现: 身上还有"+adouble+"块钱!") );
    }
}

# ConsumerTest  运行
调用 con(Double,Consumer<Double>) 方法
con方法调用~
接口实例类,参数传递实现: 身上还有540.0块钱!

con方法调用~
匿名内部类实现: 身上还有540.0块钱!

# ConsumerTest2 运行
con方法调用~
Lambda表达式实现: 身上还有540.0块钱!

也可以理解，方法引用就是更加，简化了Lambda的操作，如果有一个类已经实现了 “函数式接口的方法”`

假设有一个函数式接口A
	函数式接口A
		内部方法 af();	

lambda表达式创建 A 的实例
	A a = () -> { 方法内部的操作... }
	
如果 函数式接口 内部的方法，已经有一个B类bf()对其进行了实现,则可以在方法内部直接通过: B对象.bf(); 一行完成方法的调用
	A a = () -> { 
    	B b = new B();
    	b.bf();
    }
方法引用 简化升级： 
	B b = new B();		创建B类的 对象;
	A a = b::bf;		放法引用的 对象::实例方法名 引用;	 省略方法的参数列表...		

/** 自定义函数式: */
@FunctionalInterface
public interface A {
    //上面实例是一个 无参, 这里定义一个有参的方法();
    public void af(int i);
}

/** 自定义类,实现函数式接口 */
public class B {
    //方法参数列表,与函数式接口相同~
    public void bf(int i){
        System.out.println("对象::实例方法引用 参数列表i="+i);
    }
}

import org.junit.Test;
/** 方法引用测试类 */
public class MethodTest {
/** JDK1.8之前创建A接口实例： */
    @Test
    public void Test(){
        A a = new A() {
            @Override
            public void af(int i) {
                System.out.println("JDK8之前实现接口~ 参数列表i="+i);
            }
        };

        a.af(1);
    }

/** Lambda表达式创建A接口实例： */
    @Test
    public void Test2(){
        //Lambda表示式实现A接口:
        A a =  i ->  System.out.println("Lambda表达式实现接口 参数列表i="+i);

        int i = 2;
        a.af(i);
    }

/** 对象 :: 非静态方法 */
    /** 升级Lambda表达式: 方法引用 */
    @Test
    public void Test3(){
    //① 创建B  类对象;
        B b = new B();
    //② 方法引用:
        A a = b::bf;
    //③ 调用方法~
        a.af(3);
        /** 因为 af(i) 和 bf(i) 方法实现`af实现的操作bf已经完成了` 返回值 参数列表相同~  */
        /** 则满足方法引用,直接使用！ */
    }
}

Test
JDK8之前实现接口~ 参数列表i=1

Test2
Lambda表达式实现接口 参数列表i=2

Test3
对象::实例方法引用 参数列表i=3

//类的静态方法, bsf(int i);
public static void bsf(int i){
    System.out.println("类::static静态方法引用 参数列表i="+i);
}

/** 类 :: 静态方法 */
@Test
public void Test4(){
    System.out.println("Test4");
    //① 方法引用:
    A a = B::bsf;           //直接通过 类::匹配的静态方法()~
    //② 调用方法~
    a.af(4);
}

Test4
类::static静态方法引用 参数列表i=4

/** 类 :: 实例方法  (有难度) */
    /** 以Comparator 方法举例: int comapre(T t1,T t2) 方法 */
    /** String中的int t1.compareTo(t2) */
    @Test
    public void Test5(){
        System.out.println("Test5");
        /** lambda表达式实现 */
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println("lambda比较两个字符串大小~"+com1.compare("abc","abd"));

        Comparator<String> com2 = String :: compareTo;
        System.out.println("方法引用: 类 :: 实例方法 比较两个字符串大小~"+com2.compare("abc","abd"));

        /**
         * 如果:
         *  A 函数式接口的的实现来源于~
         *    af(T1,T2);   T1类.方法(T2); 实现,则属于 类::实例方法;  的方法引用~
         * */
    }

Test5
lambda比较两个字符串大小~-1
方法引用: 类 :: 实例方法 比较两个字符串大小~-1

public String name = "default";

public B(){
    System.out.println("B() 无参构造");
}

public B(String name) {
    System.out.println("B(name,age) 有参构造");
    this.name = name;
}
//省略get/set

/** 构造器引用 */
    //JDK8提供的函数式接口 Supplier中的T get()  返回一个 T 类型对象
    //B 类的空参构造器: B()
    public void Test(){
        /** JDK8之前 */
        Supplier<B> supB = new Supplier<B>() {
            @Override
            public B get() {
              return new B();
            };
        };
        System.out.println("JDK8之前");
        System.out.println("无参默认创建的对象: supB.get().getName();"+supB.get().getName());

        /** Lambda构造器引用 */
        Supplier<B>  supB1 = () -> new B();
        System.out.println("Lambda创建的对象: supB.get().getName();"+supB1.get().getName());

        Supplier<B>  supB2 = B :: new;
        System.out.println("构造器引用创建的对象: supB.get().getName();"+supB2.get().getName());
    }

/** 构造器引用2.0 */
    //Function中的R apply(T t);   Function<T, R>函数式接口,对类型为T的对象应用操作，并返回是R类型的对象
    @Test
    public void Test2(){
        System.out.println("Lambda创建的对象:");
        Function<String ,B> func1 = name -> new B(name);
        System.out.println("Lambda创建的对象: supB.get().getName()= "+func1.apply("wsm1").getName());

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

        System.out.println("构造器引用创建的对象:");
        Function<String ,B> func2 = B :: new;           //参数自动匹配~
        System.out.println("Lambda创建的对象: supB.get().getName()= "+func2.apply("wsm2").getName());
    }

Test
JDK8之前
B() 无参构造
无参默认创建的对象: supB.get().getName();default
B() 无参构造
Lambda创建的对象: supB.get().getName();default
B() 无参构造
构造器引用创建的对象: supB.get().getName();default


Test2
Lambda创建的对象:
B(name,age) 有参构造
Lambda创建的对象: supB.get().getName()= wsm1
*******

构造器引用创建的对象:
B(name,age) 有参构造
Lambda创建的对象: supB.get().getName()= wsm2

@Test
public void Test3(){
    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));
}

/** 自定义一个实体类: */
public class Emp {
    private int id;
    private String name;
    private int age;
    private double salary;
    //无参构造
    public Emp() {    }
    //有参构造
    public Emp(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    //自定义操作数据集, `模拟从 Redis 数据库获取到的数据集合！`
    public static List<Emp> getEmployees(){
        List<Emp> list = new ArrayList<>();

        list.add(new Emp(1001, "马化腾", 34, 6000.38));
        list.add(new Emp(1001, "马化腾", 34, 6000.38));
        list.add(new Emp(1002, "马云", 12, 9876.12));
        list.add(new Emp(1002, "马云", 12, 9876.12));
        list.add(new Emp(1003, "刘强东", 33, 3000.82));
        list.add(new Emp(1004, "雷军", 26, 7657.37));
        list.add(new Emp(1005, "李彦宏", 65, 5555.32));
        list.add(new Emp(1006, "比尔盖茨", 42, 9500.43));
        list.add(new Emp(1007, "任正非", 26, 4333.32));
        list.add(new Emp(1008, "扎克伯格", 35, 2500.32));
        return list;
    }
    //重新toString();
    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
    //省略get/set...
}    

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/** 强大的Stream Api */
public class StreamTest {
/** 创建 Stream */
    @Test
    public void test1(){
        /** 方式一: 通过集合: 集合.stream/parallelStream(); 返回一个stream顺序流/并行流~ */
        List<Emp> emps = Emp.getEmployees();

        //default Stream<E> stream() : 返回一个顺序流
        Stream<Emp> stream = emps.stream();
        //default Stream<E> parallelStream() : 返回一个并行流
        Stream<Emp> parallelStream = emps.parallelStream();
        /** Java8 Collection接口添加了新的方法 stream()、parallelStream()、forEach()和removeIf()... */

        /** 方式二: 通过数组: Arrays.stream(数组); 返回对应的Stream流对象！ */
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream intstream = Arrays.stream(arr);              /** 基本数据类型返回,对应的 xxxstream  Stream流对象~ */
        Emp e1 = new Emp(1001,"Tom",34, 6000.38);
        Emp e2 = new Emp(1002,"Jerry",34, 6000.38);
        Emp[] arr1 = new Emp[]{e1,e2};
        Stream<Emp> empStream = Arrays.stream(arr1);                /** 自定类型数组,返回 Stream<自定义类型> 的Sream类型对象！ */

        /** 方式三: 通过Stream的of() */
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5, 6);      /** 用的少了解即可~ */
    }

    /** 方式四: 创建无限流: 通过Stream类的静态方法 iterate()迭代 generate()生成 */
    public void test2(){
        /** 两种方式: 迭代流 生成流 */
//      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //参数 T , UnaryOperator函数式接口(内部方法: 传入参数T类型,返回T类型结果,正好用于对T的每次迭代的改变~)

        //Stream.iterate(0, t -> t + 2).forEach(System.out::println);
        //  注释原因: 迭代流会无限的迭代下去 +2 +2 +2...
        //  .limit(10) 之取前十个数据
        //  .forEach() 结束操作! 结束时候做的事情~

        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        //参数 Supplier函数式接口对象, 内部方法, 返回一个T类型对象... 可以根据后一个规则无限的来生成一些数据~
        Stream.generate(Math::random).limit(10).forEach(System.out::println);       /** 生成10个小于 1 随机数！ */
    }
}

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/** Stream中间操作
 *      创建完Stream流对象之后,就可以通过 流对象S.xx().xx().xx() 各种的中间操作,完成对 流种数据的计算: 筛选 切片 映射 排序...等操作
 *      中间操作, 是多个方法, 每个方法可以对流中的数据进行筛选计算~
 *      多个方法可以像链条一样 拼接操作~
 * */
public class StreamTest2 {
    /** 筛选与切片 */
    @Test
    public void test1(){
        System.out.println("筛选与切片");
        //获取 emp 集合~
        List<Emp> employees = Emp.getEmployees();
        //JDK8 Collection接口新增,foreach(); 方法: 遍历结果集操作~
        employees.forEach(System.out::println);

        //集合创建Stream 流~
        Stream<Emp> stream = employees.stream();
        System.out.println("\nfilter: 从流中排除某些元素");
        System.out.println("练习: 查询员工表中薪资大于7000的员工信息");
        stream.filter(e->e.getSalary()>7000).forEach(System.out::println);  //filter(Predicate<T>); lambda表达式,每次传入一个流中对象,返回一共 Boolean结果,过滤掉false数据！

        /** 注意一共Stream 使用之后就不可以在次使用,流已经关闭了... 但创建流的,集合依然存在~ */
//        stream.filter(e->e.getSalary()>7000).forEach(System.out::println);  //异常：stream has already been operated upon or closed 需要重新创建一共新的流~

        System.out.println("\ndistinct：筛选，对流中元素进行 hashCode() 和 equals() 去除重复元素");
        employees.stream().distinct().forEach(System.out::println);

        System.out.println("\nlimit(n)——截断流，使其元素不超过给定数量(获取前几个元素~)");
        employees.stream().limit(3).forEach(System.out::println);

        System.out.println("\nskip(n) —— 跳过元素(跳过前几个元素不要~)");
        employees.stream().skip(3).forEach(System.out::println);
    }

    /** **映 射** */
    @Test
    public void test2(){
        System.out.println("映射");
        System.out.println("\nmap(Function f): ——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素");
        List<String> strlist = Arrays.asList("aa", "bb", "cc", "dd");
        strlist.stream().map(str -> str.toUpperCase()).forEach(System.out::println);   //遍历每一个元素,对元素进行二次操作~

        System.out.println("\n过年了,给所有员工工资+1000");
        //获取 emp 集合~
        List<Emp> employees = Emp.getEmployees();
        System.out.println("遍历一遍集合:");
        employees.stream().forEach(System.out::println);
        System.out.println("\n加薪: map( 内部函数式接口方法,要求传入什么参数类型,则返回什么类型~ );　顺便去重 distinct()");
        employees.stream().map(emp -> {emp.setSalary(emp.getSalary()+1000.0); return emp; }).distinct().forEach(System.out::println);

        System.out.println("\nflatMap(f); 是map(f)的高级版~");
        System.out.println("1.Map(f) 实现遍历每一个strlist 的字符");
        Stream<Stream<Character>> streamStream = strlist.stream().map(StreamTest2::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println("2.flatMap(f) 实现遍历每一个strlist 的字符");
        Stream<Character> characterStream = strlist.stream().flatMap(StreamTest2::fromStringToStream);
        characterStream.forEach(System.out::println);
        System.out.println("flatMap 会将,内部的每一个元素进行操作,如果是Stream元素也会重新拆开执行~");

        System.out.println("\n下面的映射,就不详细介绍了: mapToInt(T) mapToLong(T) mapToDouble(T) 传入泛型T 返回对应的类似数据~");
    }

    /** 将字符串中的多个字符构成的集合转换为对应的Stream的实例 */
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    /** flatMap 和 Map :就类似于,数组里面套数组 集合里面套集合 遍历数组和集合的所有元素~*/
    @Test
    public void flat(){
        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);
        /** map 就相当于是 add(集合) */
//        list1.add(list2);
        /** flatMap 就相当于是 addAll(集合) 将集合拆分,对每个单独的元素进行操作~*/
//        list1.addAll(list2);
        System.out.println(list1);
    }


    /** 排序 */
    @Test
    public void test3(){
        System.out.println("sorted()——自然排序");
        System.out.println("注意,如果是自定义类型需要,实现Comparable接口,int 默认实现了Comparable");
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);

        System.out.println("sorted(Comparator com)——定制排序");
        list.stream().sorted((e1,e2)->-e1.compareTo(e2)).forEach(System.out::println);
        /**
         * 排序 A 比较 B
         *  返回 0  A相等B
         *  返回 -1 A小于B
         *  返回 1  A大于B
         * */
    }
}

方法				返回类型               作用                                   示例:

joining 			String 				连接流中每个字符串
String str= list.stream().map(Employee::getName).collect(Collectors.joining());

maxBy 				Optional<T> 		根据比较器选择最大值
Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));

minBy 				Optional<T> 		根据比较器选择最小值
Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));

reducing 			归约产生的类型			从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
int total=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));

collectingAndThen 	转换函数返回的类型 	   包裹另一个收集器，对其结果转换函数
int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));

groupingBy 			Map<K, List<T>> 	  根据某属性值对流分组，属性为K，结果为V
Map<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));

partitioningBy 		Map<Boolean, List<T>> 根据true或false进行分区
Map<Boolean,List<Emp>> vd = list.stream().collect(Collectors.partitioningBy(Employee::getManage));

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/** 终止操作 */
public class StreamTest3 {

    @Test
    public void test(){
        System.out.println("匹配与查找\n");
        List<Emp> employees = Emp.getEmployees();
//        allMatch(Predicate p)——检查是否匹配所有元素。
//          练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

//        anyMatch(Predicate p)——检查是否至少匹配一个元素。
//         练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch(Predicate p)——检查是否没有匹配的元素。
//          练习：是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
//        findFirst——返回第一个元素
        Optional<Emp> employee = employees.stream().findFirst();
        System.out.println(employee);
//        findAny——返回当前流中的任意元素
        Optional<Emp> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);
    }

    @Test
    public void test2(){
        List<Emp> employees = Emp.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
//        max(Comparator c)——返回流中最大值
//        练习：返回最高的工资：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);
//        min(Comparator c)——返回流中最小值
//        练习：返回最低工资的员工
        Optional<Emp> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);
        System.out.println();
//        forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);

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

    //2-归约
    @Test
    public void test3(){
//        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
//        练习1：计算1-10的自然数的和
        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) —— 函数式接口对象——>可以将流中元素反复结合起来，得到一个值,返回 Optional<T>
//        练习2：计算公司所有员工工资的总和
        List<Emp> employees = Emp.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Emp::getSalary);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get());

    }

    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//        练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Emp> employees = Emp.getEmployees();
        List<Emp> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        employeeList.forEach(System.out::println);

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

}

interface A{
	defalut void method1(){
		method2(); //默认实现
	}
	void method2();
}

interface B{
	static String method(){
		return "xxx";
	}
}

import java.nio.charset.StandardCharsets;
import java.util.Base64;
/** Base64 加解密 */
public class Base {
    public static void main(String[] args) {
        final String text = "Java慈祥,yyds!";

        final String encoded = Base64.getEncoder().encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
        System.out.println("加密:"+encoded);

        final String decoded = new String(Base64.getDecoder().decode( encoded ),StandardCharsets.UTF_8 );
        System.out.println("解密:"+decoded);
    }
}

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/** Md5加密 */
public class Md5 {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        // 生成一个MD5加密计算摘要
        MessageDigest md = MessageDigest.getInstance("MD5");

        md.update("Java.慈祥,yyds".getBytes());
        //digest()最后确定返回md5 hash值，返回值为8位字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
        //BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
        //一个byte是八位二进制，也就是2位十六进制字符（2的8次方等于16的2次方）
        System.out.println(new BigInteger(1, md.digest()).toString(16));
    }
}

import java.util.UUID;

String uuid = UUID.randomUUID().toString();