java 8 lambda表达式list操作分组、排序、去重、过滤、求和、最值

最新推荐文章于 2024-01-02 23:09:37 发布

原创最新推荐文章于 2024-01-02 23:09:37 发布

· 2.3k 阅读

6 ·

版权

文章标签：

#lambda

java8 同时被 2 个专栏收录

6 篇文章

订阅专栏

lambda

1 篇文章

订阅专栏

java8的lambda表达式提供了一些方便list操作的方法，主要涵盖分组、过滤、求和、最值、排序、去重、截取、包含等。跟之前的传统写法对比，能少写不少代码。

package com.vvvtimes.vo;
 
import java.math.BigDecimal;
import java.util.Date;
 
public class User {
 
    private Long id;
 
    //姓名
    private String name;
    //年龄
    private int age;
    //工号
    private String jobNumber;
    //性别
    private String sex;
    //入职日期
    private Date entryDate;
    //家庭成员数量
    private BigDecimal familyMemberQuantity;
 
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    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;
    }
    public String getJobNumber() {
        return jobNumber;
    }
    public void setJobNumber(String jobNumber) {
        this.jobNumber = jobNumber;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getEntryDate() {
        return entryDate;
    }
    public void setEntryDate(Date entryDate) {
        this.entryDate = entryDate;
    }
    public BigDecimal getFamilyMemberQuantity() {
        return familyMemberQuantity;
    }
    public void setFamilyMemberQuantity(BigDecimal familyMemberQuantity) {
        this.familyMemberQuantity = familyMemberQuantity;
    }
}

分组
通过groupingBy可以分组指定字段

        //分组
        Map<String, List<User>> groupBySex = userList.stream().collect(Collectors.groupingBy(User::getSex));
        //遍历分组
        for (Map.Entry<String, List<User>> entryUser : groupBySex.entrySet()) {
            String key = entryUser.getKey();
            List<User> entryUserList = entryUser.getValue();

分组求数量:根据某一个字段分组后求这个字段出现的数量

Map<Integer, Long> map = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.counting()));

分组求BigDecimal的和

Map<Long, BigDecimal> map = costEntities.stream().collect(Collectors.groupingBy(Model::getProjectId
                    , Collectors.collectingAndThen(Collectors.toList(), m ->
                            m.stream().map(Model::getCost).reduce(BigDecimal.ZERO, BigDecimalUtil::sum))));
public class BigDecimalUtil {
    public static BigDecimal sum(BigDecimal ...in){
        BigDecimal result = BigDecimal.ZERO;
        for (int i = 0; i < in.length; i++){
            result = result.add(ifNullSet0(in[i]));
        }
        return result;
    }
}

多个值求和

Map<String, Model> collect =
                list.parallelStream().collect(Collectors.groupingBy(Model::getMobile
                        , Collectors.collectingAndThen(Collectors.toList(), m -> {
                            BigDecimal amount = m.parallelStream().map(Model::getAmount).reduce(BigDecimal.ZERO,BigDecimal::add);
                            BigDecimal winAmount = m.parallelStream().map(Model::getWinAmount).reduce(BigDecimal.ZERO,BigDecimal::add);
                            Integer winCount = m.parallelStream().mapToInt(Model::getWinCount).sum();
                            return new Model(amount, winAmount, winCount);
                        })));

也可以分组后在次分组,先以name分组在以age分组

Map<String, Map<Integer, Long>> map = list.stream().collect(Collectors.groupingBy(User::getUserName,Collectors.groupingBy(User::getAge,Collectors.counting())));

JSON格式的分组

Map<Object, List<Object>> groupBySiteType = siteArr.stream()
                .collect(Collectors.groupingBy(item -> JSON.parseObject(item.toString()).get("site_type")));

过滤
通过filter方法可以过滤某些条件

        //过滤
        //排除掉工号为201901的用户
        List<User> userCommonList = userList.stream().filter(a -> !a.getJobNumber().equals("201901")).collect(Collectors.toList());

求和
分基本类型和大数类型求和，基本类型先mapToInt，然后调用sum方法，大数类型使用reduce调用BigDecimal::add方法

        //求和
        //基本类型
        int sumAge = userList.stream().mapToInt(User::getAge).sum();
        //BigDecimal求和
        BigDecimal totalQuantity = userList.stream().map(User::getFamilyMemberQuantity).reduce(BigDecimal.ZERO, BigDecimal::add);

