java jdk1.8 使用stream流进行list 分组归类操作

我就废话不多说了,大家还是直接看代码吧~

import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
 * @author czw
 */
public class Foo{
  private String name;
  private String type;
  private Double typeValue;
  private Integer count;
  public Foo(String name, String type, Double typeValue, Integer count) {
    this.name = name;
    this.type = type;
    this.typeValue = typeValue;
    this.count = count;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getType() {
    return type;
  }
  public void setType(String type) {
    this.type = type;
  }
  public Double getTypeValue() {
    return typeValue;
  }
  public void setTypeValue(Double typeValue) {
    this.typeValue = typeValue;
  }
  public Integer getCount() {
    return count;
  }
  public void setCount(Integer count) {
    this.count = count;
  }
  @Override
  public String toString() {
    return "Foo{" +
        "name='" + name + '\'' +
        ", type='" + type + '\'' +
        ", typeValue=" + typeValue +
        ", count=" + count +
        '}';
  }
  public static void main(String[] args) {
    List<Foo> fooList = new ArrayList<Foo>();
    fooList.add(new Foo("A","san",1.0,2)) ;
    fooList.add( new Foo("A","nas",13.0,1)) ;
    fooList.add(new Foo("B","san",112.0,3)) ;
    fooList.add(new Foo("C","san",43.0,5)) ;
    fooList.add(new Foo("B","nas",77.0,7)) ;
    List<List<Foo>> groupList = new ArrayList<>();
    fooList.stream()
        .collect(Collectors.groupingBy(Foo::getName,Collectors.toList()))
        .forEach((name,fooListByName)->{
          groupList.add(fooListByName);
        });
    System.out.println(JSON.toJSONString(groupList));
  }
}

输出结果

[
  [{
    "count": 2,
    "name": "A",
    "type": "san",
    "typeValue": 1
  }, {
    "count": 1,
    "name": "A",
    "type": "nas",
    "typeValue": 13
  }],
  [{
    "count": 3,
    "name": "B",
    "type": "san",
    "typeValue": 112
  }, {
    "count": 7,
    "name": "B",
    "type": "nas",
    "typeValue": 77
  }],
  [{
    "count": 5,
    "name": "C",
    "type": "san",
    "typeValue": 43
  }]
]

补充知识:java jdk1.8的stream复杂和简单的分组

获取List对象中的某个参数时:

List<Map<String,String>> param = new ArrayList<>();
Map<String,String> map = new HashMap<>();
map.put("id","1213");
map.put("name","test");
List<String> strList = param.stream().map(key ->key.get("name")).collect(Collectors.toList());

简单参数分组:

List<DamoForm> damoformList = new ArrayList<>();
Map<String, Map<String, List<DamoForm>>> collect = damoformList.stream()
        .collect(Collectors.groupingBy(DamoForm::getId()))
        .entrySet()
        .stream()
        .collect(Collectors.toMap(
            entry -> entry.getKey(),
            entry -> entry.getValue().stream().collect(Collectors.groupingBy(DamoForm::getName()))
        ));

针对List复杂排序,多个条件进行排序:

应用场景:针对List中某个字段的数据进行双重倒序的方式排序,代码有点复杂,不明白的可以留言。

List<DamoForm> damoformList = new ArrayList<>();
List<Map<String, Object>> result = damoformList.stream()
     .collect(Collectors.groupingBy(DamoForm::getPartClass))
     .entrySet()
     .stream()
     .sorted((o1, o2) -> {
       /*
        * 这里排序,任何有1的排在前,全部是0排在后
        */
        Integer sort1 = o1.getValue().stream().anyMatch(item -> item.getIsFlag() > 0) ? -1 : 1;
        Integer sort2 = o2.getValue().stream().anyMatch(item -> item.getIsFlag() > 0) ? -1 : 1;
        return sort1.compareTo(sort2);
     })
     .map(entry -> {
        Map<String, Object> map = Maps.newHashMapWithExpectedSize(2);
        map.put("repairItemTypeName", entry.getKey());
          /*
           * 这里排序,1排在前,0排在后
           */
          List<DamoVO> damoVOList = entry.getValue().stream()
              .sorted(Comparator.comparingInt(o -> (o.getIsFlag() * -1)))
              .collect(Collectors.toList());
          map.put("repairTypeList", itemDescFormList);
          return map;
     })
     .collect(Collectors.toList());

以上这篇java jdk1.8 使用stream流进行list 分组归类操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java8 使用 stream().sorted()对List集合进行排序的操作

