按指定大小，分隔集合，将集合按规定个数分为n个部分

Dear 丶 2022-06-04 09:05 126阅读 0赞

**Java技术学习 [https://www.itkc8.com][https_www.itkc8.com]**

package com.ybf.common;/**
     * Created by HUXU on 2017/12/9.
     */
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 分割list
     *
     * @author huxu
     * @create 2017-12-09 17:20
     **/
    
    public class ListCommon {
    
        /**
         * 按指定大小，分隔集合，将集合按规定个数分为n个部分
         *
         * @param list
         * @param len
         * @return
         */
        public static <T> List<List<T>> splitList(List<T> list, int len) {
            if (list == null || list.size() == 0 || len < 1) {
                return null;
            }
            List<List<T>> result = new ArrayList<List<T>>();
            int size = list.size();
            int count = (size + len - 1) / len;
            for (int i = 0; i < count; i++) {
                List<T> subList = list.subList(i * len, ((i + 1) * len > size ? size : len * (i + 1)));
                result.add(subList);
            }
            return result;
        }
    
    
    }

1、自己编写相关代码：

2、使用guava：

\[html\] [view plain][] [copy][view plain]

1.  import java.util.ArrayList;    
2.  import java.util.List;    
3.  import com.google.common.collect.Lists;    
4.      
5.      
6.  public class Test4 \{    
7.      
8.      public static void main(String\[\] args) \{    
9.          List**<****Long****>** list = new ArrayList**<****>**();    
10.         list.add(1L);    
11.         list.add(2L);    
12.         list.add(3L);    
13.         list.add(4L);    
14.         list.add(5L);    
15.         list.add(6L);    
16.         list.add(7L);    
17.         list.add(8L);    
18.         list.add(9L);    
19.             
20.         //test1(list);    
21.         test2(list);    
22.     \}    
23.         
24.     private static void test1(List**<****Long****>** list) \{    
25.         int size = 2;    
26.         List**<****List****<****Long****>****>** listArr = new ArrayList**<****>**();      
27.             
28.         int arrSize = list.size()%size==0?list.size()/size:list.size()/size+1;      
29.         for(int i=0;i**<****arrSize**;i++) \{      
30.             List**<****Long****>**  sub = new ArrayList**<****>**();      
31.             for(int j=i\*size;j**<**=size\*(i+1)-1;j++) \{      
32.                 if(j**<**=list.size()-1) \{      
33.                     sub.add(list.get(j));      
34.                 \}      
35.             \}      
36.             listArr.add(sub);      
37.         \}      
38.         System.out.println(listArr.toString());    
39.     \}    
40.         
41.         
42.     private static void test2(List**<****Long****>** list) \{    
43.         int size = 16;    
44.         List**<****List****<****Long****>****>** subSets = Lists.partition(list, size);      
45.         System.out.println(subSets.toString());    
46.     \}    
47. \}

### 补充：guava分割其他collections[iew plain][] ###

\[html\] [view plain][] [copy][view plain]

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

以上需要注意的是，partition返回的是原list的subview.视图，也即，原list改变后，partition之后的结果也会随着改变。

\[html\] [view plain][] [copy][view plain]

1.  @Test      
2.  public void givenListPartitioned\_whenOriginalListIsModified\_thenPartitionsChangeAsWell() \{      
3.      // Given      
4.      List**<****Integer****>** intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);      
5.      List**<****List****<****Integer****>****>** subSets = Lists.partition(intList, 3);      
6.         
7.      // When      
8.      intList.add(9);      
9.         
10.     // Then      
11.     List**<****Integer****>** lastPartition = subSets.get(2);      
12.     List**<****Integer****>** expectedLastPartition = Lists.**<****Integer****>** newArrayList(7, 8, 9);      
13.     assertThat(lastPartition, equalTo(expectedLastPartition));      
14. \}

3、使用apache commons collection：

\[html\] [view plain][] [copy][view plain]

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

1.没有对应的Iterable.partions方法，类似guava那样

2.partition后的结果同样是原集合的视图。

4、Java8方法

1）通过grouping by：

\[html\] [view plain][] [copy][view plain]

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

按年龄分组：

\[html\] [view plain][] [copy][view plain]