上面的求和不能过滤bigDecimal对象为null的情况，可能会报空指针，这种情况，我们可以用filter方法过滤，或者重写求和方法

重写求和方法

package com.vvvtimes.util;
 
import java.math.BigDecimal;
 
public class BigDecimalUtils {
 
    public static BigDecimal ifNullSet0(BigDecimal in) {
        if (in != null) {
            return in;
        }
        return BigDecimal.ZERO;
    }
 
    public static BigDecimal sum(BigDecimal ...in){
        BigDecimal result = BigDecimal.ZERO;
        for (int i = 0; i < in.length; i++){
            result = result.add(ifNullSet0(in[i]));
        }
        return result;
    }
}

使用重写的方法

BigDecimal totalQuantity2 = userList.stream().map(User::getFamilyMemberQuantity).reduce(BigDecimal.ZERO, BigDecimalUtils::sum);

判断对象空

stream.filter(x -> x!=null)

stream.filter(Objects::nonNull)

判断字段空

stream.filter(x -> x.getDateTime()!=null)

最值
求最小与最大，使用min max方法

        //最小
        Date minEntryDate = userList.stream().map(User::getEntryDate).min(Date::compareTo).get();
        //最大
        Date maxEntryDate = userList.stream().map(User::getEntryDate).max(Date::compareTo).get();

List 转map

         /**
         * List -> Map
         * 需要注意的是：
         * toMap 如果集合对象有重复的key，会报错Duplicate key ....
         *  user1,user2的id都为1。
         *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
         */
        Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getId, a -> a,(k1,k2)->k1));
        
		Map<Long, String> categoryMap = list.stream().collect(Collectors.toMap(User::getId,User::getName,(entity1,entity2) -> entity1));

排序
可通过Sort对单字段多字段排序

        //排序
        //单字段正序排序，根据id排序
        userList.sort(Comparator.comparing(User::getId));
        //单字段倒序排序，根据id排序
        userList.sort(Comparator.comparing(User::getId).reversed());
        //多字段排序，根据id，年龄排序
        userList.sort(Comparator.comparing(User::getId).thenComparing(User::getAge));

去重
可通过distinct方法进行去重

        //去重
        List<Long> idList = new ArrayList<Long>();
        idList.add(1L);
        idList.add(1L);
        idList.add(2L);
        List<Long> distinctIdList = idList.stream().distinct().collect(Collectors.toList());

获取list某个字段组装新list

        //获取list对象的某个字段组装成新list
        List<Long> userIdList = userList.stream().map(a -> a.getId()).collect(Collectors.toList());

批量设置list列表字段为同一个值

addList.stream().forEach(a -> a.setDelFlag("0"));

10.match比较,流中元素进行比较

//是否所有人的年龄大于50
boolean b = objects.stream().allMatch(a -> a.getAge() > 50);
//是否有一个人的年龄大于50
boolean b = objects.stream().anyMatch(a -> a.getAge() > 50);
//是否所有人的年龄都不大于50
boolean b = objects.stream().noneMatch(a -> a.getAge() > 50);

11.skip和limit的使用
skip跳过list中的几个元素，
limit截取list中的几个元素

//两个可以配合使用,先跳过,然后截取,也可以先截取然后跳过
List<User> users = objects.stream().skip(5)limit(2);

12.json格式处理方式

JSONArray jsonArray = JSONArray.parseArray("[{\"1\": {\"name\":\"maple\",\"sex\":\"man\",\"childrens\":[{\"name\":\"草根\",\"sex\":\"man\",\"date\":\"2018-01-01\"},{\"name\":\"merry\",\"sex\":\"woman\",\"date\":\"2017-01-01\"},{\"name\":\"liming\",\"sex\":\"woman\",\"date\":\"2016-01-01\"}]}}]");
jsonArray = jsonArray.stream().map(obj -> {
JSONObject returnObj = new JSONObject();
    JSONObject jsonObj = (JSONObject)obj;
    jsonObj.forEach((key,val) -> {
        returnObj.put(key,((JSONObject)val).getJSONArray("childrens"));
    });
    return returnObj;
}).collect(Collectors.toCollection(JSONArray::new));
System.out.println(jsonArray);
/**
* out :
*      [{"1":[{"date":"2018-01-01","sex":"man","name":"草根"},{"date":"2017-01-01","sex":"woman","name":"merry"},{"date":"2016-01-01","sex":"woman","name":"liming"}]}]
**/