Lambda表达式

Lambad表达式的使用

1. 举例:(o1, o1) -> Integer.compare(o1, o2);

2. 格式:

   -->: Lambda操作符 / 箭头操作符 -->: 左边: Lambda形参列表(其实就是接口中的抽象方法的行参列表) -->: 右边: lambda体 (其实就是重写的抽象方法的方法体)

3. Lambda表达式的使用：(分为6种情况) 总结： -->左边: lambda形参列表的参数类型都可以忽略(类型推断)，如果lambda形参列表只有一个参数，其一对()也可忽略 -->右边: lambda体应该使用一对{}包裹，如果只有一条语句，则可以省略{}\return

//语法格式一：无参、无返回值
Runnable r2 = () -> {System.out.println("Dreamyouth")};
//语法格式二：Lambda 需要一个参数，但是没有返回值
Cosumer<String> con1 = (String s) -> {System.out.println(s);};
//语法格式三: 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
Consumer<String> con1 = (s) -> {System.out.println(s)};
//语法格式四: 只需要一个参数的时候，参数的小括号可以省略
Consumer<String> con1 = s -> {System.out.println(s)};
//语法格式五: 需要两个或以上的参数，多条执行语句，并且可以有返回值
Comparator<Integer> com2 = (o1, o2) -> {
	System.out.println(o1);
	System.out.println(o2);
	return o1.compareTo(o2);
}
//语法格式六: 当Lambda体只有一条语句时，return与大括号若有，都可以忽略
Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);

4. Lambda表达式的本质: 作为接口的实例

Stream API

1. Stream关注的是对数据的运算，与CPU打交到 集合关注的是数据的存储，与内存打交道
2. -->Stream 自己不会存储元素 -->Stream 不会改表源对象。相反，他们会返回一个持有结果的新Stream -->Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
3. Stream 执行流程
   • Stream的实例化
   • Stream一系列的中间操作(过滤、映射.....)
   • 终止操作
4. 说明：
   • 一个中间操作链，对数据源的数据进行处理
   • 一旦执行终止操作，就执行中间操作链，并产生结果。之后不会再被使用。

创建Stream方式：

通过集合：

	List<Employee> employees = EmployeeData.getEmployees();
	//返回一个顺序流
	Stream<Employee> stream = employees.stream();
	//返回一个并行流
	Stream<Employee> parallelStream = employees.parallelStream();

通过数组：

	int[] arr = new int[]{1,2,3,4,5,6};
	//调用Arrays类的static <T> Stream<T> stream(T[] array); 返回一个流
	IntStream stream1 = Arrays.stream(arr);
	
	Employee e1 = new Employee(1001, "Tom");
	Employee e2 = new Employee(1002, "Jerry");
	Employee[] arr1 = new Employee[]{e1, e2};
	Stream<Employee> stream2 = Arrays.stream(arr1);

通过Stream的Of()

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

生成无限个(仅了解)

Stream的中间操作

筛选与切片

 //1.筛选与切片
        List<Employee> list = EmployeeData.getEmployees();

        //filter(Predicate p)--接收Lambda，从流中排除某些元素
        Stream<Employee> stream = list.stream();
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        //limit(n)--截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);
        //skip(n)--跳过元素，返回一个扔掉前n个元素的流
        list.stream().skip(3).forEach(System.out::println);
        //distinct()--筛选，通过流生成元素的hashCode()和equals()  去除重复的元素
        list.add(new Employee(1010, "刘强东", 40,  8000));
        list.add(new Employee(1010, "刘强东", 40,  8000));
        list.stream().distinct().forEach(System.out::println);

映射

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

        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(name -> name.length() > 3).forEach(System.out::println);
        //flatMap(Function f)--接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Stream<Character>> streamStream = list.stream().map(Java8NewProperties::fromStringToStream);
        
    }
    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c :
                str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

排序

@Test
    public void test4(){
        //sorted--自然排序
        List<Integer> list = Arrays.asList(12, 3, 21, 2, 32, 1, 1 2, 21);
        list.stream().sorted().forEach(System.out::println);
        //sorted(Comparator com)--定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1, e2) -> {
            return Integer.compare(e1.getAge(), e2.getAge());
        }).forEach(System.out::println);
    }

Stream的终止操作

查找与匹配

List<Employee> employees = EmployeeData.getEmployees();
boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);
boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(anyMatch);
boolean noneMatch = employees.stream().noneMatch(e -> e.getName() == "jack");
Optional<Employee> first = employees.stream().findFirst();
Optional<Employee> any = employees.parallelStream().findAny();


employees.stream().filter(e -> e.getSalary() > 5000).count();
//最大工资
Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
Optional<Double> max = salaryStream.max(Double::compare);
//最低工资
Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
//forEach

规约

@Test
    public void testStipulations(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 12, 4);
        list.stream().reduce(0,Integer::sum);
    }

收集

List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getAge() > 10).collect(Collectors.toList());
        employeeList.forEach(System.out::println);