lamba stream处理集合

lamba stream处理集合

带拼接多字段分组List< Object> 转 Map<String,List< Object>>

Map<String, List<ProfitAndLossMapping>> collect = plMappingList.stream()
.collect(Collectors.groupingBy(m -> m.getLosType() + ":" + m.getRuleType()));

带拼接多字段分组List< Object> 转 Map<String,String>

List<LosNameListByFy> losNameListByFIES = losNameListByFyMapper.selectList(null);
Map<String, String> losMap = losNameListByFIES.stream()
.collect(Collectors.toMap(o -> o.getFy() + ":" + o.getLos(), LosNameListByFy::getNewLos));

List< Object> 转 Map<String,数量>

Map<String, Long> reportOrgIdMap = reportOrgConfs.stream()
.collect(Collectors.groupingBy(m -> m.getReport() + ":" + m.getOrgId(), Collectors.counting()));

List< Object> 转 Map<String,String>

 Map<String, BigDecimal> avgMap = summaryInitList.stream().collect(HashMap::new, (map, item) -> map.put(item.getCombinedValue(), item.getValue()), HashMap::putAll);Map<String,String> columnAndDimensionMap=dimensions.stream()
.filter(m->StringUtils.isNotBlank(m.getColumnName()))
.collect(Collectors.toMap(Dimension::getColumnName, Dimension::getName, (key1, key2) -> key1));

List< String> 转 Map<String,String>

Map<String,String> reportMap=report.stream()
.filter(StringUtils::isNotBlank)
.collect(Collectors.toMap(Function.identity(),Function.identity()));

List< Object> 转 Map<String, List< DictItemDetailVO>>

Map<String, List<DictItemDetailVO>> map = list.stream()
.collect(Collectors.groupingBy(DictItemDetailVO::getDescription));

List< String>去重 拼接

List<String> list = Arrays.asList("AA", "BB", "CC", "BB", "CC", "AA", "AA");
long l = list.stream().distinct().count();
System.out.println("No. of distinct elements:"+l);
String output = list.stream().distinct().collect(Collectors.joining(","));
System.out.println(output);

List<Map<String, String>> list = new ArrayList<>();
{Map<String, String> map = new HashMap<>();map.put("id", "1");map.put("name", "B");map.put("age", "C");list.add(map);
}{Map<String, String> map = new HashMap<>();map.put("id", "1");map.put("name", "E");map.put("age", "F");list.add(map);
}//1.返回结果{"1","B"},{"2","E"}
Map<String, String> a = list.stream().collect(Collectors.toMap(l -> l.get("id"), 
l -> l.get("name")));//2.两种方法返回结果{"1":{"name":"B","id":"1","age":"C"},"2":{"name":"E","id":"2","age":"F"}}
Map<String, Map> b = list.stream().collect(Collectors.toMap(l -> l.get("id"), map -> map));Map<String, Map> c = list.stream().collect(Collectors.toMap(l -> l.get("id"), 
Function.identity()));//3.重复key情况下处理方式返回结果{"1":{"name":"E","id":"1","age":"F"}}
Map<String, Map> d = list.stream().collect(Collectors.toMap(l -> l.get("id"), 
Function.identity(), (key1, key2) -> key2));//4.重复key情况下指定返回数据类型处理方式返回结果{"1":{"name":"E","id":"1","age":"F"}}
Map<String, Map> e = list.stream().collect(Collectors.toMap(l -> l.get("id"), 
Function.identity(), (key1, key2) -> key2, LinkedHashMap::new));//5.list根据key合并并转map；返回结果{"1":[{"name":"B","id":"1","age":"C"},{"name":"E","id":"1","age":"F"}]}
Map<String, List<Map>> lableGbType = list.stream()
.collect(Collectors.groupingBy(l -> (String) l.get("id")));//6.根据key提取list中指定的值转List数组;返回结果["1","1"]
List<String> ids = list.stream().map(m -> (String) m.get("id"))
.collect(Collectors.toList());//7.数组去重并转list
String[] str = "1,1,2,3,4,5,".split(",");
List<String> listNames = Arrays.stream(str).filter(name -> !isEmpty(name)).distinct().collect(Collectors.toList());}

