关于java:Lambda表达式函数式编程整合

一、引言

java8最大的个性就是引入Lambda表达式，即函数式编程，能够将行为进行传递。总结就是：应用不可变值与函数，函数对不可变值进行解决，映射成另一个值。

二、java重要的函数式接口

1、什么是函数式接口

函数接口是只有一个形象办法的接口，用作 Lambda 表达式的类型。应用@FunctionalInterface注解润饰的类，编译器会检测该类是否只有一个形象办法或接口，否则，会报错。能够有多个默认办法，静态方法。

1.1 java8自带的罕用函数式接口。

函数接口	形象办法	性能	参数	返回类型	示例
Predicate	test(T t)	判断虚实	T	boolean	9龙的身高大于185cm吗？
Consumer	accept(T t)	生产音讯	T	void	输入一个值
Function	R apply(T t)	将T映射为R（转换性能）	T	R	取得student对象的名字
Supplier	T get()	生产音讯	None	T	工厂办法
UnaryOperator	T apply(T t)	一元操作	T	T	逻辑非（!）
BinaryOperator	apply(T t, U u)	二元操作	(T，T)	(T)	求两个数的乘积（*）

public class Test {
    
    @ToString
    static class OutstandingClass {
        private String name;
        private Student student;
        public String getName() {
            return name;
        }
        public Student getStudent() {
            return student;
        }
        
        public OutstandingClass(String name, Student student) {
            this.name = name;
            this.student = student;
        }
        public OutstandingClass() {
        }
    }
    
    @ToString
    static class Student{
         private String name;
         private int age;
         private int stature;
         private List<SpecialityEnum> specialitys;
         public Student(String name,int age,int height){
             this.name=name;
             this.age=age;
             this.stature=height;
         }
         public int getStature() {
             return stature;
         }
         public int getAge() {
             return age;
         }
         public String getName() {
             return name;
         }
         public List<SpecialityEnum> getSpecialitys() {
            return specialitys;
        }
    }
    
    @ToString
    static enum SpecialityEnum {
         SIGN("sing"),
         DANCE("dance"),
         SWIMMING("swimming"),
         RUNNING("running");
         private String speciality;
         public String getSpeciality() {
                return speciality;
         }
    // 构造方法，留神：构造方法不能为public，因为enum并不能够被实例化
        private SpecialityEnum(String speciality) {
            this.speciality = speciality;
        }
    }
    
    public static void main(String[] args) {
        Predicate<Integer> predicate = x -> x > 185;
        Student student = new Student("9龙", 23, 175);
        System.out.println(
            "9龙的身高高于185吗？：" +           predicate.test(student.getStature()));

        Consumer<String> consumer = System.out::println;
        consumer.accept("命运由我不禁天");

        Function<Student, String> function = Student::getName;
        String name = function.apply(student);
        System.out.println(name);

        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);

        BinaryOperator<Integer> operator = (x, y) -> x * y;
        Integer integer = operator.apply(2, 3);
        System.out.println(integer);

        test(() -> "我是一个演示的函数式接口");
    }

    /**
     * 演示自定义函数式接口应用
     *
     * @param worker
     */
    public static void test(Worker worker) {
        String work = worker.work();
        System.out.println(work);
    }

    public interface Worker {
        String work();
    }
}
//9龙的身高高于185吗？：false
//命运由我不禁天
//9龙
//10
//false
//6
//我是一个演示的函数式接口

以上演示了lambda接口的应用及自定义一个函数式接口并应用。上面，咱们看看java8将函数式接口封装到流中如何高效的帮忙咱们解决汇合。

留神：Student::getName例子中这种编写lambda表达式的形式称为办法援用。格局为ClassNmae::methodName。是不是很神奇，java8就是这么迷人。

1.2 惰性求值与及早求值

惰性求值：只形容Stream，操作的后果也是Stream，这样的操作称为惰性求值。惰性求值能够像建造者模式一样链式应用，最初再应用及早求值得到最终后果。

及早求值：失去最终的后果而不是Stream，这样的操作称为及早求值。

2、罕用的流

2.1 collect(Collectors.toList())

将流转换为list。还有toSet()，toMap()等。及早求值。


List<Student> studentList = Stream.of(
    new Student("路飞", 22, 175),
    new Student("红发", 40, 180),
    new Student("白胡子", 50, 185))
.collect(Collectors.toList());
System.out.println(studentList);

