Stream流在手，天下我有

搬运工007

已于 2024-06-11 14:37:31 修改

阅读量788

点赞数 7

文章标签： java

于 2024-06-11 14:34:47 首次发布

本文链接：https://blog.csdn.net/qq_42947952/article/details/139598489

版权

聊聊工作中常用的Stream流表达式

前言

日常开发中，我们很多时候需要用到Java 8的Lambda表达式，它允许把函数作为一个方法的参数，让我们的代码更优雅、更简洁。所以整理了一波工作中，我常用的，有哪些Lambda表达式，它又是如何方便我们组装、处理数据的呢，看完一定会有帮助的。

1. list转map

工作中，我们经常遇到list转map的案例。Collectors.toMap就可以把一个list数组转成一个Map。代码如下：

public class TestLambda {

    public static void main(String[] args) {

        List<UserInfo> userInfoList = new ArrayList<>();
        userInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18));
        userInfoList.add(new UserInfo(2L, "程序员田螺", 27));
        userInfoList.add(new UserInfo(2L, "捡瓶子的小男孩", 26));

        /**
         *  list 转 map
         *  使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1, k2) -> k1
         *  (k1, k2) -> k1 表示，如果有重复的key,则保留第一个，舍弃第二个
         */
        Map<Long, UserInfo> userInfoMap = userInfoList.stream().collect(Collectors.toMap(UserInfo::getUserId, userInfo -> userInfo, (k1, k2) -> k1));
        userInfoMap.values().forEach(a->System.out.println(a.getUserName()));
    }
}

//运行结果
捡田螺的小男孩
程序员田螺

类似的，还有Collectors.toList()、Collectors.toSet()，表示把对应的流转化为list或者Set。

2. filter()过滤

从数组集合中，过滤掉不符合条件的元素，留下符合条件的元素。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18));
userInfoList.add(new UserInfo(2L, "程序员田螺", 27));
userInfoList.add(new UserInfo(3L, "捡瓶子的小男孩", 26));
        
/**
 * filter 过滤，留下超过18岁的用户
 */
List<UserInfo> userInfoResultList = userInfoList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
userInfoResultList.forEach(a -> System.out.println(a.getUserName()));
        
//运行结果
程序员田螺
捡瓶子的小男孩

3. foreach遍历

foreach 遍历list，遍历map，真的很丝滑。

/**
 * forEach 遍历集合List列表
 */
List<String> userNameList = Arrays.asList("捡田螺的小男孩", "程序员田螺", "捡瓶子的小男孩");
userNameList.forEach(System.out::println);
 
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("公众号", "捡田螺的小男孩");
hashMap.put("职业", "程序员田螺");
hashMap.put("昵称", "捡瓶子的小男孩");
/**
 *  forEach 遍历集合Map
 */
hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v));

//运行结果
捡田螺的小男孩
程序员田螺
捡瓶子的小男孩
职业: 程序员田螺
公众号: 捡田螺的小男孩
昵称: 捡瓶子的小男孩

4. groupingBy分组

提到分组，相信大家都会想起SQL的group by。我们经常需要一个List做分组操作。比如，按城市分组用户。在Java8之前，是这么实现的：

List<UserInfo> originUserInfoList = new ArrayList<>();
originUserInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18,"深圳"));

originUserInfoList.add(new UserInfo(3L, "捡瓶子的小男孩", 26,"湛江"));
originUserInfoList.add(new UserInfo(2L, "程序员田螺", 27,"深圳"));
Map<String, List<UserInfo>> result = new HashMap<>();
for (UserInfo userInfo : originUserInfoList) {
  String city = userInfo.getCity();
  List<UserInfo> userInfos = result.get(city);
  if (userInfos == null) {
      userInfos = new ArrayList<>();
      result.put(city, userInfos);
    }
  userInfos.add(userInfo);
}

而使用Java8的groupingBy分组器，清爽无比:

   // 注意：分组之后如果根据key获取分组数据,未命中则返回的是Null值，防止空指针异常
   // result 可能未Null
Map<String, List<UserInfo>> result = originUserInfoList.stream()
.collect(Collectors.groupingBy(UserInfo::getCity));

注意：

分组之后可能某个组别的数据是null,当再次使用result.get(“呼和浩特”).stream。。。。的语法会报空指针异常。

5. sorted+Comparator 排序

工作中，排序的需求比较多，使用sorted+Comparator排序，真的很香。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18));
userInfoList.add(new UserInfo(3L, "捡瓶子的小男孩", 26));
userInfoList.add(new UserInfo(2L, "程序员田螺", 27));

