一文掌握Lambda表达式(上)https://mp.csdn.net/mp_blog/creation/editor/125460693

目录

一、Optional

1.1 建造Optional

1.2 是否有值 

1.3 获取值 

1.4 过滤与映射 

二、Collectors

2.1 计数

2.2 平均值 

2.3 最值计算

2.4 递归计算 

2.5 收集并转换

2.6 收集到集合

2.5 分组收集

一、Optional

 Optional是JDK1.8引入的一个对象容器，主要用作方法返回类型，如果存在值则isPresent()方法返回true否则返回false。下面我们看看具体方法如何使用

1.1 建造Optional

      optional提供了两个静态建造方法of()和ofNullable；下面看看两者有什么区别

ofNullable(T value)

     try {
            //of方法value不允许为null，如果为null 则抛出NullPointerException
            Optional.of(null);
        } catch (NullPointerException npe) {
            npe.printStackTrace();
        }
        //ofNullable允许值为null
        Optional<Object> nonValueOptional = Optional.ofNullable(null);

1.2 是否有值 

 Optional中提供了连个静态方法判断是否有值，分别是isEmpty()和isPresent；两者语义相反

1.3 获取值 

Optional中获取值的方法如下表所示

value != null ? value : other

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X

T orElseGet(Supplier<? extends T> supplier)

orElseThrow()

1.4 过滤与映射 

    Optional除了上文的方法外还提供了类似Stream一样的操作,filter,map以及flatMap

filter(Predicate<? super T> predicate)

<U> Optional<U> map(Function<? super T, ? extends U> mapper)

 <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)

Optional<Integer> a=  Optional.ofNullable(2).filter(Objects::nonNull).map(p -> 2*p);
Optional<Integer>b=Optional.of(2).filter(Objects::nonNull).flatMap(p->Optional.ofNullable(2*p));

二、Collectors

收集是流操作中很重要的处理，在Collectors中提供了一些辅助工具方法帮助我们更加方法处理流

2.1 计数

Collectors中提供了counting()方法用户统计流中元素的数量，如下文所示代码结果是5

Long collect = Stream.of(1, 2, 3, 4, 5).collect(Collectors.counting());

2.2 平均值 

Collectors中提供了三个分别针对Integer,Double,Long求平均值的方法,不管是哪个方法返回数据类型都是double

 Double average = Stream.of(1, 2, 3, 4, 5).collect(Collectors.averagingInt(p -> p));
        average = Stream.of(1, 2, 3, 4, 5).collect(Collectors.averagingLong(p ->p));
        average = Stream.of(1, 2, 3, 4, 5).collect(Collectors.averagingDouble(p ->p));

2.3 最值计算

 Collectors也提供了求最大值和最小值的方法，具体示例如下文代码所示：

Integer max = Stream.of(1, 2, 3, 4, 5).collect(Collectors.maxBy(Integer::compareTo)).orElse(0);
Integer min = Stream.of(1, 2, 3, 4, 5).collect(Collectors.minBy(Integer::compareTo)).orElse(0);
System.out.println("max value is " + max + ", min value is " + min);

2.4 递归计算 

Collectors提供了reducing方法用于递归计算，通过递归可以计算流中元素的和，乘积等如

reducing(BinaryOperator<T> op)

reducing(T identity, BinaryOperator<T> op) 

reducing(U identity,
         Function<? super T, ? extends U> mapper,
         BinaryOperator<U> op)

代码示例如下： 

Integer sum = Stream.of(1, 2, 3, 4, 5).collect(Collectors.reducing((x, y) -> x + y)).orElse(0);
 
Integer sum2 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.reducing(100, (x, y) -> x + y));
 
Integer sum3 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.reducing(100, p -> 2 * p, (x, y) -> x + y));
System.out.println(sum + " , " + sum2 + " , " + sum3);

2.5 收集并转换

  有时候我们在收集完成还需要对收集的结果进行一次处理，此时collectingAndThen方法就特别适合此场景；比如在计算出平均值以后，构造一个平均值是：xxx的字符串，就可以这样处理

String result = Stream.of(1, 2, 3, 4, 5).collect(Collectors.collectingAndThen(Collectors.averagingInt(p -> p), p -> "平均值是：" + p));

2.6 收集到集合

收集到集合是我们最常用的方法，主要的方法如下：

Collectors.toList()

Collectors.toSet()

Collectors.toMap

Collectors.toUnmodifiableList()

Collectors.toUnmodifiableSet()

Collectors.toUnmodifiableMap

Collectors.toConcurrentMap

代码示例

Stream.of(1, 2, 3, 4, 5).collect(Collectors.toList());
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toSet());
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toUnmodifiableList());
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toUnmodifiableSet());
        
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toMap(p->"key_"+p,p->p,(k,v)->v));
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toUnmodifiableMap(p->"key_"+p,p->p,(k,v)->v));
Stream.of(1, 2, 3, 4, 5).collect(Collectors.toConcurrentMap(p->"key_"+p,p->p,(k,v)->v));

2.5 分组收集

 分组收集是流处理中比较复杂但是也是非常有用的处理。我们在工作中常常会遇到根据属性分组。比如有这样一组学生数据，我们需要按照性别分组，还有需要按照性别和姓进行多重分组我们就可以这样做：

public class StreamDemo {
    public static void main(String[] args) {
      
 
        Map<String, List<Student>> genderGroup = Stream.of(new Student("男", "张", "三")
                , new Student("男", "李", "四"),
                new Student("男", "王", "五")
                , new Student("女", "李", "小草"),
                new Student("女", "王", "小花")
        ).collect(Collectors.groupingBy(p -> p.getGender(), Collectors.toList()));
 
 
        Map<String, Map<String,List<Student>>> multiGroup = Stream.of(new Student("男", "张", "三")
                , new Student("男", "李", "四"),
                new Student("男", "王", "五")
                , new Student("女", "李", "小草"),
                new Student("女", "王", "小花")
        ).collect(Collectors.groupingBy(p -> p.getGender(), Collectors.groupingBy(p->p.getFirstName())));
        System.out.println(genderGroup);
        System.out.println(multiGroup);
    }
 
    public static class Student {
        /**
         * 性别
         */
        private String gender;
 
        /**
         * 姓
         */
        private String firstName;
 
        /**
         * 名称
         */
        private String lastName;
 
        public Student(String gender, String firstName, String lastName) {
            this.gender = gender;
            this.firstName = firstName;
            this.lastName = lastName;
        }
 
        @Override
        public String toString() {
            return "Student{" +
                    "gender='" + gender + '\'' +
                    ", firstName='" + firstName + '\'' +
                    ", lastName='" + lastName + '\'' +
                    '}';
        }
 
        public String getGender() {
            return gender;
        }
 
        public void setGender(String gender) {
            this.gender = gender;
        }
 
        public String getFirstName() {
            return firstName;
        }
 
        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }
 
        public String getLastName() {
            return lastName;
        }
 
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    }
}

输出的结果是：

{女=[Student{gender='女', firstName='李', lastName='小草'}, Student{gender='女', firstName='王', lastName='小花'}], 男=[Student{gender='男', firstName='张', lastName='三'}, Student{gender='男', firstName='李', lastName='四'}, Student{gender='男', firstName='王', lastName='五'}]}
{女={王=[Student{gender='女', firstName='王', lastName='小花'}], 李=[Student{gender='女', firstName='李', lastName='小草'}]}, 男={张=[Student{gender='男', firstName='张', lastName='三'}], 王=[Student{gender='男', firstName='王', lastName='五'}], 李=[Student{gender='男', firstName='李', lastName='四'}]}}