    1.声明一个测试对象 import java.time.LocalDate; import java.util.List; import lombok.Data; @Data public class StudentInfo{ //名称 private String name; //性别 true男 false女 private Boolean gender; //年龄 private Integer age; //身高 private Double height; //出生日期 private

  • java8中Stream的使用以及分割list案例

    一.Steam的优势 java8中Stream配合Lambda表达式极大提高了编程效率,代码简洁易懂(可能刚接触的人会觉得晦涩难懂),不需要写传统的多线程代码就能写出高性能的并发程序 二.项目中遇到的问题 由于微信接口限制,每次导入code只能100个,所以需要分割list.但是由于code数量可能很大,这样执行效率就会很低. 1.首先想到是用多线程写传统并行程序,但是博主不是很熟练,写出代码可能会出现不可预料的结果,容易出错也难以维护. 2.然后就想到Steam中的parallel,能提高性能

  • JAVA JDK8 List分组的实现和用法

    概述 对List进行分组是日常开发中,经常遇到的,在JDK 8中对List按照某个属性分组的代码,超级简单. package test; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util

  • Java8 stream 中利用 groupingBy 进行多字段分组求和案例

    Java8的groupingBy实现集合的分组,类似Mysql的group by分组功能,注意得到的是一个map 对集合按照单个属性分组.分组计数.排序 List<String> items = Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya");

  • java jdk1.8 使用stream流进行list 分组归类操作

    我就废话不多说了,大家还是直接看代码吧~ import com.alibaba.fastjson.JSON; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; /** * @author czw */ public class Foo{ private String name; private String type; private Double typeValue; p

  • Java 中如何使用 stream 流

    目录 前言 一.筛选和切片 1.1.筛选 filter 1.2.去重 distinct 1.3.切片 limit 1.4.跳过元素 skip 1.5.排序 sorted 1.6.小结与综合应用 二.映射 map 三.查找和匹配 3.1.匹配 anyMatch.allMatch和noneMatch 方法 3.2.查找 findAny 与 findFirst 3.3.小结 四.归约 4.1.元素求和 reduce 后记 前言 如果你了解过 Liunx ,了解过 Liunx 的中管道命令 | ,那么你

  • Java分析Lambda表达式Stream流合并分组内对象数据合并

    目录 前言 需求 代码实现 依赖引入 设计实体类 测试代码 前言 之前写过<Lambda使用——JDK8新特性>,现在有一个分组合并的需求正好拿来小试牛刀. 需求 数据出自许多接口数据,需要将几个接口数据根据省份id进行分组合并.举例说明: A接口返回List里面有值的的字段为:provinceId.field1.field2.field3 B接口返回List里面有值的的字段为:provinceId.field4.field5.field6 C接口返回List里面有值的的字段为:provinc

  • JDK1.8新特性Stream流式操作的具体使用

    一. 前言 随着Java的发展,越来越多的企业开始使用JDK1.8 版本.JDK1.8 是自 JDK1.5之后最重要的版本,这个版本包含语言.编译器.库.工具.JVM等方面的十多个新特性.本次文章将着重学习Stream. Stream 是JDK1.8 中处理集合的关键抽象概念,Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.过滤和映射数据等操作.使用Stream API 对集合数据进行操作,就类似于使用SQ

  • Java Stream 流实现合并操作示例

    本文实例讲述了Java Stream 流实现合并操作.分享给大家供大家参考,具体如下: 1. 前言 Java Stream Api提供了很多有用的 Api 让我们很方便将集合或者多个同类型的元素转换为流进行操作.今天我们来看看如何合并 Stream 流. 2. Stream 流的合并 Stream 流合并的前提是元素的类型能够一致. 2.1 concat 最简单合并流的方法是通过 Stream.concat() 静态方法: Stream<Integer> stream = Stream.of(

  • Java集合Stream流操作的基本使用教程分享

    目录 事前准备 Filter Sorted Map Match Count Reduce 总结 Java 中可以使用 java.util.Stream 对一个集合(实现了java.util.Collection接口的类)做各种操作,例如:求和.过滤.排序等等. 这些操作可能是中间操作——返回一个 Stream 流,或者是终端操作——返回一个结果. 流操作并不会影响原来的集合,可以简单认为,流操作是把集合中的一个元素逐个复制放到一个首尾相接的流动的水槽中. Stream 流支持同步执行,也支持并发

  • Java关于JDK1.8新特性的Stream流

    目录 Java 的Stream流 一.定义 二.操作的特征 三.代码示例 1.生成流 2.forEach 迭代 3.limit方法用于获取指定数量的流 4.map 5.sorted 6.并行(parallel)程序 7.Collectors 8.转化(将枚举类转成map) Java 的Stream流 一.定义 JDK1.8 中增加了Stream流,Stream流是一个来自数据源的元素队列并支持聚合操作.元素是特定类型的对象,形成一个队列,Java中的Stream并不会存储元素,而是按需计算数据源

  • 通过实例了解Java 8创建Stream流的5种方法

    这篇文章主要介绍了通过实例了解Java 8创建Stream流的5种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 不知不觉间,Java已经发展到13了,来不及感慨时间过得真的太快了,来不及学习日新月异的技术更新,目前大多数公司还是使用的JDK8版本,一方面是版本的稳定,另一方面是熟悉,所以很多公司都觉得不升级也挺好. 说到JDK8,真的是一个里程碑的版本,一出世就受到所有开发者的青睐,并主动花时间和精力去学习,也是我见过企业升级JDK最豪爽

  • Java Stream流知识总结

    说明 在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端 遍历 传统集合在于使用循环遍历 Java 8的Lambda让我们可以更加专注于做什么(What),而不是怎么做(How),这点此前已经结合内部类进行 了对比说明.现在,我们仔细体会一下上例代码,可以发现: for循环的语法就是"怎么做" for循环的循环体才是"做什么" 传统集合遍历 import java.util.ArrayList;

  • 详解JAVA Stream流

    摘要 Stream 是对集合对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作,或者大批量数据操作.通常我们需要多行代码才能完成的操作,借助于Stream流式处理可以很简单的实现. Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的. 创建Steam流 调用Collection.stream()函数创建一个Stream对象 Stream 接口的静态方法 of 可以获取数组对应的流 List<String> list = new ArrayList<

随机推荐