拆分List的方法

已于 2024-08-27 07:17:46 修改
阅读量998 收藏 16
点赞数 18
分类专栏： 数据结构和算法 文章标签： list
于 2024-08-27 06:52:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fu_Cong/article/details/141578591
版权

按固定条数拆分

谷歌的Lists#partition方法

方法引用地址：com.google.common.collect.Lists#partition

源码解读

Lists.java

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkElementIndex;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkPositionIndex;
import static com.google.common.base.Preconditions.checkPositionIndexes;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.collect.CollectPreconditions.checkNonnegative;
import static com.google.common.collect.CollectPreconditions.checkRemove;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;
import java.io.Serializable;
import java.math.RoundingMode;
import java.util.AbstractList;
import java.util.AbstractSequentialList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Predicate;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Static utility methods pertaining to {@link List} instances. Also see this class's counterparts
 * {@link Sets}, {@link Maps} and {@link Queues}.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/CollectionUtilitiesExplained#lists">{@code Lists}</a>.
 *
 * @author Kevin Bourrillion
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class Lists {
    
    private Lists() {
        
    }
    
    /**
     * Returns consecutive {@linkplain List#subList(int, int) sublists} of a list, each of the same
     * size (the final list may be smaller). For example, partitioning a list containing {@code [a, b,
     * c, d, e]} with a partition size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list
     * containing two inner lists of three and two elements, all in the original order.
     *
     * <p>The outer list is unmodifiable, but reflects the latest state of the source list. The inner
     * lists are sublist views of the original list, produced on demand using {@link List#subList(int,
     * int)}, and are subject to all the usual caveats about modification as explained in that API.
     *
     * @param list the list to return consecutive sublists of
     * @param size the desired size of each sublist (the last may be smaller)
     * @return a list of consecutive sublists
     * @throws IllegalArgumentException if {@code partitionSize} is nonpositive
     */
    public static <T extends @Nullable Object> List<List<T>> partition(List<T> list, int size) {
        checkNotNull(list);
        checkArgument(size > 0);
        return (list instanceof RandomAccess) ? new RandomAccessPartition<>(list, size) : new Partition<>(list, size);
    }
    
    private static class Partition<T extends @Nullable Object> extends AbstractList<List<T>> {
        final List<T> list;
        final int size;
    
        Partition(List<T> list, int size) {
            this.list = list;
            this.size = size;
        }
    
        @Override
        public List<T> get(int index) {
            checkElementIndex(index, size());
            int start = index * size;
            int end = Math.min(start + size, list.size());
            return list.subList(start, end);
        }
    
        @Override
        public int size() {
            return IntMath.divide(list.size(), size, RoundingMode.CEILING);
        }
    
        @Override
        public boolean isEmpty() {
            return list.isEmpty();
        }
    }
    
    private static class RandomAccessPartition<T extends @Nullable Object> extends Partition<T> implements RandomAccess {
        RandomAccessPartition(List<T> list, int size) {
            super(list, size);
        }
    }
}

RandomAccess.java

package java.util;

/**
 * Marker interface used by <tt>List</tt> implementations to indicate that
 * they support fast (generally constant time) random access.  The primary
 * purpose of this interface is to allow generic algorithms to alter their
 * behavior to provide good performance when applied to either random or
 * sequential access lists.
 *
 * <p>The best algorithms for manipulating random access lists (such as
 * <tt>ArrayList</tt>) can produce quadratic behavior when applied to
 * sequential access lists (such as <tt>LinkedList</tt>).  Generic list
 * algorithms are encouraged to check whether the given list is an
 * <tt>instanceof</tt> this interface before applying an algorithm that would
 * provide poor performance if it were applied to a sequential access list,
 * and to alter their behavior if necessary to guarantee acceptable
 * performance.
 *
 * <p>It is recognized that the distinction between random and sequential
 * access is often fuzzy.  For example, some <tt>List</tt> implementations
 * provide asymptotically linear access times if they get huge, but constant
 * access times in practice.  Such a <tt>List</tt> implementation
 * should generally implement this interface.  As a rule of thumb, a
 * <tt>List</tt> implementation should implement this interface if,
 * for typical instances of the class, this loop:
 * <pre>
 *     for (int i=0, n=list.size(); i &lt; n; i++)
 *         list.get(i);
 * </pre>
 * runs faster than this loop:
 * <pre>
 *     for (Iterator i=list.iterator(); i.hasNext(); )
 *         i.next();
 * </pre>
 *
 * <p>This interface is a member of the
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @since 1.4
 */
public interface RandomAccess {
}