/**
 *  sorted + Comparator.comparing 排序列表，
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

System.out.println("开始降序排序");

/**
 * 如果想降序排序，则可以使用加reversed()
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

//运行结果
UserInfo{userId=1, userName='捡田螺的小男孩', age=18}
UserInfo{userId=3, userName='捡瓶子的小男孩', age=26}
UserInfo{userId=2, userName='程序员田螺', age=27}
开始降序排序
UserInfo{userId=2, userName='程序员田螺', age=27}
UserInfo{userId=3, userName='捡瓶子的小男孩', age=26}
UserInfo{userId=1, userName='捡田螺的小男孩', age=18}


// list<Integer>升序排序

compareTo方法内部调用compare方法，小于比对,小于返回-1 等于返回0 大于返回1

// 默认排序
Collections.sort(list);

list.sort(Integer::compareTo);

List<Integer> collect = list.stream().sorted((a, b) -> a.compareTo(b)).collect(Collectors.toList());

// 降序排序

list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

// 自定义降序排序

        list.sort(new Comparator<Integer>() {

            @Override

            public int compare(Integer o1, Integer o2) {

                return o2-o1;

            }

        });

// 顺序反转

Collections.reverse(list);

6.distinct去重

distinct可以去除重复的元素:

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
List<String> temp = list.stream().distinct().collect(Collectors.toList());
temp.forEach(System.out::println);

7. findFirst 返回第一个

findFirst 很多业务场景，我们只需要返回集合的第一个元素即可：

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
list.stream().findFirst().ifPresent(System.out::println);

8. anyMatch是否至少匹配一个元素

anyMatch 检查流是否包含至少一个满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.anyMatch(s -> s.contains("C"));
System.out.println(match);
//输出
true

9. allMatch 匹配所有元素

allMatch 检查流是否所有都满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.allMatch(s -> s.contains("C"));
System.out.println(match);
//输出
false

10. map转换

map方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性，demo如下：

List<String> list = Arrays.asList("jay", "tianluo");
//转化为大写
List<String> upperCaselist = list.stream().map(String::toUpperCase).collect(Collectors.toList());
upperCaselist.forEach(System.out::println);

11. Reduce

Reduce可以合并流的元素，并生成一个值

            // 盈亏
            // 处理金额中的,
            List<String> phaseList = tradeStatisticsFormDOS.stream().filter(obj -> StringUtils.hasLength(obj.getPhase())).map(obj -> obj.getPhase().replaceAll(",", "")).collect(Collectors.toList());
            BigDecimal phaseSum = phaseList.stream().map(BigDecimal::new).reduce(BigDecimal.ZERO, BigDecimal::add);

12. peek 打印个日志

peek()方法是一个中间Stream操作，有时候我们可以使用peek来打印日志。

List<String> result = Stream.of("程序员田螺", "捡田螺的小男孩", "捡瓶子的小男孩")
            .filter(a -> a.contains("田螺"))
            .peek(a -> System.out.println("关注公众号:" + a)).collect(Collectors.toList());
System.out.println(result);
//运行结果
关注公众号:程序员田螺
关注公众号:捡田螺的小男孩
[程序员田螺, 捡田螺的小男孩]

13. Max，Min最大最小

使用lambda流求最大，最小值，非常方便。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18));
userInfoList.add(new UserInfo(3L, "捡瓶子的小男孩", 26));
userInfoList.add(new UserInfo(2L, "程序员田螺", 27));

Optional<UserInfo> maxAgeUserInfoOpt = userInfoList.stream().max(Comparator.comparing(UserInfo::getAge));
maxAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("max age user:" + userInfo));

Optional<UserInfo> minAgeUserInfoOpt = userInfoList.stream().min(Comparator.comparing(UserInfo::getAge));
minAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("min age user:" + userInfo));

//运行结果
max age user:UserInfo{userId=2, userName='程序员田螺', age=27}
min age user:UserInfo{userId=1, userName='捡田螺的小男孩', age=18}

14. count统计

一般count()表示获取流数据元素总数。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "捡田螺的小男孩", 18));
userInfoList.add(new UserInfo(3L, "捡瓶子的小男孩", 26));
userInfoList.add(new UserInfo(2L, "程序员田螺", 27));

long count = userInfoList.stream().filter(user -> user.getAge() > 18).count();
System.out.println("大于18岁的用户:" + count);
//输出
大于18岁的用户:2

15.map重新收集某字段信息

抽取集合中某个字段信息，以符号,隔开转成字符串

String s= list.stream().map(p->p.get("name")).collect(Collectors.joining(","));

16.集合中某字段是否重复校验

List<String> distinctList = fieldConfigVOList.stream().map(FieldConfigVO::getFieldName).distinct().collect(Collectors.toList());

boolean flag = distinctList.size() != fieldConfigVOList.size();

     if (flag) {

            result.setErrorJson("输入的文件字段名称不可重复,请检查", result);

            return true;

      }

17.多字段去重

java8去重(根据年级和专业,当年级和专业都相同的情况下看做是重复数据):

List<ClassEntity> distinctClass = classEntities.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getProfessionId() + ";" + o.getGrade()))), ArrayList::new));

通过hashSet去重(如将classNames去重):该种去重是bean完全相同的时候算重复数据:

List<String> classNameList = new ArrayList(new HashSet(classNames));

18.list类型转换数据复制

private List<FileSendDetailDto> getWarnPhone(Page<FileSendDetailVO> all, String businessTypes) throws ParseException {

        // list复制

        List<FileSendDetailDto> resultList = all.getContent().stream().map(fileSendDetailVO -> {

            FileSendDetailDto fileSendDetailDto = new FileSendDetailDto();

            BeanUtils.copyProperties(fileSendDetailVO, fileSendDetailDto);

            return fileSendDetailDto;

        }).collect(Collectors.toList());

19. 常用函数式接口

其实lambda离不开函数式接口，我们来看下JDK8常用的几个函数式接口：

•

Function<T, R>（转换型）: 接受一个输入参数，返回一个结果
•

Consumer<T> （消费型）: 接收一个输入参数，并且无返回操作
•

Predicate<T> （判断型）: 接收一个输入参数，并且返回布尔值结果
•

Supplier<T> （供给型）: 无参数，返回结果

Function<T, R> 是一个功能转换型的接口，可以把将一种类型的数据转化为另外一种类型的数据

    private void testFunction() {
        //获取每个字符串的长度，并且返回
        Function<String, Integer> function = String::length;
        Stream<String> stream = Stream.of("程序员田螺", "捡田螺的小男孩", "捡瓶子的小男孩");
        Stream<Integer> resultStream = stream.map(function);
        resultStream.forEach(System.out::println);
    }

Consumer<T>是一个消费性接口，通过传入参数，并且无返回的操作

   private void testComsumer() {
        //获取每个字符串的长度，并且返回
        Consumer<String> comsumer = System.out::println;
        Stream<String> stream = Stream.of("程序员田螺", "捡田螺的小男孩", "捡瓶子的小男孩");
        stream.forEach(comsumer);
    }

Predicate<T>是一个判断型接口,并且返回布尔值结果.

    private void testPredicate() {
        //获取每个字符串的长度，并且返回
        Predicate<Integer> predicate = a -> a > 18;
        UserInfo userInfo = new UserInfo(2L, "程序员田螺", 27);
        System.out.println(predicate.test(userInfo.getAge()));
    }

Supplier<T>是一个供给型接口,无参数，有返回结果。

    private void testSupplier() {
        Supplier<Integer> supplier = () -> Integer.valueOf("666");
        System.out.println(supplier.get());
    }

这几个函数在日常开发中，也是可以灵活应用的，比如我们DAO操作完数据库，是会有个result的整型结果返回。我们就可以用Supplier<T>来统一判断是否操作成功。如下：

    private void saveDb(Supplier<Integer> supplier) {
        if (supplier.get() > 0) {
            System.out.println("插入数据库成功");
        }else{
            System.out.println("插入数据库失败");
        }
    }
    
    @Test
    public void add() throws Exception {
        Course course=new Course();
        course.setCname("java");
        course.setUserId(100L);
        course.setCstatus("Normal");
        saveDb(() -> courseMapper.insert(course));
    }

20.一个集合根据另一个集合去重

    public static void main(String[] args) {
        List<String> listC = new ArrayList<>();
        listC.add("1");
        listC.add("2");
        listC.add("3");
        listC.add("4");
        List<String> listD = new ArrayList<>();
        listD.add("1");
        listD.add("2");
        listD.add("3");

        // 去重
        listC.removeIf(s -> listD.stream().anyMatch(s::equals));

        System.out.println(JsonUtils.toJson(listC));
    }

结果：
[
  "4"
]

21.一个list去重

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateElementsExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(3);

        Set<Integer> duplicates = new HashSet<>();

        numbers.stream()  // 转换成流
                .filter(n -> !duplicates.add(n))  // 如果添加到集合失败（即元素已存在），则说明是重复元素
                .forEach(System.out::println);  // 打印重复元素
    }
}

在上述示例中，我们使用了一个 HashSet 来存储已经出现过的元素。通过把元素添加到 HashSet 中，我们可以判断是否添加成功来确定是否为重复元素。

numbers.stream().filter(n -> !duplicates.add(n)) 这一行代码使用了 Lambda 表达式来筛选重复元素。如果元素已经存在于 HashSet 中，add() 方法会返回 false，否则返回 true。通过 !duplicates.add(n)，我们可以得到返回值为 true 的重复元素。最后，使用 forEach() 方法来打印重复元素。

22.分组计算

summingDouble：比如汇总资金

summingInt：比如汇总年龄

summingLong：比如数据汇总

// 分组，直接对某个字段求和（Double存在精度丢失问题）

  // 各客户的所有可用资金合计
            Map<String, Double> totalSysFundsAvailable = resultList.stream().collect(Collectors.groupingBy(
                    r -> r.getInvestor(), Collectors.summingDouble(e -> Double.valueOf(StringUtils.isEmpty(e.getSysFundsAvailable())?"0.00":e.getSysFundsAvailable()))
            ));

// 先分组，再收集成list，然后再map,再对字段汇总求和

  
// 各客户的所有可用资金合计 getAge使用int类型
            Map<String, BigDecimal> totalSysFundsAvailable = resultList.stream().collect(Collectors.groupingBy(
                    r -> r.getInvestor(), Collectors.collectingAndThen(
                        Collectors.toList(),x->x.stream().map(
                        Student::getAge().reduce(BigDecimal.ZERO,BigDecimal::add)
                        )
            ));

在Java中，Double 类型确实存在精度问题，因为它是基于 IEEE 754 标准的浮点数。这意味着 Double 类型不能精确表示某些十进制小数，特别是那些无法用二进制精确表示的小数。

在你提供的代码片段中，使用 Double 类型来存储和计算资金总额，可能会遇到精度问题，尤其是在以下情况下：

当进行大量累加操作时，累积的舍入误差可能会变得显著。
当处理非常小或非常大的数值时，精度问题可能更加明显。

为了减少精度问题，可以考虑以下几种方法：

使用 BigDecimal：BigDecimal 类型提供了更高精度的十进制数运算，适合用于金融计算。你可以将 Double 替换为 BigDecimal，并相应地修改 Collectors.summingDouble 为 Collectors.reducing 或 Collectors.summing，并提供 BigDecimal.ZERO 作为初始值。
舍入规则：在最终输出或显示之前，可以对 Double 值应用舍入规则，例如使用 BigDecimal 的 setScale 方法来指定小数点后的位数。
避免不必要的转换：如果可能，尽量避免在计算过程中将 String 转换为 Double，特别是当字符串表示的数字可以精确转换为 BigDecimal 时。
使用整数：如果资金的单位是最小的货币单位（如分、厘等），可以考虑使用 long 或 BigInteger 类型来避免精度问题。

下面是一个使用 BigDecimal 替代 Double 的示例代码：

Map<String, BigDecimal> totalSysFundsAvailable = resultList.stream().collect(Collectors.groupingBy(
    r -> r.getInvestor(),
    Collectors.reducing(
        BigDecimal.ZERO,
        e -> new BigDecimal(StringUtils.isEmpty(e.getSysFundsAvailable()) ? "0.00" : e.getSysFundsAvailable()),
        BigDecimal::add)
));

请注意，这里假设 getSysFundsAvailable 返回的是 String 类型。如果它返回的是 Double，则需要相应地调整代码。此外，使用 BigDecimal 时，你可能需要处理 NullPointerException，因为如果 getSysFundsAvailable() 返回 null，StringUtils.isEmpty 会返回 true，并且 new BigDecimal(null) 会抛出异常。

23.toMap

toMap在代码中可以实现跟分组一样的效果，来看看实际运用场景

  //6、 资金对账表-按照投资者-资金对账表组装数据
            Map<String,AssetCheck> assetCheckMap = acList.stream().collect(Collectors.toMap(
                    e->e.getInvestorId(), AssetCheck->AssetCheck
            ));
            //8、质押更新
            Map<String,List<PledgeRenewal>> prMap = prList.stream().collect(Collectors.groupingBy(
                    e->e.getInvestorId()
            ));
            List<String> investors = masterConfigList.stream().map(c -> {
                return c.getInvestor();
            }).distinct().collect(Collectors.toList());
            // 主系统结果
            List<MultiSysMasterResult> resultList = new ArrayList<>();
            //遍历客户
            for(MultiSysMasterConfig config:masterConfigList){
                // 根据投资者获取资金对账表
                AssetCheck assetCheck = assetCheckMap.get(config.getInvestor());
            ......
            }