查数据
List<Map<String, Object>> prnInfo = xxxMapper.selectInfo(pars);List<String> ids= prnInfo.stream().map(m -> m.get("id").toString()).collect(Collectors.toList());**1.根据map的某个key分组**
Map<String, List<Map<String, Object>>> res= dataList.stream().collect(groupingBy(map -> map.get("d").toString()));
获取type="ZC"的数据        
----------------------------------------------------------------     
List<Map<String, Object>> data = res.stream().filter(map -> (map.get("type")+"").equals("ZC")).collect(Collectors.toList());
-----------------------------------------------------------------
List<Map<String, Object>> res = prnInfo .stream().filter(e ->Integer.parseInt(e.get("caseFlag").toString()) != 0)
.collect(Collectors.toList());**2.根据某个key求对应value和**
int totalNums= prnInfo .stream().collect(Collectors.summingInt( e -> Integer.parseInt(e.get("num").toString()))); 

**3.根据map中的某个key的value值进行判断过滤**List<Map<String,Object>> res= prnInfo .stream().filter(e -> Double.parseDouble(e.get("z").toString())>Double.parseDouble(e.get("wrz").toString())).collect(Collectors.toList());
------------------------------------------------------------------------
获取指XX时间前后的数据
LocalDateTime ftm = "xxxxxxxxx";
List<Map<String, Object>> res = prnInfo .stream().filter(map -> LocalDateTime.parse(map.get("starttm")+"", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")).isBefore(tm )).collect(Collectors.toList());------------------------------------------------------------------------

**4.对集合中的map做变更**
List<Map<String, Object>> res= prnInfo .stream().map(x -> {x.put("encd", Double.parseDouble(x.get("rz")+"")-Double.parseDouble(x.get("tdz")+""));return x;}).collect(Collectors.toList());**5.排序**
List<Map<String, Object>>  res= prnInfo.stream().sorted((e1,e2) -> {
return -Double.compare(Double.valueOf(e1.get("num").toString()),Double.valueOf(e2.get("num").toString()));
}).collect(Collectors.toList());res.sort(Comparator.comparing((Map<String, Object> h) -> (h.get("tm").toString())));//排序可能对应字段数据为null导致空指针，需要先判断过滤一下
res.stream().filter(Objects::nonNull).filter((Map<String, Object> h)-> (Objects.nonNull(h.get("fz")))).collect(Collectors.toList());

6.去重
List<String> res = prnInfo.stream().distinct().collect(Collectors.toList());7.做统计
IntSummaryStatistics collect = list.stream().collect(Collectors.summarizingInt(Test::getId));
System.out.println("和：" + collect.getSum());
System.out.println("数量：" + collect.getCount());
System.out.println("最大值：" + collect.getMax());
System.out.println("最小值：" + collect.getMin());
System.out.println("平均值：" + collect.getAverage());最大
double max = prnInfo.stream().mapToDouble(l -> ((BigDecimal) l.get("num")).doubleValue()).max().getAsDouble();
和
double sum = prnInfo.stream().mapToDouble(l -> ((BigDecimal) l.get("num")).doubleValue()).sum();

8.list-map转换
Map<String, Object> map = list.stream().collect(Collectors.toMap(i -> i.getName() + i.getUnitName(), j -> j, (k1, k2) -> k1));------------------------------------------------------------------------
List<User> collect = map.entrySet().stream().map(item -> {User user= new User();user.setId(item.getKey());user.setName(item.getValue());return user;}).collect(Collectors.toList());遍历。。
users.stream().forEach(x->{System.out.println(x);
});下面这个场景用的也很多，List里面的a和b相等就把c属性相加,报表里面某些属性相等则求和等场景，可以先根据需要去重的多个字段进行分组，再计算返回
for (Map.Entry<String, List<DTO>> entry : beanList.parallelStream().collect(groupingBy(o -> (o.getId() + o.geCode()), Collectors.toList())).entrySet()) {if(bitMap.contains(entry.getKey()) && entry.getValue().size()==1){objects.add(entry.getValue().get(0));}else{List<DTO> transfer = entry.getValue();transfer.stream().reduce((a, b) -> DTO.builder().irrCd(a.getIrrCd()).id(a.getId()).tm(a.getCode()).build()).ifPresent(objects::add);}}