//输入后果
//[Student{name='路飞', age=22, stature=175, specialities=null}, 
//Student{name='红发', age=40, stature=180, specialities=null}, 
//Student{name='白胡子', age=50, stature=185, specialities=null}]

2.2 filter

顾名思义，起过滤筛选的作用。外部就是Predicate接口。惰性求值。

比方咱们筛选出出身高小于180的同学。

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);
        
//输入后果
//[Student{name='路飞', age=22, stature=175, specialities=null}]

2.3 map

转换性能，外部就是Function接口。惰性求值

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);
        
//输入后果
//[路飞, 红发, 白胡子]

例子中将student对象转换为String对象，获取student的名字。

2.4 flatMap

将多个Stream合并为一个Stream。惰性求值

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);
        
//输入后果
//[Student{name='路飞', age=22, stature=175, specialities=null}, 
//Student{name='红发', age=40, stature=180, specialities=null}, 
//Student{name='白胡子', age=50, stature=185, specialities=null}, 
//Student{name='艾斯', age=25, stature=183, specialities=null},
//Student{name='雷利', age=48, stature=176, specialities=null}]

调用Stream.of的静态方法将两个list转换为Stream，再通过flatMap将两个流合并为一个。

2.5 max和min

咱们常常会在汇合中求最大或最小值，应用流就很不便。及早求值。

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(Comparator.comparing(stu -> stu.getAge()));
        Optional<Student> min = students.stream()
            .min(Comparator.comparing(stu -> stu.getAge()));
        //判断是否有值
        if (max.isPresent()) {
            System.out.println(max.get());
        }
        if (min.isPresent()) {
            System.out.println(min.get());
        }
        
//输入后果
//Student{name='白胡子', age=50, stature=185, specialities=null}
//Student{name='路飞', age=22, stature=175, specialities=null}

max、min接管一个Comparator（例子中应用java8自带的动态函数，只须要传进须要比拟值即可。）并且返回一个Optional对象，该对象是java8新增的类，专门为了避免null引发的空指针异样。能够应用max.isPresent()判断是否有值；能够应用max.orElse(new Student())，当值为null时就应用给定值；也能够应用max.orElseGet(() -> new Student());这须要传入一个Supplier的lambda表达式。

2.6 count

统计性能，个别都是联合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));

        long count = students.stream().filter(s1 -> s1.getAge() < 45).count();
        System.out.println("年龄小于45岁的人数是：" + count);
        
//输入后果
//年龄小于45岁的人数是：2

2.7 reduce

reduce 操作能够实现从一组值中生成一个值。在上述例子中用到的 count 、 min 和 max 方法，因为罕用而被纳入规范库中。事实上，这些办法都是 reduce 操作。及早求值。

Integer reduce = Stream.of(1, 2, 3, 4).reduce(0, (acc, x) -> acc+ x);
        System.out.println(reduce);
//输入后果
//10

咱们看得reduce接管了一个初始值为0的累加器，顺次取出值与累加器相加，最初累加器的值就是最终的后果。

三、高级汇合类及收集器

收集器，一种通用的、从流生成简单值的构造。只有将它传给 collect 办法，所有的流就都能够应用它了。规范类库曾经提供了一些有用的收集器，以下示例代码中的收集器都是从 java.util.stream.Collectors 类中动态导入的。

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.getName());
System.out.println("一班平均年龄是：" + averageNumberOfStudent(students1));

/**
 * 获取人数最多的班级
 */
public static OutstandingClass biggestGroup(Stream<OutstandingClass> outstandingClasses) {
    return outstandingClasses.collect(
            maxBy(comparing(ostClass -> ostClass.getStudents().size())))
            .orElseGet(OutstandingClass::new);
}
/**
 * 计算平均年龄
 */
private static double averageNumberOfStudent(List<Student> students) {
    return students.stream().collect(averagingInt(Student::getAge));
}

//输入后果
//人数最多的班级是：一班
//一班平均年龄是：37.666666666666664

maxBy或者minBy就是求最大值与最小值。

3.2 转换成块

罕用的流操作是将其分解成两个汇合，Collectors.partitioningBy帮咱们实现了，接管一个Predicate函数式接口。

将示例学生分为会唱歌与不会唱歌的两个汇合。

Map<Boolean, List<Student>> listMap = students.stream().collect(
            Collectors.partitioningBy(student -> student.getSpecialities().
                                      contains(SpecialityEnum.SING)));

