JAVA8的Stream操作

分组之后继续操作

示例1-转List

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 公众号：干货食堂
 */
public class Test {

    public static void main(String[] args) {
        List<Cpv> init = init();
        List<Map<String, Object>> hit_val_param = init.stream()
                .collect(Collectors.groupingBy(
                        Cpv::getProp,
                        Collectors.mapping(Cpv::getVal, Collectors.toList())
                ))
                .entrySet().stream()
                .map(e -> {
                    Map<String, Object> map = new LinkedHashMap<>();
                    map.put("prop", e.getKey());
                    map.put("valList", e.getValue());
                    return map;
                })
                .collect(Collectors.toList());
        System.out.println(hit_val_param);
    }

    /**
     * 初始化数据
     */
    public static List<Cpv> init() {
        List<Cpv> userList = new ArrayList<Cpv>();
        userList.add(new Cpv("颜色","红"));
        userList.add(new Cpv("颜色","蓝"));
        userList.add(new Cpv("颜色","绿"));
        userList.add(new Cpv("功能","防水"));
        userList.add(new Cpv("材质","木材"));
        return userList;
    }


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Cpv {
        String prop;
        String val;
    }
}

结果：

[
  {
    "prop": "功能",
    "valList": ["防水"]
  },
  {
    "prop": "颜色",
    "valList": ["红", "蓝", "绿"]
  },
  {
    "prop": "材质",
    "valList": ["木材"]
  }
]

示例2-转Map

import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 公众号：干货食堂
 */
public class Test {


    public static void main(String[] args) {
        //需求，有一个sku集合，需要用java8转成Map<String,Integer> 的形式，
        //逻辑是，一个itemId对应多个skuId, Map的key是 itemId，val逻辑是如果itemId下的sku集合中的flag字段有一个为1那么就是1
        List<Sku> skuList = init();
        // 方案1：使用分组+anyMatch（推荐，可读性好）
        Map<String, Integer> resultMap = skuList.stream()
                .collect(Collectors.groupingBy(
                        Sku::getItemId,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                list -> list.stream().anyMatch(sku -> sku.getFlag() == 1) ? 1 : 0
                        )
                ));
        System.out.println(JSON.toJSON(resultMap));
    }

    /**
     * 初始化数据
     */
    public static List<Sku> init() {
        List<Sku> userList = new ArrayList<Sku>();
        userList.add(new Sku("1","100",0));
        userList.add(new Sku("1","101",1));
        userList.add(new Sku("1","102",0));
        userList.add(new Sku("2","103",0));
        userList.add(new Sku("2","104",0));
        return userList;
    }


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Sku {
        String itemId;
        String skuId;
        Integer flag;
    }
}

结果：

{
  "1": 1,
  "2": 0
}

优雅的获取多层对象嵌套值

对于层次很深的对象结构，每次都需要判空处理，很麻烦，我们可以借助java8的Optional来简化操作

import com.alibaba.fastjson.JSON;
import lombok.Builder;
import lombok.Data;

import java.util.Optional;

/**
 * 公众号：干货食堂
 */
public class Test {

    public static void main(String[] args) {
        Person person = init();
        String name = Optional.ofNullable(person.getProvince())
                .map(Province::getCity)
                .map(City::getXian)
                .orElse(null);
        System.out.println(JSON.toJSON(name));
    }

    /**
     * 初始化数据
     */
    public static Person init() {
        City city = City.builder().xian("公众号：干货食堂").build();
        Province province = Province.builder().city(city).build();
        return Person.builder().province(province).build();
    }

    @Data @Builder
    public static class Person {
        private Province province;
    }
    @Data @Builder
    public static class Province {
        private City city;
    }
    @Data @Builder
    public static class City {
        private String  xian;
    }
}

stream过滤

1. 第一种

Stream.of(
        categoryDO.getCategory1Name(),
        categoryDO.getCategory2Name(),
        categoryDO.getCategory3Name()
        )
.filter(StringUtils::isNotBlank)
.collect(Collectors.toList());

分组

三级分组

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupingExample {
    public Map<String, Map<String, Map<String, List<EntityCpvDO>>>> groupByThreeFields(List<EntityCpvDO> list) {
        return list.stream().collect(
            Collectors.groupingBy(
                EntityCpvDO::getField1,          // 第一级分组key
                Collectors.groupingBy(
                    EntityCpvDO::getField2,      // 第二级分组key
                    Collectors.groupingBy(
                        EntityCpvDO::getField3   // 第三级分组key
                    )
                )
            )
        );
    }
}

// 实体类示例
class EntityCpvDO {
    private String field1;
    private String field2;
    private String field3;
}

map排序

key自定义排序

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

public class MapSorter {
    public static Map<String, String> sortMapByReference(
            Map<String, String> inputMap,
            Map<String, Integer> referenceOrder) {
        
        return inputMap.entrySet().stream()
                .sorted(Comparator.comparing(entry -> 
                    referenceOrder.getOrDefault(entry.getKey(), Integer.MAX_VALUE)
                ))
                .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (a, b) -> a,
                    LinkedHashMap::new
                ));
    }

    public static void main(String[] args) {
        // 测试数据
        Map<String, String> inputMap = new HashMap<String, String>() {{
            put("b", "谢谢小星星");
            put("c", "ssss");
            put("a", "ccccc");
            put("d", "额外键");  // 测试参考顺序中不存在的键
        }};
        
        Map<String, Integer> referenceOrder = new HashMap<String, Integer>() {{
            put("a", 1);
            put("b", 2);
            put("c", 3);
        }};
        
        // 执行排序
        Map<String, String> sortedMap = sortMapByReference(inputMap, referenceOrder);
        
        // 输出结果: {a=ccccc, b=谢谢小星星, c=ssss, d=额外键}
        System.out.println(sortedMap); 
    }
}