java8之stream分析

喜欢ヅ旅行 2022-10-16 07:49 205阅读 0赞

### 写在前面 ###

我们在写sql语句的时候，可以使用诸如，where，group，order by，distinct等方式对数据进行处理后返回，这种处理方式我们叫做是声明式的数据处理，对于开发人员非常友好，不需要编写大量程序，提高了生产力，基于此，java在Java8中引入了stream相关的API，允许我们使用声明式的方式来进行数据处理。  
将数据抽象为`流`,然后流在管道中流转，可以进行诸如`过滤`,`排序`,`去重`，`映射`等处理，下面我们一起来看下。这个过程大概如下：

+--------------------+       +------+   +------+   +---+   +-------+
    | stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
    +--------------------+       +------+   +------+   +---+   +-------+

java代码可能如下：

List<Integer> transactionsIds = 
    widgets.stream()
                 .filter(b -> b.getColor() == RED)
                 .sorted((x,y) -> x.getWeight() - y.getWeight())
                 .mapToInt(Widget::getWeight)
                 .sum();

## 1：什么是Stream ##

是一种数据处理的抽象的载体，包括以下的信息：

*  元素

元素是某种特定的对象，比如List<String>集合，元素就是List集合中一个个String类型的对象。

*  数据源

流的来源，可以是集合，数组，I/O通道等。

*  聚合操作

类似sql语句中的操作，如filter，map，reduce，find，match，sorted等。

## 2：生成流 ##

可以通过`stream()`API来生成，也可以通过`parallelStream()`API来生成串行流。

## 3：foreach ##

通过`foreach`进行循环操作，替代普通的for循环方式，如下：

List<String> myList = new ArrayList<>();
     myList.add("111");
     myList.add("222");
     myList.add("333");
     myList.stream().forEach(System.out::println);

运行：

111
    222
    333

## 4：map ##

映射每一个元素，并将处理后的值作为对应位置的新值，

> 注意，原始集合不会被改变!!!

如下测试代码：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    // map()依次获取每个位置元素，并将处理后的值映射回原位置
    // distinct()去除重复的元素
    // collect(Collectors.toList())转成List集合
    List<Integer> collect = numbers.stream().map(i -> i * i).distinct().collect(Collectors.toList());
    System.out.println(collect);

运行：

[9, 4, 49, 25]

## 5：filter ##

依次处理每一个元素，如果是返回true，则保留该元素，如果是返回false，则删除该元素，如下获取空字符串的个数：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    long emptyStrCount = strings.stream().filter(string -> string.isEmpty()).count();
    System.out.println(emptyStrCount);

运行：

## 6：limit ##

获取指定数量元素的流，可以用于截取集合中的部分元素，如下获取5个随机数，并输出：

new Random().ints().limit(5).forEach(System.out::println);

运行：

-1217432247
    -248139245
    -1118452837
    1802294647
    -1433405876

## 7：sorted ##

对流进行排序，可以用于对集合进行排序，以下是对5个随机数进行排序后，并输出：

new Random().ints().limit(5).sorted().forEach(System.out::println);

运行：

-2007085613
    -1987186617
    -1970159904
    983905171
    2043273504

## 8：并行程序 ##

API是`parallelStream()`，和`stream()`相比，对于我们的唯一差别就是使用的API的名字换一下而已，以下是过滤集合中的空字符串，并获取过滤后的结果：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> collect = strings.parallelStream().filter(ele -> !ele.isEmpty()).collect(Collectors.toList());
    System.out.println(collect);

运行：

[abc, bc, efg, abcd, jkl]

## 9：Collectors ##

### 9.1：代码 ###

public class Person { 
        private String name;
        private int age;
    
        public Person() { }
    
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

public class Java8StreamTest { 
    
