jdk8新特性stream流式计算常用方法

我就是我 2023-01-13 06:28 206阅读 0赞

###### jdk8新特性stream流式计算 ######

Stream的特点：  
（1）不存储元素；  
（2）不改变源数据；  
（3）具有延迟执行，类似懒加载。

特此记录Stream的学习案例：

--------------------

先设计一个类：

package com.pipi.test;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    import org.junit.Test;
    
    import java.text.Collator;
    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Accessors(chain = true)  // 支持链式编程，例如：product.setId(1001).setName("辣条").setPrice(2.0f)
    class Product { 
        private Integer id;
        private String name;
        private Float price;
    }

实例化一个属性变量：

public class StreamTest { 
    
        private static List<Product> products = Arrays.asList(
                new Product(1001,"辣条",3.0f),
                new Product(1002,"薯片",4.5f),
                new Product(1003,"汤达人",5.5f),
                new Product(1004,"可乐",3.0f),
                new Product(1005,"凤爪",5.5f)
        );
        
    	// 这里写测试方法
    	@Test
    	public void m1() { 
    		// ...
    	}
    }

--------------------

1、sort() 排序

测试代码：

@Test
    public void m1() { 
        // 按照价格排序，默认升序
        List<Product> sort_asc = products.stream().sorted(Comparator.comparing(Product::getPrice)).collect(Collectors.toList());
        System.out.println(sort_asc);  // 顺序为：辣条，可乐，薯片，汤达人，凤爪
    
        // 降序排序
        List<Product> sort_desc = products.stream().sorted((o1, o2) -> { 
            return o2.getPrice().compareTo(o1.getPrice());
        }).collect(Collectors.toList());
        System.out.println(sort_desc);  // 顺序为：汤达人，凤爪，薯片，辣条，可乐
    
        // 也可以这样写
        List<Product> sort_desc1 = products.stream().sorted(Comparator.comparing(Product::getPrice).reversed()).collect(Collectors.toList());
        System.out.println(sort_desc1);  // 顺序为：汤达人，凤爪，薯片，辣条，可乐
    }

--------------------

2、sort() 拼音排序

测试代码：

@Test
    public void m2() { 
        // 中文字符串，按照拼音排序
        List<String> list = Arrays.asList("合肥市","北京市","深圳市","南昌市");
        List<String> sort1 = list.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
        System.out.println(sort1);  // [北京市, 合肥市, 南昌市, 深圳市]
    
        List<Product> sort2 = products.stream().sorted(Comparator.comparing(Product::getName)).collect(Collectors.toList());
        System.out.println(sort2);  // 凤爪fz，可乐kl，汤达人tdr，薯片sp，辣条lt 这是按照编码来排序，说明这种不能用
    
        List<Product> sort3 = products.stream().sorted(Comparator.comparing(Product::getName, Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
        System.out.println(sort3);  // 凤爪，可乐，辣条，薯片，汤达人
    }

--------------------

3、distinct() 去重，anyMatch() 匹配

测试代码：

@Test
    public void m3() { 
        List<Integer> list = Arrays.asList(8, 9, 7, 1, 6, 3, 3, 2, 2, 2, 7);
    
        List<Integer> dist = list.stream().distinct().collect(Collectors.toList());
        List<Integer> dist_asc = list.stream().distinct().sorted().collect(Collectors.toList());
        List<Integer> sort_desc = list.stream().distinct().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    
        System.out.println(dist);  // [8, 9, 7, 1, 6, 3, 2]
        System.out.println(dist_asc);  // [1, 2, 3, 6, 7, 8, 9]
        System.out.println(sort_desc);  // [9, 8, 7, 6, 3, 2, 1]
    
        // 匹配
        boolean match = list.stream().anyMatch(x -> { 
            return x == 3;
        });
        System.out.println(match);  // true
    }

去重的另一种场景：

// 根据类的全部属性去重
    	stuList = stuList.stream().distinct().collect(Collectors.toList());
    
    	// 根据类的某个属性去重
    	stuList = stuList.stream().collect(Collectors.collectingAndThen(
    	    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(StuVO::getStuId))), ArrayList::new)
    	);
    
    	// 根据类的多个属性去重
    	stuList = stuList.stream().collect(Collectors.collectingAndThen(
    	    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(ele -> ele.getStuId()+";"+ele.getName()))), ArrayList::new)
    	);

--------------------

4、filter() 过滤

测试代码：