说明：

  1. Lists#partition方法并不是直接返回一个简单的List<List>，而是返回了一个 Partition 对象，这个对象是一个实现了List接口的自定义类。当调用 ListUtils.partition 方法时，得到的是一个“虚拟”的列表，其内部的get方法会在请求特定索引的元素时动态地返回原始列表的一个子列表。

    这里的关键是Partition类继承自AbstractList并重写了get方法。当使用for-each循环或其他方式迭代这个返回的列表时，实际上是在迭代Partition对象。每次迭代访问到某个元素时，Partition#get方法会被调用来提供对应索引的子列表。
    这种方式的优点是延迟计算（惰性求值）：只有实际需要某个分区时，它才会被创建。这可以提高效率，尤其是只需要列表中某些分区或者只需要迭代一次时。

  2. RandomAccessPartition实现了RandomAccess接口，用于表示支持快速（通常是恒定时间）随机访问。

使用示例

// 生成包含1-400的列表
Long[] idArray = new Long[0];
for (long i = 1; i <= 400; i++) {
    idArray = ArrayUtils.add(idArray, i);
}
List<Long> allIdList = Arrays.asList(idArray);

// 每100条拆分1次
List<List<Long>> partitionIdList = Lists.partition(allIdList, 100);

注意事项

  1. **不可修改的外层列表：**分区列表是不可修改的，这意味着不能直接添加或删除分区，但可以修改分区内部的元素，因为它们是原始列表的视图。
  2. **子列表的修改问题：**虽然分区列表本身不可修改，但每个分区都是原始列表的视图，因此对分区的修改会反映到原始列表中。这一点在注释中（The outer list is unmodifiable, but reflects the latest state of the source list.）也有提到，需要注意。
  3. **性能和内存效率：**由于使用了subList，分区的性能和内存效率与原始列表紧密相关。如果原始列表很大，创建太多的分区可能会导致性能问题。

阿帕奇的ListUtils#partition方法

方法引用地址：org.apache.commons.collections4.ListUtils#partition

源码解读

ListUtils.java

package org.apache.commons.collections4;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections4.bag.HashBag;
import org.apache.commons.collections4.functors.DefaultEquator;
import org.apache.commons.collections4.list.FixedSizeList;
import org.apache.commons.collections4.list.LazyList;
import org.apache.commons.collections4.list.PredicatedList;
import org.apache.commons.collections4.list.TransformedList;
import org.apache.commons.collections4.list.UnmodifiableList;
import org.apache.commons.collections4.sequence.CommandVisitor;
import org.apache.commons.collections4.sequence.EditScript;
import org.apache.commons.collections4.sequence.SequencesComparator;

/**
 * Provides utility methods and decorators for {@link List} instances.
 *
 * @since 1.0
 */
public class ListUtils {

    /**
     * <code>ListUtils</code> should not normally be instantiated.
     */
    private ListUtils() {
        
    }

    /**
     * Returns consecutive {@link List#subList(int, int) sublists} of a
     * list, each of the same size (the final list may be smaller). For example,
     * partitioning a list containing {@code [a, b, c, d, e]} with a partition
     * size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list containing
     * two inner lists of three and two elements, all in the original order.
     * <p>
     * The outer list is unmodifiable, but reflects the latest state of the
     * source list. The inner lists are sublist views of the original list,
     * produced on demand using {@link List#subList(int, int)}, and are subject
     * to all the usual caveats about modification as explained in that API.
     * <p>
     * Adapted from http://code.google.com/p/guava-libraries/
     *
     * @param <T> the element type
     * @param list  the list to return consecutive sublists of
     * @param size  the desired size of each sublist (the last may be smaller)
     * @return a list of consecutive sublists
     * @throws NullPointerException if list is null
     * @throws IllegalArgumentException if size is not strictly positive
     * @since 4.0
     */
    public static <T> List<List<T>> partition(final List<T> list, final int size) {
        if (list == null) {
            throw new NullPointerException("List must not be null");
        }
        if (size <= 0) {
            throw new IllegalArgumentException("Size must be greater than 0");
        }
        return new Partition<>(list, size);
    }
    
    /**
     * Provides a partition view on a {@link List}.
     * @since 4.0
     */
    private static class Partition<T> extends AbstractList<List<T>> {
        private final List<T> list;
        private final int size;
    
        private Partition(final List<T> list, final int size) {
            this.list = list;
            this.size = size;
        }
    
        @Override
        public List<T> get(final int index) {
            final int listSize = size();
            if (index < 0) {
                throw new IndexOutOfBoundsException("Index " + index + " must not be negative");
            }
            if (index >= listSize) {
                throw new IndexOutOfBoundsException("Index " + index + " must be less than size " +
                                                    listSize);
            }
            final int start = index * size;
            final int end = Math.min(start + size, list.size());
            return list.subList(start, end);
        }
    
        @Override
        public int size() {
            return (int) Math.ceil((double) list.size() / (double) size);
        }
    
