18，jdk新特性

jdk 8.0 

Lambda

package java4;

import org.junit.Test;

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

/*
Lambda 表达式的使用
1.举例：(o1,o2) -> Integer.compare(o1,o2);
2.格式：
      -> ： lambda 操作符 或 箭头操作符
           箭头左边：lambda的形参列表（接口中的抽象方法的形参列表）
           箭头右边：lambda体 （重写抽象方法的方法体）

3.lambda的表达式的使用：（六种情况）

4.lambda的本质：作为函数式接口的实例

5.如果一个接口中，只申明了一个抽象方法，则此接口就称为函数式接口

java内置的4大核心函数式接口
消费型接口 ：Consumer
供给型接口：Supplier
函数型接口：Function
断定型接口：Predicate

 */
public class LambdaTest1 {
    @Test
     public void test(){
        //语法格式一：无参、无返回值
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("上海");
            }
        };
        r1.run();
        System.out.println("lambda的写法");
        Runnable r2 = () -> System.out.println("北京");
        r2.run();
    }
    @Test
    public void test2(){
        //语法格式二：lambda 需要一个参数，但是没有返回值
        Consumer<String> con = new Consumer<String>(){
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("上海");
        //lambda表达式的写法
        Consumer<String> con1 = (String s) -> {System.out.println(s);};
        con1.accept("魔都");
    }
    @Test
    public void test3(){
        //语法格式三：数据类型可以胜率，因为可有编译器推断得出，称为类型推断
        Consumer<String> con1 = (s) -> {System.out.println(s);};
        con1.accept("魔都");
    }
    @Test
    public void test4(){
        //语法格式四：lambda 若只需要一个参数时，参数小括号可以省略
        Consumer<String> con1 = s -> {System.out.println(s);};
        con1.accept("魔都");
    }
    @Test
    public void test5(){
        //语法格五：lambda 若需要两个及以上参数时，多条执行语句，并可以有返回值
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12,21));
       //lambda的方式
        Comparator<Integer> com2 = (o1,o2) ->
            {
                System.out.println(o1);
                return o1.compareTo(o2);
            };
        System.out.println(com2.compare(21,11));
    }
    @Test
    public void test6(){
        //语法格式六：lambda 只需要一条语句时， return 和 {} 可以省略
        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(21,11));
    }
    
}

 Stream

package java4;

public class Employee {
    public int id;
    public String name;
    public int age;
    public double salary;

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}
package java4;

import java.util.ArrayList;
import java.util.List;

public class EmployeeData {
    public static List<Employee> getEmployees(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(1001,"马虎疼",33,6000.5));
        list.add(new Employee(1002,"马云",31,9876.9));
        list.add(new Employee(1003,"刘松",23,8797.12));
        list.add(new Employee(1004,"雷军",34,555.21));
        list.add(new Employee(1005,"黎元洪",35,2231));
        return list;
    }
}

package java4;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/*
1.Stream 关注的时对数据的运算，与cpu打交道
  集合关注的时数据的存储，与内存打交道

2. ①Stream 不会自己存储元素
   ②Stream 不会改变源对象。而是返回一个只有结果的新Stream
   ③Stream 操作时延迟执行的，这意味着，等需要结果的时候才会执行

3.Stream 执行流程
① Stream 的实例化
② 一系列的中间操作(过滤、映射……)
③ 中间操作

4.说明：
中间操作链，对数据源的数据进行处理
一旦执行终止操作，就会执行中间操作链，并产生结果，之后不会再被使用
 */
public class StreamAPITest {
    //创建 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> employeeStream = employees.parallelStream();
    }
    //方式二：通过数组
    @Test
    public void test2(){
        //调用Arrays静态方法： static<T> Stream<T> stream(T array):返回一个流
        int[] arr = new int[]{1,2,3,4,5};
        IntStream stream = Arrays.stream(arr);
    }
    //方式三： 通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
    }
}

 中间操作

package java4;

import org.junit.Test;

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

/*
Stream 中间操作
 */
public class StreamAPI1 {
    //1.筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
        //filter(Predicate p)--接受Lambda，从流中排除某些数据
        Stream<Employee> stream = list.stream();
        //查询员工表中 员工工资大于7000的员工
        stream.filter(e -> e.getSalary()>7000).forEach(System.out::println);
        //Employee{id=1002, name='马云', age=31, salary=9876.9}
        //Employee{id=1003, name='刘松', age=23, salary=8797.12}

