JAVA8 关于集合的LAMBDA聚合操作

一、案例展示

下面首先给大家展示一些JAVA8 关于集合的LAMBDA聚合操作案例

@RequestMapping("/")
public String  index() {
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    //获得空字符串
    System.out.println("list集合中空的个数有："+strings.stream().filter(s -> s.isEmpty()).count());
    //将字符串变大写
    List<String> strings1 = strings.stream().map(s1 ->  s1.toUpperCase()).collect(Collectors.toList());
    strings1.forEach(s1 -> System.out.println(s1));
    //筛选不为空的字段
    List<String> strings2 = strings.stream().filter(s2 ->  !s2.isEmpty()).collect(Collectors.toList());
    strings2.forEach(s2 -> System.out.println(s2));
    //获取指定大小的字符串集合
    List<String> strings3 = strings.stream().limit(3).collect(Collectors.toList());
    strings3.forEach(s3 -> System.out.println(s3));
    //删除空字符串，将剩余的字符串拼接
    String allStr = strings.stream().filter(s4 -> !s4.isEmpty()).collect(Collectors.joining(","));
    System.out.println(allStr);
    return "aa";
}

二、传统方式与聚合操作方式遍历数据

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @Package: PACKAGE_NAME
 * @ClassName: Dog2
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/9/8 15:37
 */
public class Dog2 {
    private String name;
    private int length;
    private int weight;

    public Dog2(String name, int length, int weight) {
        this.name = name;
        this.length = length;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Dog2{" +
                "name='" + name + '\'' +
                ", length=" + length +
                ", weight=" + weight +
                '}';
    }

    public static void main(String[] args) {
        List<Dog2> dogs = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            dogs.add(new Dog2("dog" + i, r.nextInt(100), r.nextInt(100)));
        }
        System.out.println("初始化后的集合");
        System.out.println(dogs);
        System.out.println("查询条件：length>20 && weight<50");
        System.out.println("通过传统操作方式找出满足条件的数据：");
        for (Dog2 dog2 : dogs) {
            if (dog2.length > 20 && dog2.weight < 50) {
                System.out.println(dog2.getName());
            }
        }
        System.out.println("通过聚合操作方式找出满足条件的数据：");
        dogs.stream().filter(dog2 -> dog2.length > 20 && dog2.weight < 50)
                .forEach(dog2 -> System.out.println(dog2.getName()));


    }
}

三、Stream和管道的概念

Stream 和Collection结构化的数据不一样，Stream是一系列的元素，就像是生产线上的罐头一样，一串串的出来。
管道指的是一系列的聚合操作。

管道又分3个部分
管道源：在这个例子里，源是一个List
中间操作： 每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
结束操作：当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream，但是会返回int、float、String、 Collection或者像forEach，什么都不返回, 结束操作才进行真正的遍历行为，在遍历的时候，才会去进行中间操作的相关判断

四、中间操作

每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
中间操作比较多，主要分两类   对元素进行筛选 和 转换为其他形式的流

1.对元素进行筛选：

filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator<T>) 指定排序
limit 保留
skip 忽略

2.转换为其他形式的流

mapToDouble 转换为double的流
map 转换为任意类型的流

五、结束操作

当进行结束操作后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream，但是会返回int、float、String、 Collection或者像forEach，什么都不返回,。
结束操作才真正进行遍历行为，前面的中间操作也在这个时候，才真正的执行。
常见结束操作如下：
forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator<T>) 取最小的元素
max(Comparator<T>) 取最大的元素
count() 总数
findFirst() 第一个元素

六、中间操作，结尾操作演示

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @Package: PACKAGE_NAME
 * @ClassName: Dog2
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/9/8 15:37
 */
public class Dog2 implements Comparable<Dog2> {
    private String name;
    private int length;
    private int weight;

    public Dog2(String name, int length, int weight) {
        this.name = name;
        this.length = length;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Dog2{" +
                "name='" + name + '\'' +
                ", length=" + length +
                ", weight=" + weight +
                '}';
    }

    @Override
    public int compareTo(Dog2 o) {
        if (weight > o.weight) {
            return 1;
        } else {
            return -1;
        }
    }

    public static void main(String[] args) {
        List<Dog2> dogs = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            dogs.add(new Dog2("dog" + i, r.nextInt(100), r.nextInt(100)));
        }
        System.out.println("添加一个重复元素");
        dogs.add(dogs.get(0));
        System.out.println("初始化后的集合(含一个重复元素)");
        System.out.println(dogs);
        System.out.println("查询条件：length>20 && weight<50");
        System.out.println("中间操作匹配--filter()");
        dogs.stream().filter(dog2 -> dog2.length > 20 && dog2.weight < 50)
                .forEach(dog2 -> System.out.println(dog2.getName()));
        System.out.println("中间操作去重--distinct()");
        dogs.stream().distinct().forEach(dog2 -> System.out.println(dog2.getName()));
        System.out.println("中间操作排序--sorted()");
        dogs.stream().sorted((dog2, dog22) -> dog2.weight >= dog22.weight ? 1 : -1)
                .forEach(dog2 -> System.out.println(dog2.getName()));
        System.out.println("中间操作保留--limit()");
        dogs.stream().limit(2).forEach(dog2 -> System.out.println(dog2.getName()));
        System.out.println("中间操作忽略--skip()");
        dogs.stream().skip(1).forEach(dog2 -> System.out.println(dog2.getName()));
        System.out.println("结尾操作取最小的元素--min() ");
        System.out.print("最轻狗狗的名字:");
        Dog2 minDog = dogs.stream().min((h1, h2) -> h1.weight - h2.weight).get();
        System.out.println(minDog.getName());
        System.out.println("结尾操作取最大的元素--min() ");
        System.out.print("最长狗狗的名字:");
        Dog2 maxDog = dogs.stream().max((h1, h2) -> h1.length - h2.length).get();
        System.out.println(maxDog.getName());
        System.out.println("结尾操作count() 总数 ");
        System.out.println(dogs.stream().count());
        System.out.println("结尾操作findFirst() 第一个元素 ");
        Dog2 fDog = dogs.stream().findFirst().get();
        System.out.println(fDog.getName());

    }

}