        public static void main(String[] args) { 
            /*** 将对象中name属性封装到list集合中开始 ***/
            List<Person> list1 = new ArrayList<>();
            Person list1Person1 = new Person("张三", 50);
            Person list1Person2 = new Person("李四", 62);
            Person list1Person3 = new Person("王五", 13);
            list1.add(list1Person1);
            list1.add(list1Person2);
            list1.add(list1Person3);
            List<String> list1collect = list1.stream().map(Person::getName).collect(Collectors.toList());
            System.out.println("将对象中name属性封装到list集合中，结果是：");
            System.out.println(list1collect);
            /*** 将对象中name属性封装到list集合中结束 ***/
            System.out.println();
    
            /*** 将对象中name属性封装到set集合中开始 ***/
            List<Person> list2 = new ArrayList<>();
            Person list2Person1 = new Person("张三1", 50);
            Person list2Person2 = new Person("李四1", 62);
            Person list2Person3 = new Person("王五1", 13);
            list2.add(list2Person1);
            list2.add(list2Person2);
            list2.add(list2Person3);
            Set<String> list2collect = list2.stream().map(Person::getName).collect(Collectors.toCollection(TreeSet::new));
            System.out.println("将对象中name属性封装到set集合中，结果是：");
            System.out.println(list2collect);
            /*** 将对象中name属性封装到set集合中结束 ***/
            System.out.println();
    
            /*** 将对象转成字符串，并将结果组合为按照,分割的字符串开始 ***/
            List<Person> list3 = new ArrayList<>();
            Person list3Person1 = new Person("张三2", 50);
            Person list3Person2 = new Person("李四2", 62);
            Person list3Person3 = new Person("王五2", 13);
            list3.add(list3Person1);
            list3.add(list3Person2);
            list3.add(list3Person3);
            String list3collect = list3.stream().map(Object::toString).collect(Collectors.joining(","));
            System.out.println("将对象转成字符串，并将结果组合为按照,分割的字符串，结果是：");
            System.out.println(list3collect);
            /*** 将对象转成字符串，并将结果组合为按照,分割的字符串结束 ***/
            System.out.println();
    
            /*** 获取age总和开始 ***/
            List<Person> list4 = new ArrayList<>();
            Person list4Person1 = new Person("张三3", 20);
            Person list4Person2 = new Person("李四3", 30);
            Person list4Person3 = new Person("王五3", 25);
            list4.add(list4Person1);
            list4.add(list4Person2);
            list4.add(list4Person3);
            Integer list4collect = list4.stream().collect(Collectors.summingInt(Person::getAge));
            System.out.println("获取age总和，结果是：");
            System.out.println(list4collect);
            /*** 获取age总和结束 ***/
            System.out.println();
    
            /*** 按照年龄分组开始 ***/
            List<Person> list5 = new ArrayList<>();
            Person list5Person1 = new Person("张三4", 20);
            Person list5Person2 = new Person("李四4", 30);
            Person list5Person3 = new Person("王五4", 20);
            Person list5Person4 = new Person("赵六4", 52);
            Person list5Person5 = new Person("李七4", 30);
            list5.add(list5Person1);
            list5.add(list5Person2);
            list5.add(list5Person3);
            list5.add(list5Person4);
            list5.add(list5Person5);
            Map<Integer, List<Person>> list5collect = list5.stream().collect(Collectors.groupingBy(Person::getAge));
            System.out.println("按照年龄分组，结果是：");
            System.out.println(list5collect);
            /*** 按照年龄分组结束 ***/
            System.out.println();
            /*** 获取年龄相同的总人数，开始 ***/
            List<Person> list6 = new ArrayList<>();
            Person list6Person1 = new Person("张三5", 20);
            Person list6Person2 = new Person("李四5", 30);
            Person list6Person3 = new Person("王五5", 20);
            Person list6Person4 = new Person("赵六5", 80);
            Person list6Person5 = new Person("李七5", 30);
            list6.add(list6Person1);
            list6.add(list6Person2);
            list6.add(list6Person3);
            list6.add(list6Person4);
            list6.add(list6Person5);
            // Collectors.groupingBy(Person::getAge, Collectors.counting()) 相当于sql语句 select count(*) from xxx group by age
            Map<Integer, Long> list6collect = list6.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));
            System.out.println("获取年龄相同的总人数，结果是：");
            System.out.println(list6collect);
            /*** 获取年龄相同的总人数，结束 ***/
            System.out.println();
    