        System.out.println();
        //limit(n) --截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);
        //Employee{id=1001, name='马虎疼', age=33, salary=6000.5}
        //Employee{id=1002, name='马云', age=31, salary=9876.9}
        //Employee{id=1003, name='刘松', age=23, salary=8797.12}

        //skip(n) -- 跳过元素，返回一个扔掉了前n个元素的流，若流中不足n个元素，则返回空
        list.stream().skip(4).forEach(System.out::println);
        //Employee{id=1005, name='黎元洪', age=35, salary=2231.0}

        //distinct() --筛选，通过流所生成元素的hashCode() 和equals() 过滤重复元素
        list.add(new Employee(1005,"黎元洪",35,2231));
        System.out.println(list);
        System.out.println();
        list.stream().distinct().forEach(System.out::println);
        //Employee{id=1001, name='马虎疼', age=33, salary=6000.5}
        //Employee{id=1002, name='马云', age=31, salary=9876.9}
        //Employee{id=1003, name='刘松', age=23, salary=8797.12}
        //Employee{id=1004, name='雷军', age=34, salary=555.21}
        //Employee{id=1005, name='黎元洪', age=35, salary=2231.0}
    }
    //二、映射

    @Test
    public void test2(){
        //        map(Function f) --接收一个函数作为参数，将元素转换成其他形式，或提取信息，该函数就会被应用到每个元素上，并将其映射成一个新的元素
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out ::println);//AA BB CC DD

        List<Employee> list1 = EmployeeData.getEmployees();
        list1.add(new Employee(1006,"黎元洪撒",41,10000));
        //获取员工姓名大于3的员工姓名
        Stream<String> nameStream = list1.stream().map(e -> e.getName());
        nameStream.filter(name -> name.length()>3).forEach(System.out::println);//黎元洪撒

        //flatMap(Function f) --接收一个函数作为参数,将流中的每个值都换成另一个流，然后把所有的流连成一个流
    }

    //三、排序
    @Test
    public void test3(){
        //sorted() -- 自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 13, 87, 0, -98, 9);
        list.stream().sorted().forEach(System.out::print);//-98 0 9 12 13 34 43 65 87
        //sorted(Comparator com) ---定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2) ->{
                return Integer.compare(e1.getAge(),e2.getAge());
        }).forEach(System.out::print);
    }
}

终止操作

package java4;

import org.junit.Test;

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

/*
Stream 的终止操作

 */
public class StreamTest2 {
    //1.匹配与查找
    @Test
    public void test(){
        List<Employee> employees = EmployeeData.getEmployees();
        //allMath(Predicate p) -- 检查是否匹配所有元素
        //是否所有员工的年龄都大于18
        boolean b = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(b);//true
        //anyMath(predicate p) --检查是否至少匹配一个元素
        //noneMatch(predicate p) -- 检查是否没有匹配元素

        //findFirst --
        Optional<Employee> first = employees.stream().findFirst();
        System.out.println(first);//Optional[Employee{id=1001, name='马虎疼', age=33, salary=6000.5}]
        //findAny -- 返回当前流中的任意元素
        //count -- 返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);//3

        //max(Comparator c) -- 返回流中最大值
        //返回最高工资
        Stream<Double> money = employees.stream().map(e -> e.getSalary());
        Optional<Double> max = money.max(Double::compareTo);
        System.out.println(max);//Optional[9876.9]
        //min(Comparator c) -- 返回流中最小值

        //foreach(Consumer c) --内部迭代器
        employees.stream().forEach(System.out ::print);
    }
    //2.归约
    @Test
    public void test1(){
        //reduce(T identity,BinaryOperator) :将流中元素反复结合起来，得到一个值.T identity:初始值
        //练习1-10的自然数和
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = integers.stream().reduce(0, Integer::sum);
        System.out.println(reduce);//55
        //reduce(BinaryOperator)

    }
    //3.收集
    @Test
    public void test2(){
        //collect(collector c) --将流转换为其他形式。接受一个Collector接口的实现，用于给Stream中元素做汇总的方法
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> collect = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        collect.forEach(System.out ::println);
        //Employee{id=1001, name='马虎疼', age=33, salary=6000.5}
        //Employee{id=1002, name='马云', age=31, salary=9876.9}
        //Employee{id=1003, name='刘松', age=23, salary=8797.12}
    }

}