1.  Map**<****Integer**, List**<****Person****>****>** personGroups = Stream.generate(new PersonSupplier()).      
2.   limit(100).      
3.   collect(Collectors.groupingBy(Person::getAge));      
4.  Iterator it = personGroups.entrySet().iterator();      
5.  while (it.hasNext()) \{      
6.   Map.Entry**<****Integer**, List**<****Person****>****>** persons = (Map.Entry) it.next();      
7.   System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());      
8.  \}

2）通过partition by：

\[html\] [view plain][] [copy][view plain]

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

按照成年未成年人分组：

\[html\] [view plain][] [copy][view plain]

1.  Map**<****Boolean**, List**<****Person****>****>** children = Stream.generate(new PersonSupplier()).    
2.   limit(100).    
3.   collect(Collectors.partitioningBy(p -**>** p.getAge() **<** **18**));    
4.  System.out.println("Children number: " + children.get(true).size());    
5.  System.out.println("Adult number: " + children.get(false).size());

注意：  
1.Java8方式，分组后的list不再是原list的视图。所以，原list的改变不会影响分组后的结果。  
2partitioningBy 其实是一种特殊的 groupingBy，它依照条件测试的是否两种结果来构造返回的数据结构，get(true) 和 get(false) 能即为全部的元素对象。

**Java技术学习 [https://www.itkc8.com][https_www.itkc8.com]**

[https_www.itkc8.com]: https://www.itkc8.com
[view plain]: http://blog.csdn.net/liuxiao723846/article/details/75670290#
[iew plain]: http://blog.csdn.net/pandawang1989/article/details/72801630#

发表评论取消回复

表情：

评论列表（有 0 条评论，126人围观）

还没有评论，来说两句吧...

相关阅读

相关 oracle实现将字段按逗号拼接/按逗号分为多行

oracle实现将字段按逗号拼接/按逗号分行一、拼接 1.普通拼接 2.进阶：限制拼接个数并去重 3.进阶：拼接除去当前值

叁歲伎倆/ 2024年03月23日 15:15/ 0 赞/ 44 阅读

相关将集合按指定数量分组

在工作过程中，我们可能需要将已经查询出来的大集合，改造为大集合中包含小集合，每个小集合的集合长度为固定的。这时就可以用下面的方法来实现： /

约定不等于承诺〃/ 2024年03月17日 18:49/ 0 赞/ 40 阅读

相关 Java 将Excel工作簿按工作表拆分为多个文档

本文介绍在Java代码环境中如何将Excel工作簿按工作表拆分为多个Excel文档，即：把Excel工作簿中的每一个工作表单独保存为一个Excel工作簿文件。思路及方法：通

阳光穿透心脏的1/2处/ 2023年01月02日 02:25/ 0 赞/ 453 阅读

相关 java数据按时间分组_java list集合按日期分组

结果： \{ "code": 1, "data": \{ "mapDate": \[ \{ "fomTime": "2019-11-14", "list": \[

亦凉/ 2022年11月03日 04:01/ 0 赞/ 671 阅读

相关创建指定大小随机数集合

创建随机数组代码如下（示例）： import java.util.Random; public class Test2 {

女爷i/ 2022年10月24日 01:44/ 0 赞/ 102 阅读

相关分隔线集合

\\ 基础分隔线一条黑色实线 \`\`\` html <hr /> \`\`\` \\\ 点线 \`\`\` css /\ 点线 \/ .hr-dotted

你的名字/ 2022年08月30日 08:43/ 0 赞/ 108 阅读

相关 Java将字符串按指定长度分割

转载地址:[https://www.cnblogs.com/ljtletters/p/7109875.html?utm\_source=itdadao&utm\_medium=

女爷i/ 2022年06月05日 06:44/ 0 赞/ 460 阅读

相关按指定大小，分隔集合，将集合按规定个数分为n个部分

Java技术学习 [https://www.itkc8.com][https_www.itkc8.com] package com.ybf.common;/

Dear 丶/ 2022年06月04日 09:05/ 0 赞/ 127 阅读

相关集合按某个属性排序

让集合对象按其属性的某个值的降序排列： package zy.utils; import java.util.Comparator;

淡淡的烟草味﹌/ 2022年02月09日 12:41/ 0 赞/ 262 阅读

相关 Java将字符串按指定长度分割

用于将大量字符串按指定长度分割，返回List 转载地址:[https://www.cnblogs.com/ljtletters/p/7109875.html?utm\_so

偏执的太偏执、/ 2022年01月11日 23:37/ 0 赞/ 820 阅读