Lamda简单方法操作

Dear 丶 2021-09-30 15:22 320阅读 0赞

package com.example.socket.demo.TEST.Lamda;
    
    import javax.swing.plaf.synth.SynthUI;
    import java.awt.dnd.DragGestureEvent;
    import java.math.BigDecimal;
    import java.util.*;
    import java.util.function.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    import static java.util.Arrays.asList;
    import static java.util.Comparator.comparing;
    import static java.util.stream.Collectors.*;
    
    /**
     *功能描述 联系java8Lamda表达式
     * @author kangjinfan
     * @date 2019/8/6
     */
    public class Lamda {
            public static void main(String[] args) {
    //              changYong();
    
    //            将流转换为list
    //            list();
    
    //            filter
                //顾名思义，起过滤筛选的作用
    //            filter();
    
    //          转换功能
    //            map();
    
    //           将多个Stream合并为一个Stream
    //            flatMap();
    
    
    //            求最大或最小值
    //            maxmin();
    
    
    //          统计功能
    //            count();
    
    //            操作可以实现从一组值中生成一个值
    //            reduce();
    
    //            收集器
    //            CollectorsTest();
    
    //            字符串拼接
                JoiningTest();
            }
    
            //常用方法
            public static  void changYong(){
                Predicate<Integer> predicate = x -> x > 185;
                Student student = new Student("9龙", 23, 175);
                System.out.println("9龙的身高高于185吗？：" + predicate.test(student.getStature()));//判断
    
    
                //test只能判断Integer类型
                Consumer consumer1 = System.out::println;
                Predicate<String> predicate1 = y -> y == "1";
                consumer1.accept("输出string判断"+predicate.test(Integer.valueOf(2)));
    
                Consumer<String> consumer = System.out::println;
                consumer.accept("命运由我不由天");//输出
    
                Function<Student, String> function = Student::getName;//方法获取姓名
                String name = function.apply(student);
                System.out.println(name);
                consumer.accept("测试consumer=="+name);
    
                Function<Student,Integer> fun = Student::getAge;
                Integer age = fun.apply(student);
                Consumer consumer2 = System.out::println;
                consumer2.accept("继续测试consumer功能"+age);
    
                Supplier<Integer> supplier = () -> Integer.valueOf(BigDecimal.TEN.toString());//工厂方法
                System.out.println(supplier.get());
    
                UnaryOperator<Boolean> unaryOperator = uglily -> !uglily;//逻辑非
                Boolean apply2 = unaryOperator.apply(true);
                System.out.println(apply2);
    
                UnaryOperator<Boolean> unary = xx -> !xx;
                Boolean boo = unary.apply(false);
                Consumer booConsumer = System.out::println;
                booConsumer.accept("测试非逻辑"+boo);
    
    
                BinaryOperator<Integer> operator = (x, y) -> x + y;//相乘
                Integer integer = operator.apply(2, 3);
                System.out.println(integer);
    
    
                BinaryOperator<String> binaryOperator = (z,c) -> z + c;
                String bb = binaryOperator.apply("a", "b");
                Consumer c = System.out::println;
                c.accept("输出String类型相加"+bb);
    
    
                test(() -> "我是一个演示的函数式接口");
            }
            /**
             * 演示自定义函数式接口使用
             *
             * @param worker
             */
            public static void test(Worker worker) {
                String work = worker.work();
                System.out.println(work);
    
            }
            public interface Worker {
                String work();
            }
    
        //内部类学生
        static class Student{
            private String name;
            private Integer age;
            private Integer stature;
            public Student(String name,Integer age,Integer stature){
                this.name = name;
                this.age = age;
                this.stature = stature;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public Integer getAge() {
                return age;
            }
            public void setAge(Integer age) {
                this.age = age;
            }
            public Integer getStature() {
                return stature;
            }
            public void setStature(Integer stature) {
                this.stature = stature;
            }
        }
    
    
        //将流转换为list。还有toSet()，toMap()等。及早求值
        public static void list() {
            List<Student> studentList = Stream.of(
                    new Student("路飞", 22, 175),
                    new Student("红发", 40, 180),
                    new Student("白胡子", 50, 185)).collect(Collectors.toList());
            System.out.println(studentList);
    
            List<Student> sti = Stream.of(new Student("ce", 10, 100),
                    new Student("ce1", 11, 200),
                    new Student("ce2", 12, 300)
                    ).collect(Collectors.toList());
            Consumer consumer = System.out::println;
            consumer.accept("自创list:"+sti);
        }
    
    
        //filter
        //顾名思义，起过滤筛选的作用。内部就是Predicate接口。惰性求值。
    //    比如我们筛选出出身高小于180的同学。
        public static void filter() {
            List<Student> students = new ArrayList<>(3);
            students.add(new Student("路飞", 22, 175));
            students.add(new Student("红发", 40, 180));
            students.add(new Student("白胡子", 50, 185));
            List<Student> list = students.stream()
                    .filter(stu -> stu.getStature() < 180)
                    .collect(Collectors.toList());
            System.out.println(list);
    
            List<Student> listTest = Stream.of(
                    new Student("测试", 10, 100),
                    new Student("测试1", 20, 120),
                    new Student("测试2", 30, 121)
            ).collect(Collectors.toList());
    
            List<Student> ageStudent = listTest.stream().filter(stu -> stu.getAge()<20).collect(Collectors.toList());
            Consumer con = System.out::println;
            ageStudent.stream().forEach(aa -> aa.getAge());
            con.accept("判断后的list"+ageStudent);
        }
    
    
    
    //    map
    //    转换功能，内部就是Function接口。惰性求值
    //    例子中将student对象转换为String对象，获取student的名字。
        public static void map() {
            List<Student> students = new ArrayList<>(3);
            students.add(new Student("路飞", 22, 175));
            students.add(new Student("红发", 40, 180));
            students.add(new Student("白胡子", 50, 185));
            List<String> names = students.stream().map(student -> student.getName())
                    .collect(Collectors.toList());
            System.out.println(names);
    
    
            List<Student> list = Stream.of(
                    new Student("a", 1, 1),
                    new Student("b", 2, 2),
                    new Student("c", 3, 3)
            ).collect(Collectors.toList());
    
            List<Integer> ageList = list.stream().map(l -> l.getAge()).collect(Collectors.toList());
            Consumer con = System.out::println;
            con.accept("测试自己写的map"+ageList);
    
    
        }
    
    
    
    //    flatMap
    //    将多个Stream合并为一个Stream。惰性求值
    //    调用Stream.of的静态方法将两个list转换为Stream，再通过flatMap将两个流合并为一个。
        public static void flatMap() {
            List<Student> students = new ArrayList<>(3);
            students.add(new Student("路飞", 22, 175));
            students.add(new Student("红发", 40, 180));
            students.add(new Student("白胡子", 50, 185));
            List<Student> studentList = Stream.of(students,
                    asList(new Student("艾斯", 25, 183),
                            new Student("雷利", 48, 176)))
                    .flatMap(students1 -> students1.stream()).collect(Collectors.toList());
            System.out.println(studentList);
    
            List<Student> s1 = Stream.of(
                    new Student("a", 1, 1),
                    new Student("b", 2, 2)
            ).collect(Collectors.toList());
    
            List<Student> s2 = Stream.of(
                    new Student("c", 3, 3),
                    new Student("b", 4, 4)
            ).collect(Collectors.toList());
    
            List<Student> ss = Stream.of(s1,s2).flatMap(s -> s.stream()).collect(Collectors.toList());
            Consumer c = System.out::println;
            c.accept("自测stream合并"+ss);
        }
    
    
    //    max和min
    //    我们经常会在集合中求最大或最小值，使用流就很方便。及早求值。
    //    max、min接收一个Comparator（例子中使用java8自带的静态函数，只需要传进需要比较值即可。）
    //    并且返回一个Optional对象，该对象是java8新增的类，专门为了防止null引发的空指针异常。
    //    可以使用max.isPresent()判断是否有值；可以使用max.orElse(new Student())，
    //    当值为null时就使用给定值；也可以使用max.orElseGet(() -> new Student());
    //    这需要传入一个Supplier的lambda表达式。
        public static void maxmin() {
            List<Student> students = new ArrayList<>(3);
            students.add(new Student("路飞", 22, 175));
            students.add(new Student("红发", 40, 180));
            students.add(new Student("白胡子", 50, 185));
            Optional<Student> max = students.stream()
                    .max(comparing(stu -> stu.getAge()));
            Optional<Student> min = students.stream()
                    .min(comparing(stu -> stu.getAge()));
            //判断是否有值
            if (max.isPresent()) {
                System.out.println(max.get().name);
            }
            if (min.isPresent()) {
                System.out.println(min.get().name);
            }
    
    
            List<Student> s = Stream.of(
                    new Student("a", 1, 10),
                    new Student("b", 2, 20),
                    new Student("c", 3, 30)
            ).collect(Collectors.toList());
    
            Consumer c = System.out::println;
    
            Long sum = s.stream().map(aa -> aa.getAge() >1).count();
            c.accept("年龄大于1的数量"+sum);
    
            Optional<Student> stuMax =  s.stream().max(comparing(ss -> ss.getAge()));
            if (stuMax.isPresent()){
    
               c.accept("最大值："+stuMax.get().getAge());
           }
    
           Optional<Student> stuMin =  s.stream().min(comparing(tt -> tt.getAge()));
    
           if (stuMin.isPresent()){
               c.accept("最小值"+stuMin.get().getAge());
           }
        }
    
    //    count
    //    统计功能，一般都是结合filter使用，因为先筛选出我们需要的再统计即可。及早求值
            public static void count() {
                List<Student> students = new ArrayList<>(3);
                students.add(new Student("路飞", 22, 175));
                students.add(new Student("红发", 40, 180));
                students.add(new Student("白胡子", 50, 185));
                long count = students.stream().filter(s1 -> s1.getAge() < 45).count();
                System.out.println("年龄小于45岁的人数是：" + count);
    
    
    
               Long num = Stream.of(
                        new Student("a",1,10),
                        new Student("b", 2,20),
                        new Student("aa",3,30)
                ).collect(Collectors.toList()).stream().map(aa-> aa.getAge()>0).count();
                Consumer c = System.out::println;
                c.accept("自测计算符合判断的数量："+num);
    
            }
    
    
    //    reduce 操作可以实现从一组值中生成一个值。在上述例子中用到的 count 、 min 和 max 方法，
    //    因为常用而被纳入标准库中。事实上，这些方法都是 reduce 操作。及早求值。
            public static void reduce() {
                Integer reduce = Stream.of(1, 2, 3, 4).reduce(0, (acc, x) -> acc+ x);
                System.out.println(reduce);
    
                Consumer c = System.out::println;
                Integer a = Stream.of(1,2,3,4,5,6,7).reduce(100, (aa,b) -> aa-b);
                c.accept("测试加法："+a);
            }
    
    
            static  class OutstandingClass {
                private String className;
                private List<Student> list;
    
                public OutstandingClass(String className,List<Student> list) {
                    this.className = className;
                    this.list = list;
                }
    
                public OutstandingClass() {
    
                }
    
                public String getClassName() {
                    return className;
                }
                public void setClassName(String className) {
                    this.className = className;
                }
                public List<Student> getList() {
                    return list;
                }
                public void setList(List<Student> list) {
                    this.list = list;
                }
            }
    
    
    
            /*********************************高级集合类及收集器******************************/
    //    收集器，一种通用的、从流生成复杂值的结构。只要将它传给 collect 方法，所有
    //    的流就都可以使用它了。标准类库已经提供了一些有用的收集器，以下示例代码中的收集器都是从
    //    java.util.stream.Collectors 类中静态导入的。
            public  static void CollectorsTest() {
                    List<Student> students1 = new ArrayList<>(3);
                    students1.add(new Student("路飞", 23, 175));
                    students1.add(new Student("红发", 40, 180));
                    students1.add(new Student("白胡子", 50, 185));
                    OutstandingClass ostClass1 = new OutstandingClass("一班", students1);
                    //复制students1，并移除一个学生
                    List<Student> students2 = new ArrayList<>(students1);
                    students2.remove(1);
                    OutstandingClass ostClass2 = new OutstandingClass("二班", students2);
                    //将ostClass1、ostClass2转换为Stream
                    Stream<OutstandingClass> classStream = Stream.of(ostClass1, ostClass2);
                    OutstandingClass outstandingClass = biggestGroup(classStream);
                    System.out.println("人数最多的班级是：" + outstandingClass.getClass());
                    System.out.println("一班平均年龄是：" + averageNumberOfStudent(students1));
                }
    
                /**
                 * 获取人数最多的班级
                 */
                private static OutstandingClass biggestGroup(Stream<OutstandingClass> outstandingClasses) {
                    return outstandingClasses.collect(
                            maxBy(comparing(ostClass -> ostClass.getList().size())))
                            .orElseGet(OutstandingClass::new);
                }
    
                /**
                 * 计算平均年龄
                 */
                private static double averageNumberOfStudent(List<Student> students) {
                    return students.stream().collect(averagingInt(Student::getAge));
                }
    
    
    //    转换成块
    //    常用的流操作是将其分解成两个集合，
    //    Collectors.partitioningBy帮我们实现了，接收一个Predicate函数式接口
    //    将示例学生分为会唱歌与不会唱歌的两个集合
            public static void PartitioningByTest(String[] args) {
                List<Student> students = new ArrayList<>(3);
                students.add(new Student("路飞", 23, 175));
                students.add(new Student("红发", 40, 180));
                students.add(new Student("白胡子", 50, 185));
    //            Map<Boolean, List<Student>> listMap = students.stream().collect(
    //                    Collectors.partitioningBy(student ->
    //                            student.getSpecialities().
    //                                    contains(SpecialityEnum.SING)));
            }
    
    
    //    根据学生第一个特长进行分组
    //    数据分组是一种更自然的分割数据操作，
    //    与将数据分成 ture 和 false 两部分不同，可以使用任意值对数据分组。Collectors.groupingBy接收一个Function做转换。
    //     Collectors.groupingBy与SQL 中的 group by 操作是一样的。
            public static void GroupingByTest() {
                List<Student> students = new ArrayList<>(3);
                students.add(new Student("路飞", 23, 175));
                students.add(new Student("红发", 40, 180));
                students.add(new Student("白胡子", 50, 185));
    //            Map<SpecialityEnum, List<Student>> listMap =
    //                    students.stream().collect(
    //                            Collectors.groupingBy(student -> student.getSpecialities().get(0)));
            }
    
    
    //    字符串拼接
    //    如果将所有学生的名字拼接起来，怎么做呢？通常只能创建一个StringBuilder，
    //    循环拼接。使用Stream，使用Collectors.joining()简单容易。
            public static void JoiningTest() {
                List<Student> students = new ArrayList<>(3);
                students.add(new Student("路飞", 22, 175));
                students.add(new Student("红发", 40, 180));
                students.add(new Student("白胡子", 50, 185));
    
                String names = students.stream()
                        .map(Student::getName).collect(Collectors.joining(",","[","]"));
                System.out.println(names);
    
    
                List<Student> ss = Stream.of(
                        new Student("a", 1, 1),
                        new Student("b", 2, 2),
                        new Student("c", 3, 3)
                ).collect(Collectors.toList());
                Consumer c = System.out::println;
                String name = ss.stream().map(n -> n.getName()).collect(Collectors.joining("-","{","}"));
                c.accept("测试拼接："+name);
            }
    }