3.3 数据分组

数据分组是一种更天然的宰割数据操作，与将数据分成 ture 和 false 两局部不同，能够使用任意值对数据分组。Collectors.groupingBy接管一个Function做转换。

如图，咱们应用groupingBy将依据进行分组为圆形一组，三角形一组，正方形一组。

例子：依据学生第一个专长进行分组

Map<SpecialityEnum, List<Student>> listMap = 
             students.stream().collect(
             Collectors.groupingBy(student -> student.getSpecialities().get(0)));

Collectors.groupingBy与SQL 中的 group by 操作是一样的。

3.4 字符串拼接

如果将所有学生的名字拼接起来，怎么做呢？通常只能创立一个StringBuilder，循环拼接。应用Stream，应用Collectors.joining()简略容易。**

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);
        
//输入后果
//[路飞,红发,白胡子]

joining接管三个参数，第一个是分界符，第二个是前缀符，第三个是结束符。也能够不传入参数Collectors.joining()，这样就是间接拼接。

3.5 筛选+-

static class Student{
    public String name;
     public int age;
     public int stature;
     public boolean result;
     public Student(String name,int age,int height,boolean result){
            this.name=name;
     this.age=age;
     this.stature=height;
     this.result=result;
 }
    public void setResult(boolean result){
        this.result= result;
 }
    public int getStature() {
        return stature;
 }
    public int getAge() {
        return age;
 }
    public String getName() {
        return name;
 }
    public boolean getResult() {
        return result;
 }
}
public static void main(String[] args) {
    List<String> iv=new ArrayList();
 iv.add("张三");
 iv.add("李四");
 iv.add("王五");
 iv.add("赵六");
 List<Student> troList =new ArrayList();
 troList.add(new Student("bobo",20,170,false));
 troList.add(new Student("张三",30,171,false));
 troList.add(new Student("老李",40,172,false));
 troList.add(new Student("赵六",50,173,false));
 troList.add(new Student("隔壁老王",60,174,false));
 //筛选+
 List<String> stringList = iv.stream().filter(
            tname -> troList.stream().map(Student::getName).collect(Collectors.toList()).contains(tname)
    ).collect(Collectors.toList());
 List<Student> students = troList.stream().map(
            student -> {
                if(iv.contains(student.getName())){
                    student.setResult(true);
 return student;
 }
                return student;
 }
    ).collect(Collectors.toList());
 students.forEach(
            s -> {
                System.out.println(s.getName() +":" + s.getResult());
 }
    );
 System.out.println("================筛选+===============");
 stringList.forEach(
            s -> {
                System.out.println(s);
 }
    );
 System.out.println("================筛选-===============");
 //筛选-
 List<String> stringList2 = iv.stream().filter(
            tname -> !troList.stream().map(Student::getName).collect(Collectors.toList()).contains(tname)
    ).collect(Collectors.toList());
 stringList2.forEach(
            s -> {
                System.out.println(s);
 }
    );
}

四、总结

本篇次要从理论应用讲述了罕用的办法及流，应用java8能够很清晰表白你要做什么，代码也很简洁。本篇例子次要是为了解说较为简单，大家能够去应用java8重构本人现有的代码，自行体会lambda的奥秘。本文说的Stream要组合应用才会施展更大的性能，链式调用很迷人，依据本人的业务去做吧。

关于java:Lambda表达式函数式编程整合

一、引言

二、java重要的函数式接口

1、什么是函数式接口

1.1 java8自带的罕用函数式接口。

1.2 惰性求值与及早求值

2、罕用的流

2.1 collect(Collectors.toList())

2.2 filter

2.3 map

2.4 flatMap

2.5 max和min

2.6 count

2.7 reduce

三、高级汇合类及收集器

3.2 转换成块

3.3 数据分组

3.4 字符串拼接

3.5 筛选+-

四、总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:Lambda表达式函数式编程整合

一、引言

二、java重要的函数式接口

1、什么是函数式接口

1.1 java8自带的罕用函数式接口。

1.2 惰性求值与及早求值

2、罕用的流

2.1 collect(Collectors.toList())

2.2 filter

2.3 map

2.4 flatMap

2.5 max和min

2.6 count

2.7 reduce

三、高级汇合类及收集器

3.2 转换成块

3.3 数据分组

3.4 字符串拼接

3.5 筛选+-

四、总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复