        @Override
        public boolean isEmpty() {
            return list.isEmpty();
        }
    }
    
}

说明：

  1. 重点注意注释Adapted from http://code.google.com/p/guava-libraries/（改编自谷歌），也能发现代码和谷歌的com.google.common.collect.Lists#partition方法几乎一致，只是少了RandomAccessPartition的相关代码。

使用示例

// 生成包含1-400的列表
Long[] idArray = new Long[0];
for (long i = 1; i <= 400; i++) {
    idArray = ArrayUtils.add(idArray, i);
}
List<Long> allIdList = Arrays.asList(idArray);

// 每100条拆分1次
List<List<Long>> partitionIdList = ListUtils.partition(allIdList, 100);

注意事项

  1. 同谷歌的Lists#partition方法几乎一样。

平均分成N份

Stream的方法

使用示例

// 生成包含1-400的列表
Long[] idArray = new Long[0];
for (long i = 1; i <= 400; i++) {
    idArray = ArrayUtils.add(idArray, i);
}
List<Long> allIdList = Arrays.asList(idArray);

// 按每10个一组分割
Integer maxSize = 10;
// 计算切分次数
Integer limit = (allIdList.size() + maxSize - 1) / maxSize;
// Stream.iterate：生成无限序列
List<List<Long>> partitionIdList = Stream.iterate(0, n -> n + 1)
    // 限制序列的长度为limit
    .limit(limit)
    // 将一个序列流（sequential stream）转换为并行流（parallel stream），以便可以并行处理每个分组。
    .parallel()
    // 返回一个流，该流包含将给定函数应用于此流的元素的结果。 
    .map(
        // 使用skip(a * maxSize) 跳过前a * maxSize个元素，这样每个子列表都会从正确的位置开始。
        a -> allIdList.stream().skip(a * maxSize)
            // 限制每个子列表的最大大小
            .limit(maxSize)
            .parallel()
            .collect(Collectors.toList())
    )
    .collect(Collectors.toList());

说明：

  1. 核心方法是Stream.iterate和map的组合使用，以及skip和limit的链式调用来生成所需的子列表。并行流的使用（parallel()）是为了提高分割操作的性能，尤其是在处理大型列表时。

注意事项

  1. 需要注意的是，由于使用了并行流，生成的子列表内部元素的顺序可能会与原始列表不同，因为并行操作不保证元素的处理顺序。此外，如果原始列表非常大，使用并行流可能会带来线程管理的开销，实际性能提升需要根据具体情况进行测试。
