精华内容
下载资源
问答
  • java集合分组(Guava)

    2017-03-11 21:06:31
    因工作的需要,利用Guave对集合进行分组。这是个最简单的例子,希望对大家有用。
  • 再做List数据集合打印活数据绑定时,需要吧List集合分组筛选的,就可以用。
  • java 8 集合分组_Java 8:按集合分组

    千次阅读 2020-06-12 19:55:52
    java 8 集合分组 在继续阅读Venkat Subramaniam的“ Java函数式编程 ”时,我到达了介绍Stream#collect函数的那部分。 我们想收集一个人,按年龄分组并返回一张方便的地图(年龄->人的名字)。 要刷新,这...

    java 8 集合分组

    在继续阅读Venkat Subramaniam的“ Java函数式编程 ”时,我到达了介绍Stream#collect函数的那部分。

    我们想收集一个人,按年龄分组并返回一张方便的地图(年龄->人的名字)。

    要刷新,这是Person类的样子:

    static class Person {
        private String name;
        private int age;
    
        Person(String name, int age) {
    
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return String.format("Person{name='%s', age=%d}", name, age);
        }
    }

    我们可以用Java 8编写以下代码来获取按年龄分组的人的名字的地图:

    Stream<Person> people = Stream.of(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28));
    Map<Integer, List<String>> peopleByAge = people
        .collect(groupingBy(p -> p.age, mapping((Person p) -> p.name, toList())));
    System.out.println(peopleByAge);
    {24=[Paul], 28=[Will], 30=[Mark]}

    我们正在集合上运行“收集”功能,并在进行时按“年龄”属性进行分组,并对人员姓名而不是人员本身进行分组。

    这与您在Ruby中所做的稍有不同,在Ruby中您可以调用一个“ group_by”函数:

    > people = [ {:name => "Paul", :age => 24}, {:name => "Mark", :age => 30}, {:name => "Will", :age => 28}]
    > people.group_by { |p| p[:age] }
    => {24=>[{:name=>"Paul", :age=>24}], 30=>[{:name=>"Mark", :age=>30}], 28=>[{:name=>"Will", :age=>28}]}

    这会向我们提供按年龄分组的人员列表,但我们需要应用其他“地图”操作来将其更改为姓名列表:

    > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] }
    => [[24, ["Paul"]], [30, ["Mark"]], [28, ["Will"]]]

    在这个阶段,我们有一个(年龄,名字)对的数组,但是幸运的是Ruby 2.1.0有一个函数“ to_h”,我们可以调用它来再次返回哈希:

    > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] }.to_h
    => {24=>["Paul"], 30=>["Mark"], 28=>["Will"]}

    如果要在对集合执行归约操作时遵循Java按属性分组的方法,则将具有以下内容:

    > people.reduce({}) { |acc, item| acc[item[:age]] ||=[]; acc[item[:age]] << item[:name]; acc }
    => {24=>["Paul"], 30=>["Mark"], 28=>["Will"]}

    如果我们使用Clojure,则可能会得到如下所示的结果:

    (def people
      [{:name "Paul", :age 24} {:name "Mark", :age 30} {:name "Will", :age 28}])
    
    > (reduce (fn [acc [k v]] (assoc-in acc [k] (map :name v))) {} (group-by :age people))
    {28 ("Will"), 30 ("Mark"), 24 ("Paul")}

    我以为Java版本从一开始看起来有点怪异,但是用其他几种语言解决了这个问题,实际上还不错。

    最好知道是否有更好的方法来使用Ruby / Clojure!


    翻译自: https://www.javacodegeeks.com/2014/02/java-8-group-by-with-collections.html

    java 8 集合分组

    展开全文
  • java 集合分组求和

    2021-02-27 12:27:28
    请问如何将这样的一个list>转换成下面的结果,求问各位路过的大神赐教该如何修改!!!!!!!!要实现的结果是:AB A 9.0 4.0AB B 7.0 5.0AB C 4.0 3.0AB D 8.0 2.0AB合计 28.0 14.0CD A 7.0 3.0CD B 5.0 1.0CD...

    请问如何将这样的一个list> 转换成下面的结果,求问各位路过的大神赐教该如何修改!!!!!!!!要实现的结果是:

    AB  A  9.0  4.0

    AB  B  7.0  5.0

    AB  C  4.0  3.0

    AB  D  8.0  2.0

    AB合计  28.0  14.0

    CD  A  7.0  3.0

    CD  B  5.0  1.0

    CD合计  12.0  4

    总计    40.0   18

    相关代码如下:

    package com.test;

    import java.math.BigDecimal;

    import java.util.ArrayList;

    import java.util.HashMap;

    import java.util.List;

    import java.util.Map;

    public class Test1 {

    public static void main(String[] args) {

    List> list = new ArrayList>();

    list.add(createMap("小溪塔", "A", 9.0,5.0));

    list.add(createMap("小溪塔", "B", 7.0,4.0));

    list.add(createMap("小溪塔", "C", 4.574,2.52));

    list.add(createMap("小溪塔", "D", 8.435,3.53));

    list.add(createMap("太平溪", "A", 7.246,4));

    list.add(createMap("太平溪", "B", 5,3));

    list.add(createMap("雾渡河镇", "A", 7.0,2.5));

    list.add(createMap("雾渡河镇", "B", 5.0,3.5));

    List> xlist=groupCount(list);

    for (Map map : xlist) {

    System.out.println(map);

    }

    }

    public static List> groupCount(List> list){

    List> xList =new ArrayList>();

    if(list!=null&&list.size()>0){

    double zhj1=0,gdzhj1=0;

    xList.add(list.get(0));

    for(int i=1;i

    int size=xList.size()-1;

    Map map=list.get(i);

    Map map1=xList.get(size);

    String xz = object2String(map.get("乡镇"));

    String xz1 = object2String(map1.get("乡镇"));

    double zj = object2Double(map.get("总计"));

    double gdzj = object2Double(map.get("耕地"));

    zhj1=add(zj,zhj1);gdzhj1=add(gdzj,gdzhj1);

    if(xz.equals(xz1)){

    double zj1 = object2Double(map1.get("总合计"));

    double gdzj1 = object2Double(map1.get("耕地"));

    double zhj=add(zj,zj1);

    double gdzhj=add(gdzj,gdzj1);

    Map map2=new HashMap();

    map2.put("乡镇总合计", xz+"总合计");

    map2.put("村", null);

    map2.put("总计",zhj);

    map2.put("耕地",gdzhj);

    xList.add(map);

    xList.add(map2);

    }else{

    xList.add(map);

    }

    }

    Map map=new HashMap();

    map.put("所有总计","所有总计");

    map.put("总计", zhj1);

    map.put("耕地", gdzhj1);

    xList.add(map);

    }

    return xList;

    }

    public static double add(double v1, double v2) {

    BigDecimal b1 = new BigDecimal(Double.toString(v1));

    BigDecimal b2 = new BigDecimal(Double.toString(v2));

    return b1.add(b2).doubleValue();

    }

    public static String object2String(Object obj){

    return obj == null ? "" : obj.toString();

    }

    public static double object2Double(Object obj){

    String value = object2String(obj);

    return "".equals(value) ? 0 : Double.valueOf(value);

    }

    public static Map createMap(String town,String village,double zjmj,double gdmj){

    Map map = new HashMap();

    map.put("乡镇", town);

    map.put("村", village);

    map.put("总计",zjmj);

    map.put("耕地", gdmj);

    return map;

    }

    }

    展开全文
  • java 集合分组与排序

    2012-05-10 13:30:04
    java 集合分组排序帮助类有好的意见可以互相交流不甚感激
  • Java:实现集合分组

    千次阅读 2019-04-15 10:22:01
    对于相对简单的操作,令人惊讶的是在标准Java集合API中没有支持。幸运的是,Guava和Apache Commons Collections都以类似的方式实现了操作 2.使用Guava对List进行分区 Guava便于将列表分成指定大小的子列表-经由...

    1.概述

    在本教程中,我将说明如何将List拆分为给定大小的多个子列表

    对于相对简单的操作,令人惊讶的是在标准Java集合API中没有支持。幸运的是,GuavaApache Commons Collections都以类似的方式实现了操作

     

    2.使用Guava对List进行分区

    Guava 便于将列表分成指定大小的子列表-经由Lists.partition操作

    @Test
    public void givenList_whenParitioningIntoNSublists_thenCorrect() {
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
        List<List<Integer>> subSets = Lists.partition(intList, 3);
     
        List<Integer> lastPartition = subSets.get(2);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
        assertThat(subSets.size(), equalTo(3));
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

    3.使用Guava对Collection进行分区

    Guava也可以对Collection进行分区

    @Test
    public void givenCollection_whenParitioningIntoNSublists_thenCorrect() {
        Collection<Integer> intCollection = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
     
        Iterable<List<Integer>> subSets = Iterables.partition(intCollection, 3);
     
        List<Integer> firstPartition = subSets.iterator().next();
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(1, 2, 3);
        assertThat(firstPartition, equalTo(expectedLastPartition));
    }

    请记住,分区是原始集合的子列表视图 - 这意味着原始集合中的更改将反映在分区中

    @Test
    public void givenListPartitioned_whenOriginalListIsModified_thenPartitionsChangeAsWell() {
        // Given
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
        List<List<Integer>> subSets = Lists.partition(intList, 3);
     
        // When
        intList.add(9);
     
        // Then
        List<Integer> lastPartition = subSets.get(2);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8, 9);
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

     

    4.使用Apache Commons Collections对List进行分区

    最新版本的Apache Commons Collections 最近还增加了对List的分区支持:

    @Test
    public void givenList_whenParitioningIntoNSublists_thenCorrect() {
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
        List<List<Integer>> subSets = ListUtils.partition(intList, 3);
     
        List<Integer> lastPartition = subSets.get(2);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
        assertThat(subSets.size(), equalTo(3));
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

    没有相应的选项来划分一个原始收藏 -类似于Guava Iterables.partition在通用集合。

    最后,同样的警告也适用于此 - 结果分区是原始List的视图

    5.使用Java8对List进行分区

    现在,让我们看看如何使用Java8来分区列表。

    5.1. Collectors partitioningBy

    我们可以使用Collectors.partitioningBy()将列表拆分为2个子列表 - 如下所示:

    @Test
    public void givenList_whenParitioningIntoSublistsUsingPartitionBy_thenCorrect() {
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
     
        Map<Boolean, List<Integer>> groups = 
          intList.stream().collect(Collectors.partitioningBy(s -> s > 6));
        List<List<Integer>> subSets = new ArrayList<List<Integer>>(groups.values());
     
        List<Integer> lastPartition = subSets.get(1);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
        assertThat(subSets.size(), equalTo(2));
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

    注意:生成的分区不是主List的视图,因此主List发生的任何更改都不会影响分区。

    5.2.  Collectors groupingBy

    我们也可以使用Collectors.groupingBy()将列表拆分为多个分区:

    @Test
    public final void givenList_whenParitioningIntoNSublistsUsingGroupingBy_thenCorrect() {
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
     
        Map<Integer, List<Integer>> groups = 
          intList.stream().collect(Collectors.groupingBy(s -> (s - 1) / 3));
        List<List<Integer>> subSets = new ArrayList<List<Integer>>(groups.values());
     
        List<Integer> lastPartition = subSets.get(2);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
        assertThat(subSets.size(), equalTo(3));
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

    注意:就像Collectors.partitioningBy()一样 - 生成的分区不会受到主List中的更改的影响。

    5.3. 按分隔符拆分列表

    我们也可以使用Java8按分隔符拆分List:

    @Test
    public void givenList_whenSplittingBySeparator_thenCorrect() {
        List<Integer> intList = Lists.newArrayList(1, 2, 3, 0, 4, 5, 6, 0, 7, 8);
     
        int[] indexes = 
          Stream.of(IntStream.of(-1), IntStream.range(0, intList.size())
          .filter(i -> intList.get(i) == 0), IntStream.of(intList.size()))
          .flatMapToInt(s -> s).toArray();
        List<List<Integer>> subSets = 
          IntStream.range(0, indexes.length - 1)
                   .mapToObj(i -> intList.subList(indexes[i] + 1, indexes[i + 1]))
                   .collect(Collectors.toList());
     
        List<Integer> lastPartition = subSets.get(2);
        List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
        assertThat(subSets.size(), equalTo(3));
        assertThat(lastPartition, equalTo(expectedLastPartition));
    }

    注意:我们使用“0”作为分隔符 - 我们首先获得List中所有“0”元素的索引,然后我们在这些索引上拆分List

    六,结论

    这里介绍的解决方案使用了额外的库--Guava或Apache Commons Collections库。这两个都非常轻量级,总体上非常有用,所以在类路径中使用其中一个非常有意义; 但是,如果这不是一个选项 - 这里显示一个Java解决方案。

    所有这些示例和代码片段的实现都可以在GitHub上找到 - 这是一个基于Maven的项目,因此它应该很容易导入和运行。

    译文地址:https://www.baeldung.com/java-list-split

     

    展开全文
  • Java 8:按集合分组

    2020-05-16 04:25:39
    在继续阅读Venkat Subramaniam的... 我们想收集一个人,按年龄分组,并返回一张方便的(年龄->人名)地图。 要刷新,这是Person类的样子: static class Person { private String name; private int age; ...

    在继续阅读Venkat Subramaniam的“ Java函数式编程 ”时,我到达了介绍Stream#collect函数的那部分。

    我们想收集一个人,按年龄分组,并返回一张方便的(年龄->人名)地图。

    要刷新,这是Person类的样子:

    static class Person {
        private String name;
        private int age;
    
        Person(String name, int age) {
    
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return String.format("Person{name='%s', age=%d}", name, age);
        }
    }

    我们可以用Java 8编写以下代码来获取按年龄分组的人的名字的地图:

    Stream<Person> people = Stream.of(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28));
    Map<Integer, List<String>> peopleByAge = people
        .collect(groupingBy(p -> p.age, mapping((Person p) -> p.name, toList())));
    System.out.println(peopleByAge);
    {24=[Paul], 28=[Will], 30=[Mark]}

    我们在集合上运行“集合”功能,并在进行时按“年龄”属性进行分组,并对人员姓名而不是人员本身进行分组。

    这与您在Ruby中所做的有点不同,在Ruby中您可以调用一个“ group_by”函数:

    > people = [ {:name => "Paul", :age => 24}, {:name => "Mark", :age => 30}, {:name => "Will", :age => 28}]
    > people.group_by { |p| p[:age] }
    => {24=>[{:name=>"Paul", :age=>24}], 30=>[{:name=>"Mark", :age=>30}], 28=>[{:name=>"Will", :age=>28}]}

    这会向我们提供按年龄分组的人员列表,但是我们需要应用其他“地图”操作来将其更改为姓名列表:

    > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] }
    => [[24, ["Paul"]], [30, ["Mark"]], [28, ["Will"]]]

    在这个阶段,我们有一个(年龄,名字)对的数组,但是幸运的是Ruby 2.1.0有一个函数“ to_h”,我们可以调用它来再次返回哈希:

    > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] }.to_h
    => {24=>["Paul"], 30=>["Mark"], 28=>["Will"]}

    如果要在对集合执行归约操作时遵循Java按属性分组的方法,我们将具有以下内容:

    > people.reduce({}) { |acc, item| acc[item[:age]] ||=[]; acc[item[:age]] << item[:name]; acc }
    => {24=>["Paul"], 30=>["Mark"], 28=>["Will"]}

    如果我们使用Clojure,则可能会得到如下所示的结果:

    (def people
      [{:name "Paul", :age 24} {:name "Mark", :age 30} {:name "Will", :age 28}])
    
    > (reduce (fn [acc [k v]] (assoc-in acc [k] (map :name v))) {} (group-by :age people))
    {28 ("Will"), 30 ("Mark"), 24 ("Paul")}

    我以为Java版本一开始看起来有点怪异,但是用其他几种语言解决了这个问题,实际上还不错。

    最好知道是否有更好的方法来执行Ruby / Clojure方法!


    翻译自: https://www.javacodegeeks.com/2014/02/java-8-group-by-with-collections.html

    展开全文
  • 一:基于stream的集合分组 最记载做到一个统计功能,发现其中的集合分组的实现,让人头疼。传统的分组方式,基于集合的遍历按照条件意义分组。如下例所示。 基于年龄的分组其实真的挺烦,即使我们使用工厂模式的话...
  • Java基础之List集合分组实现教程

    千次阅读 2019-06-29 00:10:57
    举个例子,下面是一种方法,将list按照没1000个为一个集合分组 List<String> values = new ArrayList(); String[] configSeqArray = StringUtils.split(configSeq,','); for (String str : configSeqArray) { ...
  • //处理分组后的数据 //创建一个list集合存储所有数据 List> maps = new ArrayList(); //遍历分组后的数据,进行组装 collect.forEach((k, v) -> { HashMap map = new HashMap(); map.put("name", k); map.put(...
  • 主要介绍了java8 集合 多字段 分组 统计个数代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 使用stream流对List集合分组

    千次阅读 2020-01-03 20:48:32
    直接上代码 public static void main... // 初始化一个List集合 List<Integer> numberList = Arrays.asList(3, 5, 6, 4, 2, 8, 9, 1, 7); //使用stream流进行分组(使用条件) Map<Boolean, List&l...
  • 一.对象类@Data@AllArgsConstructorpublic class User {private Integer age;private String name;}二.普通写法private List users =Arrays.asList(new User(20,"张三"),new User(18,"李四"),new User(20,"王五"));...
  • 集合中为对象,根据对象中的某一属性值分组   例子 1、实体类:构造方法、get/set方法、toString方法省略 public class User { private String id; private String name; private String age; .........
  • java 实现集合分组功能

    千次阅读 2018-04-19 11:43:06
    1.代码package com.xtm.java.test; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; import java.util.List;... * 分组实现 */ public class Test{ //实体类 class App...
  • 集合中为对象,根据对象中的某一属性值分组   例子 1、实体类:构造方法、get/set方法、toString方法省略 public class User { private String id; private String name; private String age; ........
  • 将Scala集合分组输出

    千次阅读 2018-08-15 14:28:10
    val list = List(List(0, 0, 0),List(1, 1, 0),List(0, 0, 1),List(1, 0, 1),List(0, 1, 0),List(1, 0, 1),List(0, 1, 1),List(1, 1, 1),List(0, 0, 1),List(11, 11, 11), List(11,2,2),List(11,22,334),List(2,2,....
  • hasOwnProperty:判断对象是否存在属性 代码1: const groupBy = (list, key) => { const obj = {}; list.map(item => { if (!obj[item[key]]) { //如果不存在这个属性 obj[item[key]] = [];...
  • 关于java Stream流将list集合分组之后与原list的集合的顺序不一致的问题 问题:在将list集合按照某个或某几个字段分组之后,map中key的顺序与原来list的顺序不一致,导致需要按顺序进行字段匹配时出现了错误 // 按照...
  • 转自:... java 8 lambda表达式list操作分组、过滤、求和、最值、排序、去重:https://blog.csdn.net/gsls200808/article/details/86501905 jdk8 lambda表达式list操作分组、过滤、求和、最值...
  • java中List集合分组合并

    千次阅读 2019-04-11 09:12:30
    List<... 集合数据 直接上代码: package com.springboot_demo.hlvyboot.test; import java.util.*; /** * Test * * @author heng * @date 2019/3/28 **/ public class Test { ...
  • 上一篇JDK1.8新特性(五):Stream,集合操作利器,让你好用到飞起来,主要讲解了关于Stream的基本操作,可以轻松摆脱**“遍历、再遍历、再运算”**等复杂操作,但Stream远远不止这些。本文将讲述关于St.
  • java通过Stream对list集合分组 现在有一个List集合,想对该集合中的数据分组处理,想到java8中的stream,就搞来试试,非常给力!例子如下 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26...
  • 实现List 集合 分组取出

    千次阅读 2018-05-15 15:47:15
    * 实现java 中 list集合中有几十万条数据,每100条为一组取出 * @param list 可穿入几十万条数据的List */ public void groupList(List list){ int listSize=list.size(); int toIndex=100; int keyToken = 0...
  • Java集合分组算法

    千次阅读 2013-07-10 14:41:45
    在实际开发中,可能会遇到这么一种情况:对集合进行分组,这里使用Collection集合。所谓分组,笔者是指对集合中有相同特征的元素进行归纳,用例中使用map表示,将相同特征做为Key,将具有此特征的元素作为一个List的...
  • 实用推荐 | JDK 1.8 Lambda表达式集合分组、条件过滤、组装、去重、排序、转换、求和、最值
  • guava集合分组

    千次阅读 2016-02-25 11:50:09
    //根据groupId分组, 如果groupId为null, 则放到默认为0的group下 Function, Integer> fun = new Function, Integer>() { @Override public Integer apply(Goods input) { if (input.getGroupId() == null)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 179,607
精华内容 71,842
关键字:

集合分组

友情链接: HoodLoader2-master.zip