Stream浅解析

Stream流浅解析

package com.w.earn.share;


import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author yang kai bo
 * @Date 2024/5/26 19:43
 * @Description
 *  概念：stream流是一种对 Java 集合运算和表达的高阶抽象。
 *  优点：写法简单，代码简洁，效率高。
 *  原理：stream流将要处理的元素看作一种流，在管道中传输时，可以在管道的节点上进行筛选、排序、聚合等操作处理，经过最终操作最后得到前面处理的结果。
 *  eg: stream +-----> filter+-> sorted+-> map+-> collect
 */
public class StreamFlow {

    public static void main(String[] args) {
        function1();
        System.out.println("========================================实用场景=======================================");
        function2();
    }

    /**
     * 基础用法
     */
    public static void function1() {
        List<String> arrayList = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        // 1、forEach 迭代
        arrayList.forEach(System.out::print);
        System.out.println("=========================================================================================");
        // 2、map 映射每个元素到对应的结果
        List<String> collectList = arrayList.stream().map(o -> o + "==>").collect(Collectors.toList());
        System.out.println(collectList);
        System.out.println("=========================================================================================");
        // 3、filter 过滤器，过滤出来指定的元素
        List<String> filterList = arrayList.stream().filter(o -> o.startsWith("a")).collect(Collectors.toList());
        System.out.println(filterList);
        System.out.println("=========================================================================================");
        // 4、limit 获取指定数量的数据
        System.out.println("=========================================================================================");
        List<String> listCollect = arrayList.stream().limit(3).collect(Collectors.toList());
        System.out.println(listCollect);
        // 5、sorted
        System.out.println("=========================================================================================");
        List<String> sortedCollect = arrayList.stream().sorted().collect(Collectors.toList());
        System.out.println(sortedCollect);
        System.out.println("=========================================================================================");
        // 6、并行（parallel）程序，多线程，多个任务同时处理
        List<String> parallelCollect1 = arrayList.parallelStream().map(o -> o + "==>").collect(Collectors.toList());
        List<String> parallelCollect2 = arrayList.parallelStream().filter(o -> o.startsWith("a")).collect(Collectors.toList());
        List<String> parallelCollect3 = arrayList.parallelStream().limit(3).collect(Collectors.toList());
        List<String> parallelCollect4 = arrayList.parallelStream().sorted().collect(Collectors.toList());
        System.out.println(parallelCollect1);
        System.out.println(parallelCollect2);
        System.out.println(parallelCollect3);
        System.out.println(parallelCollect4);
        System.out.println("=========================================================================================");
        // 7、Collectors
        String mergedString1 = arrayList.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining("<==>"));
        List<String> mergedString2 = arrayList.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
        System.out.println("合并字符串: " + mergedString1);
        System.out.println("合并字符串: " + mergedString2);
        System.out.println("=========================================================================================");
        // 8、统计
        IntSummaryStatistics intSummaryStatistics = arrayList.stream().mapToInt(o -> o.length()).summaryStatistics();
        System.out.println(intSummaryStatistics.getAverage());
        System.out.println(intSummaryStatistics.getMax());
        System.out.println(intSummaryStatistics.getCount());
        System.out.println(intSummaryStatistics.getMin());
        System.out.println(intSummaryStatistics.getSum());
        System.out.println("=========================================================================================");
    }

    // 实用一点的用法
    public static void function2() {
        Role role1 = new Role();
        role1.setAge(18);
        role1.setName("zhangsan");
        Role role2 = new Role();
        role2.setAge(15);
        role2.setName("lisi");
        Role role3 = new Role();
        role3.setAge(19);
        role3.setName("wangwu");
        Role role4 = new Role();
        role4.setAge(11);
        role4.setName("liming");
        List<Role> list = new ArrayList<>();
        list.add(role1);
        list.add(role2);
        list.add(role3);
        list.add(role4);


        // 1、anymatch 只要有符合条件的元素，则返回true
        boolean anyMatch1 = list.stream().anyMatch(o -> o.getAge() < 20);
        boolean anyMatch2 = list.stream().anyMatch(o -> o.getAge() > 20);
        System.out.println(anyMatch1);
        System.out.println(anyMatch2);
        System.out.println("=========================================================================================");

        // 2、allmatch 全部元素都符合条件，则返回true
        boolean allMatch1 = list.stream().allMatch(o -> o.getAge() < 18);
        boolean allMatch2 = list.stream().allMatch(o -> o.getAge() < 20);
        System.out.println(allMatch1);
        System.out.println(allMatch2);
        System.out.println("=========================================================================================");

        // 3、nomatch 没有元素符合条件，则返回true
        boolean noneMatch1 = list.stream().noneMatch(o -> o.getAge() < 18);
        boolean noneMatch2 = list.stream().noneMatch(o -> o.getAge() > 20);
        System.out.println(noneMatch1);
        System.out.println(noneMatch2);
        System.out.println("=========================================================================================");

        // 4、对象字段排序，升序降序
        List<Role> sortedCollect = list.stream().sorted(Comparator.comparing(Role::getAge)).collect(Collectors.toList());
        System.out.println(sortedCollect);
        List<Role> sortedCollect2 = list.stream().sorted(Comparator.comparing(Role::getAge).reversed()).collect(Collectors.toList());
        System.out.println(sortedCollect2);
        System.out.println("=========================================================================================");

        Role role5 = new Role();
        role5.setAge(18);
        role5.setName("wudi");
        Role role6 = new Role();
        role6.setAge(18);
        role6.setName("jimo");
        list.add(role5);
        list.add(role6);
        // 5、对象多个字段排序
        List<Role> sortedCollect4 = list.stream().sorted(Comparator.comparing(Role::getAge)).collect(Collectors.toList());
        List<Role> sortedCollect5 = list.stream().sorted(Comparator.comparing(Role::getAge).thenComparing(Role::getName)).collect(Collectors.toList());
        System.out.println(sortedCollect4);
        System.out.println(sortedCollect5);
        System.out.println("=========================================================================================");

        // 6、找到第一个出现的数据
        Optional<Role> first = list.stream().sorted(Comparator.comparing(Role::getAge)).findFirst();
        System.out.println(first.get());
        System.out.println("=========================================================================================");

        // 7、去重
        List<Integer> list1 = list.stream().map(o -> o.getAge()).distinct().collect(Collectors.toList());
        System.out.println(list1);
    }
}

class Role{

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}