付聪1210
关注
  • 18
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java拆分list_Java 8 stream 流 拆分list
weixin_36068796的博客
02-12 1878
背景：希望List 可以根据某个字段 进行分组 然后拆分使用Java 8 的流来做。java.util.stream.Collectors#groupingBy(java.util.function.Function super T,? extends K>, java.util.stream.Collector super T,A,D>)使用Group By 方法 默认会转换为 L...
java8 拆分list_Java 8 stream 流 拆分list
weixin_36102010的博客
02-26 4567
背景：希望List 可以根据某个字段 进行分组 然后拆分使用Java 8 的流来做。java.util.stream.Collectors#groupingBy(java.util.function.Function super T,? extends K>, java.util.stream.Collector super T,A,D>)使用Group By 方法 默认会转换为 L...
Java List拆分的方法
ServiceLogic的专栏
04-25 514
最近看rocketmq源码看到一段比较有意思的代码，对Java List拆分的代码，实现思路比较好。尝试自己去写，思路跟大多数的同学一样，都是取余拆分的方法，当然也可以用Google guava的Lists.partition方法。
拆分list的通用方法
vampire_wjp的博客
01-03 2021
拆分list的通用方法java中如何实现拆分list集合 java中如何实现拆分list集合 创建一个公共类就可以省去重复拆分不同类集合的麻烦了 /**允许使用的最大记录数量*/ private static final int SELECT_MAX_COUNT = 1000; /** * 按照count拆分成多个list * @param lists 需要拆分的数据...
按长度拆分List
zsy_495058005的博客
08-14 698
按条数拆分集合数据
java实现把一个List集合拆分成多个的操作
09-07
首先，我们来看一个简单的例子，这个例子中定义了一个名为`groupList`的方法，它接受一个List类型的参数，并将其拆分成多个子集合。方法的核心是使用了`subList()`方法，这是List接口的一个成员方法，它能返回一个新...
Map拆分List拆分
03-04
这种拆分方法可以显著提高计算效率，因为它允许数据在分布式系统中分散，每台机器只需处理一部分数据。例如，在Hadoop MapReduce中，InputFormat类负责将输入数据拆分为多个Map任务，每个任务处理一部分键值对。 接...
将list中的内容根据某一属性的值对list进行拆分
08-10
拆分list,将list中的内容根据某一属性的值对list进行拆分，分组
java实现日期拆分的方法
09-03
在拆分日期时，我们可以利用`Calendar`类的`add`方法按需增加日期，从而得到一个日期范围内的所有日期。这种方法在需要对日期进行迭代或计算的场景中非常实用。理解并熟练掌握这些基本的日期处理技术对于Java开发者...
python中多层嵌套列表的拆分方法
09-20
示例代码中的 `printlist` 函数可能是用于打印拆分后的列表，但其具体实现未给出，所以这里假设它与 `splitlist` 相同，只是没有 `return` 语句，仅用于打印结果。 在测试代码中，定义了一个多层嵌套列表 `list`，...
【C++】_list常用方法解析及模拟实现
Become Mad的博客
09-09 577
学习了string和vector，我们现在来学习list。它和string与vector不一样的地方就是它在物理上不是连续的，所以迭代器部分是要更加复杂的。
Java——踩坑Arrays.asList()
Wanankl的博客
09-06 464
查看源码可以看到，asList返回到ArrayList是一个内部类，继承了AbstractList，再查看源码，并没有是哪set,add,remove方法。查看源码可以看到，接收入参为泛型，而基本类型并没有集成Object。asList之后new一个List给他。进行装箱或者直接使用包装类型。new一个新的List。报了不支持的操作异常。
ArrayList,Vector, LinkedList 的存储性能和特性
Flying_Fish_roe的博客
09-07 1077
接口，允许存储有序的元素，并支持按索引访问、添加、修改和删除元素。尽管它们在功能上很相似，但在底层实现和性能特性上有显著差异。的元素不需要连续存储，而是通过节点（Node）互相连接，每个节点包含指向前一个和后一个节点的指针。在底层，它使用一个数组来存储元素，并在需要时自动扩容。是线程安全的，所有涉及修改元素的操作都被同步了，因此在多线程环境下可以直接使用。在进行按索引访问时性能非常高，但在插入和删除操作上可能表现不如链表。类似，也是基于动态数组实现的列表。是基于双向链表实现的列表，与。
C++入门9——list的使用
weixin_73629886的博客
09-04 1061
详细介绍C++list容器构造函数、迭代器、capacity、增删查改以及reverse、sort、merge、unique等函数的使用方法
【c++进阶[五]】list相关接口介绍及list和vector的对比
weixin_62196764的博客
09-08 775
本章重点本章重点讲解list的接口函数的熟悉，并且讲解list迭代器失效的特性和迭代器的功能分类以及算法库函数中谁能用谁不能用，最后比较一下list和vector的优势和劣势对上诉大致理解如下：1.list是一种可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2.list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立结点当中，在结点中通过指针指向其前一个元素和后一个元素。
WebAPI (一)DOM树、DOM对象，操作元素样式(style className,classList)。表单元素属性。自定义属性。间歇函数定时器
qq_44285582的博客
09-06 1190
获取DOM对象；操作元素内容、属性，通过style、类名className、classList控制CSS。操作表单元素属性，自定义属性。定时器setInterval。
STL-List常用接口
2301_77479435的博客
09-09 199
STL-List常用接口
ArrayList、LinkedList和Vector的区别
qq_58023907的博客
09-09 101
因为 LinkedList 的每个节点除了存储元素，还要存储两个指针，一个指向前驱，一个指向后继。Vector 和 ArrayList 相似，但属于强同步类，内部由于synchronized 同步关键字的存在，其方法都是同步的，保证了线程安全。如果程序本身是线程安全的，使用ArrayLIst是更好的选择。的新数组，然后将原数组中的数据拷贝到新数组中。如果能预估数据量，那么就给 ArrayList 分配一个较大的初始值，可以减少调整大小的开销，ArrayList支持缩容，但不会自动缩容。
【STL中容器汇总】map、list、vector等详解
最新发布
paidaxing_s的博客
09-09 461
STL中map、vector、list容器的详解
拆分list
05-26
可以使用Python的切片（slice）操作来拆分一个列表。例如，如果我们有一个列表`my_list`，想要将它拆分成两个列表，可以这样做： ``` my_list = [1, 2, 3, 4, 5, 6] split_index = 3 first_half = my_list[:split_index] second_half = my_list[split_index:] ``` 这样就将`my_list`拆分成了`[1, 2, 3]`和`[4, 5, 6]`两个列表。其中，`split_index`表示拆分的位置，也就是第二个列表的起始位置。`my_list[:split_index]`表示获取`my_list`中从0到`split_index`（不包括`split_index`）的元素，也就是第一个列表；`my_list[split_index:]`表示获取`my_list`中从`split_index`到末尾的元素，也就是第二个列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

付聪1210

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值