@Test
    public void m4() { 
        // 找出单价大于4元的商品
        List<Product> filterList = products.stream().filter(p -> { 
            return p.getPrice() > 4.0f;
        }).collect(Collectors.toList());
        System.out.println(filterList);  // 薯片, 汤达人, 凤爪
    
        // 找出单价大于4的一个商品
        Product firstOne = products.stream().filter(p -> { 
            return p.getPrice() > 4.0f;
        }).findFirst().get();
        System.out.println(firstOne);  // Product(id=1002, name=薯片, price=4.5)
    
        // 找出单价大于4的任一个商品（一般用并行流，并行流适合元素较多的操作）
        Product anyone = products.parallelStream().filter(p -> { 
            return p.getPrice() > 4.0f;
        }).findAny().get();
        System.out.println(anyone);  // 当元素很多时，结果任意一个
    }

--------------------

5、map() 映射

测试代码：

@Test
    public void m5() { 
        // 映射即操作每个元素，例如：给每个元素价钱+1
        List<Product> mapList = products.stream().map(p -> { 
            return p.setPrice(p.getPrice() + 1);
        }).collect(Collectors.toList());
        System.out.println(mapList);  // 每个product的price都涨1
    
        // 获取每个产品的name，组成新的list
        List<String> names = products.stream().map(p -> { 
            return p.getName();
        }).collect(Collectors.toList());
        // 当然你也可以这样写，不过上面的更好理解
        // List<String> names = products.stream().map(Product::getName).collect(Collectors.toList());
        System.out.println(names);  // [辣条, 薯片, 汤达人, 可乐, 凤爪]
    }

--------------------

6、flatMap() 完全映射

测试代码：

@Test
    public void m6() { 
        // 每项产品价钱加1
        List<Product> list = products.stream().flatMap((p) -> { 
            p.setPrice(p.getPrice() + 1);
            return Stream.of(p);  // 每个元素经过操作，变成一个新的流，最终这些流合并成一个大的流
        }).collect(Collectors.toList());
    
        System.out.println(list);
    }

--------------------

7、min() 最小值，max() 最大值

测试代码：

@Test
    public void m7() { 
        // 获取产品中价钱最高的元素，即使有多个最高，只返回一个
        Product maxProduct = products.stream().max((p1, p2) -> { 
            return p1.getPrice().compareTo(p2.getPrice());
        }).get();
        System.out.println(maxProduct);  // Product(id=1003, name=汤达人, price=5.5)
    
        // 因为默认是升序，也可以不指定排序规则，直接指定比较的元素项
        Product maxProduct1 = products.stream().max(Comparator.comparing(Product::getPrice)).get();
        System.out.println(maxProduct1);  // Product(id=1003, name=汤达人, price=5.5)
    
        // 获取产品中价钱最低的元素
        Product minProduct = products.stream().min((p1, p2) -> { 
            return p1.getPrice().compareTo(p2.getPrice());
        }).get();
        System.out.println(minProduct);  // Product(id=1001, name=辣条, price=3.0)
    
        // 显然，你也可以这样
        Product minProduct1 = products.stream().min(Comparator.comparing(Product::getPrice)).get();
        System.out.println(minProduct1);  // Product(id=1001, name=辣条, price=3.0)
    }

--------------------

8、count() 统计

测试代码：

@Test
    public void m8() { 
        // 集合中价钱大于4的产品有几个
        // 显然我们需要先过滤，过滤后怎么操作都行，只要能获取个数
        int size1 = products.stream().filter(p -> { 
            return p.getPrice() > 4.0f;
        }).collect(Collectors.toList()).size();
        System.out.println(size1);  // 3
    
        long count = products.stream().filter(p -> p.getPrice() > 4.0f).count();
        System.out.println(count);  // 3
    }

--------------------

9、reduce() 归约

测试代码：

@Test
    public void m9() { 
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
        // 求元素总和
        Integer sum = list.stream().reduce((x, y) -> { 
            return x + y;
        }).get();
        System.out.println(sum);  // 55
    
        // 求元素中最大值
        Integer max = list.stream().reduce((x, y) -> { 
            return x >= y ? x : y;
        }).get();
        System.out.println(max);  // 10
    }

--------------------

另外：附上一篇大佬的博客，对Stream讲的非常好。  
[Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合][Java8 Stream_2_20]

--------------------

[Java8 Stream_2_20]: https://blog.csdn.net/mu_wind/article/details/109516995