如何整数列表拆分为较小的块？ [英] How to split a list of integers to smaller chunks?

问题描述

我有一个整数与50个项目的清单：

 名单，其中，INT＆GT;表= CreateList（）;
 

我怎么可能把它分解成9个项目？

块

 名单，其中，名单，其中，INT＆GT;＆GT;块= CreateChucks（名单）;
 

我已经写了这个，有没有更好的办法？

 私有静态列表＆LT;列表＆LT; T＆GT;＆GT; GetChunks＆LT; T＆GT;（名单＆LT; T＆GT;清单，INT maxChunkSize = 1000）
    {
        VAR块=新的名单，其中，名单＆LT; T＆GT;＆GT;（）;

        的for（int i = 0; I＆LT; list.Count; I = I + maxChunkSize）
        {
            chunks.Add（list.Skip（ⅰ）。取（maxChunkSize）.ToList（））;
        }

        返回块;
    }
 

解决方案

我建议你使用的批运营商：// code.google.com/p/morelinq/wiki/OperatorsOverview相对=nofollow> MoreLINQ （可从的NuGet）：

 的IEnumerable＆LT; IEnumerable的＆LT; INT＆GT;＆GT; chuncks = list.Batch（9）;
 

如果你想列出的名单，那么你可以创建自己的分机：

 公共静态列表＆LT;列表＆LT; T＆GT;＆GT;批处理（这IEnumerable的＆LT; T＆GT;源，诠释BATCHSIZE）
{
    名单＆LT;列表＆LT; T＆GT;＆GT;结果=新名单，其中，名单＆LT; T＆GT;＆GT;（）;
    名单＆LT; T＆GT;一批=新的名单，其中，T＆GT;（BATCHSIZE）;

    的foreach（源牛逼项）
    {
        如果（batch.Count == BATCHSIZE）
        {
            result.Add（批）;
            一批=新的名单，其中，T＆GT;（BATCHSIZE）;
        }

        batch.Add（项目）;
    }

    如果（batch.Any（））
       result.Add（批）;

    返回结果;
}
 

您当前的实现有很大的缺点 - list.Skip（我）将枚举源列表，从开始的每一批要添加导致

I have a list of integers with 50 items:

List<int> list = CreateList();

How could I split it into chunks of 9 items?

List<List<int>> chunks = CreateChucks(list);

I've written this, is there any better way?

private static List<List<T>> GetChunks<T>(List<T> list, int maxChunkSize = 1000)
    {
        var chunks = new List<List<T>>();

        for (int i = 0; i < list.Count; i = i + maxChunkSize)
        {
            chunks.Add(list.Skip(i).Take(maxChunkSize).ToList());
        }

        return chunks;
    }

解决方案

I suggest you to use Batch operator of MoreLINQ (available from NuGet):

IEnumerable<IEnumerable<int>> chuncks = list.Batch(9);

If you want list of lists, then you can create own extension:

public static List<List<T>> Batch(this IEnumerable<T> source, int batchSize)
{
    List<List<T>> result = new List<List<T>>();
    List<T> batch = new List<T>(batchSize);

    foreach(T item in source)
    {
        if (batch.Count == batchSize)
        {
            result.Add(batch);
            batch = new List<T>(batchSize);                 
        }

        batch.Add(item);
    }

    if (batch.Any())
       result.Add(batch);

    return result;        
}

Your current implementation has big drawback - list.Skip(i) will enumerate source list from beginning for each batch you are adding to result.

这篇关于如何整数列表拆分为较小的块？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！