            /*** 按照年龄范围分区，开始 ***/
            List<Person> list7 = new ArrayList<>();
            Person list7Person1 = new Person("张三6", 20);
            Person list7Person2 = new Person("李四6", 30);
            Person list7Person3 = new Person("王五6", 56);
            Person list7Person4 = new Person("赵六6", 80);
            Person list7Person5 = new Person("李七6", 30);
            list7.add(list7Person1);
            list7.add(list7Person2);
            list7.add(list7Person3);
            list7.add(list7Person4);
            list7.add(list7Person5);
            // 年龄大于40的一个分区，其余的另一个分区
            Map<Boolean, List<Person>> list7collect = list7.stream().collect(Collectors.partitioningBy(person -> person.getAge() > 40));
            System.out.println("按照年龄范围分区，结果是：");
            System.out.println(list7collect);
            /*** 按照年龄范围分区，结束 ***/
            System.out.println();
            /*** 将年龄统一增加8，开始 ***/
            List<Person> list8 = new ArrayList<>();
            Person list8Person1 = new Person("张三6", 20);
            Person list8Person2 = new Person("李四6", 30);
            Person list8Person3 = new Person("王五6", 56);
            Person list8Person4 = new Person("赵六6", 80);
            Person list8Person5 = new Person("李七6", 30);
            list8.add(list8Person1);
            list8.add(list8Person2);
            list8.add(list8Person3);
            list8.add(list8Person4);
            list8.add(list8Person5);
            List<Person> list8collect = list8.stream().map(person -> { 
                person.setAge(person.getAge() + 8);
                return person;
            }).collect(Collectors.toList());
            System.out.println("将年龄统一增加8，结果是：");
            System.out.println(list8collect);
            /*** 将年龄统一增加8，结束 ***/
        }
    }

### 9.2：运行 ###

将对象中name属性封装到list集合中，结果是：
    [张三, 李四, 王五]
    
    将对象中name属性封装到set集合中，结果是：
    [张三1, 李四1, 王五1]
    
    将对象转成字符串，并将结果组合为按照,分割的字符串，结果是：
    Person{name='张三2', age=50},Person{name='李四2', age=62},Person{name='王五2', age=13}
    
    获取age总和，结果是：
    75
    
    按照年龄分组，结果是：
    {52=[Person{name='赵六4', age=52}], 20=[Person{name='张三4', age=20}, Person{name='王五4', age=20}], 30=[Person{name='李四4', age=30}, Person{name='李七4', age=30}]}
    
    获取年龄相同的总人数，结果是：
    {80=1, 20=2, 30=2}
    
    按照年龄范围分区，结果是：
    {false=[Person{name='张三6', age=20}, Person{name='李四6', age=30}, Person{name='李七6', age=30}], true=[Person{name='王五6', age=56}, Person{name='赵六6', age=80}]}
    
    将年龄统一增加8，结果是：
    [Person{name='张三6', age=28}, Person{name='李四6', age=38}, Person{name='王五6', age=64}, Person{name='赵六6', age=88}, Person{name='李七6', age=38}]

## 10：统计 ##

获取最大值，最小值，平均值，等，如下：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    
    IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
    
    System.out.println("列表中最大的数 : " + stats.getMax());
    System.out.println("列表中最小的数 : " + stats.getMin());
    System.out.println("所有数之和 : " + stats.getSum());
    System.out.println("平均数 : " + stats.getAverage());

运行：

列表中最大的数 : 7
    列表中最小的数 : 2
    所有数之和 : 25
    平均数 : 3.5714285714285716

## 11：flatMap ##

用于处理集合中包含集合的情况，一般用于进行跨集合的数据的合并，测试代码如下：

public class Klass { 
        private int field;
    
        public Klass(int field) { 
            this.field = field;
        }
    
        @Override
        public String toString() { 
            return "field=" + field;
        }
    }
    
    
    public class KlassGroup { 
        private List<Klass> group = new ArrayList<>();
    
        public KlassGroup(Klass... objList) { 
            for (Klass item : objList) { 
                this.group.add(item);
            }
        }
    
        public List<Klass> getKlassList() { 
            return group;
        }
    }
    
    List<KlassGroup> groupList = Arrays.asList(
           new KlassGroup(new Klass(1), new Klass(2), new Klass(3)),
           new KlassGroup(new Klass(4), new Klass(5), new Klass(6)),
           new KlassGroup(new Klass(7), new Klass(8), new Klass(9)),
           new KlassGroup(new Klass(10))
    );
    // 希望将KlassGroup中的Klass集合合并到一个大的集合中，可以使用flatMap，作用是将所有的stream信息进行合并
    // klassGroup -> klassGroup.getKlassList().stream() 中的klassGroup.getKlassList().stream()是将集合转为stream，flatMap会合并这些stream到一个集合中
    List<Klass> collect = groupList.stream().flatMap(klassGroup -> klassGroup.getKlassList().stream()).collect(Collectors.toList());
    System.out.println(collect);

运行：

[field=1, field=2, field=3, field=4, field=5, field=6, field=7, field=8, field=9, field=10]

## 参考列表 ##

https://www.runoob.com/java/java8-streams.html  
java.util.stream.Collectors注释  
https://zhuanlan.zhihu.com/p/103686124