lambda语法，java8Stream流，maven

lambda语法

Arraylist排序

ArrayList<Integer> a = new ArrayList();
        a.add(1);
        a.add(2);
        a.add(3);

        a.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//对集合a中数据进行升序排序
            }
        });

但是这样的书写还是有一些复杂，于是就有了一种更简单的写法。

ArrayList<Integer> a = new ArrayList();
        a.add(4);
        a.add(2);
        a.add(3);

        a.sort((o1,o2)->{
            return o1-o2;//使用了lambda表达式，与上段代码一样
        });
        System.out.println(a);

什么是lambda表达式

Lambda表达式是一种匿名函数，通常用于简化代码、实现小型函数而不需要定义完整的函数。

lambda也是一种语法糖，语法糖（Syntactic Sugar）指的是一种语言设计特性，允许程序员以更简洁、易读的方式编写代码。其实质上，它不增加语言的功能，只是提供了一种更方便的语法，使得程序员的编写和理解更加轻松。

使用lamdba表达式要求

一个抽象类或者接口里面只能有一个方法

@FunctionalInterface添加了这个注解的抽象类只能有一个抽象方法

匿名函数，把函数当作参数一样传递

lambda函数怎么使用，使用arraylist排序来举例

在这个Comparator接口里面只有一个compare方法，里面传入了两个参数，要使用lambda的要求就是一个抽象类或者接口里面只能有一个方法，因为arraylist排序方法里面要传入一个Comparator接口，new 一个对象可以直接重写，但是使用lambda表达式就十分简单，只需（o1,o2）->{},其中o1，o2是传进的参数，{}里面可以直接重写方法，和上面的案例一样。

java8Stream流

我们之前所学的IO流是在文件上面进行输入输出，我们现在所说的这个流是在数组和集合的基础上进行操作的。

处理数据集合（数组，集合）

对数组，集合进行各种操作（过滤，排序.....）

Stream 处理数据大体过程

数组/集合 --> 流 --各种操作（排序，过滤）--> 结果（数组，集合类）

如何获取数组和集合的流

ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(1);
        a1.add(5);
        a1.add(3);
        a1.add(4);
        Stream<Integer> stream = a1.stream();//集合获取流的方式

 Integer[] a2 = new Integer[]{1,2,3,4,5};
        Stream<Integer> stream1 = Arrays.stream(a2);//数组获得流的方式

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);//获得流

流的操作

分为中间操作（流的各种处理）和终端操作（把流转化为最终结果）

中间操作：filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(1);
        a1.add(5);
        a1.add(3);
        a1.add(4);
        a1.add(3);
        a1.add(4);
        a1.add(2);
        Stream<Integer> stream = a1.stream();//集合获取流的方式
        a1.stream().filter((e)->{
            return e>1;//过滤集合中大于1的
        }).sorted()//升序排序
                .distinct()//去除重复元素
                .skip(2)//跳过两个元素
                .limit(2)//限制输出元素
                .forEach((e)->{//我们这里就使用了lambda表达式
            System.out.println(e); //集合遍历
        });

终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返

回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返

回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

Integer i = a1.stream().distinct()
//                .findFirst().get();//返回第一个元素
//        System.out.println(i);


//        boolean b = a1.stream().distinct()
//                .anyMatch((e) -> {
//                    return e > 2;//有一个元素满足条件返回true,allMatch所有条件满足返回true否则返回false
//                });
//        System.out.println(b);


//        Integer i = a1.stream().distinct()
//                .reduce((o1, o2) -> {
//                    return o1 + o2;//流中所有元素相加
//                }).get();
//        System.out.println(i);


//        long count = a1.stream().distinct()
//                .count();//计算流中数据个数,为long类型
//        System.out.println(count);

//        Integer i = a1.stream().distinct()
//                .min((o1, o2) -> {
//                    return o1 - o2;//最小值min方法将数据包装在一个类中需要调用get方法返回数据,max也一样
//                }).get();
//        System.out.println(i);


//        a1.stream().distinct()
//                .forEach((e)->{
//                    System.out.println(e);//元素遍历
//                });

将整数换成student对象
 student s1 =new student(1,"张三1",18);
        student s2 =new student(2,"张三2",19);
        student s4 =new student(3,"张三4",20);
        student s3 =new student(4,"张三3",21);
        student s6 =new student(5,"张三6",22);
        ArrayList<student> a = new ArrayList<>();
        a.add(s1);
        a.add(s2);
        a.add(s3);
        a.add(s4);
        a.add(s6);
//        Map<Integer, String> collect = a.stream()
//                .collect(Collectors.toMap(student::getId, student::getName));//将对象中的属性的值映射到一个新的集合中去也是lambda表达式
//        System.out.println(collect);


//        List<student> collect = a.stream().sorted((o1, o2) -> {
//            return o1.getAge() - o2.getAge();//用年龄排序
//        }).collect(Collectors.toList());//将流转换为list集合
//        System.out.println(collect);


//        List<Integer> collect = a.stream().map(student::getId)//将对象中某个属性的值映射到一个新的集合中去
//                .collect(Collectors.toList());
//        System.out.println(collect);