Chia danh sách thành các danh sách nhỏ hơn có kích thước N

Tôi đang cố gắng chia một danh sách thành một loạt các danh sách nhỏ hơn.

Vấn đề của tôi: Chức năng phân chia danh sách của tôi không phân chia chúng thành các danh sách có kích thước chính xác. Nó nên chia chúng thành các danh sách kích thước 30 nhưng thay vào đó nó chia chúng thành các danh sách kích thước 114?

Làm cách nào tôi có thể làm cho chức năng của mình chia một danh sách thành X số Danh sách có kích thước từ 30 trở xuống ?

public static List<List<float[]>> splitList(List <float[]> locations, int nSize=30) 
{       
    List<List<float[]>> list = new List<List<float[]>>();

    for (int i=(int)(Math.Ceiling((decimal)(locations.Count/nSize))); i>=0; i--) {
        List <float[]> subLocat = new List <float[]>(locations); 

        if (subLocat.Count >= ((i*nSize)+nSize))
            subLocat.RemoveRange(i*nSize, nSize);
        else subLocat.RemoveRange(i*nSize, subLocat.Count-(i*nSize));

        Debug.Log ("Index: "+i.ToString()+", Size: "+subLocat.Count.ToString());
        list.Add (subLocat);
    }

    return list;
}

Nếu tôi sử dụng hàm trên danh sách kích thước 144 thì đầu ra là:

Chỉ số: 4, Kích thước: 120
Chỉ số: 3, Kích thước: 114
Chỉ số: 2, Kích thước: 114
Chỉ số: 1, Kích thước: 114
Chỉ số: 0, Kích thước: 114

public static List<List<float[]>> SplitList(List<float[]> locations, int nSize=30)  
{        
    var list = new List<List<float[]>>(); 

    for (int i = 0; i < locations.Count; i += nSize) 
    { 
        list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i))); 
    } 

    return list; 
} 

Phiên bản chung:

public static IEnumerable<List<T>> SplitList<T>(List<T> locations, int nSize=30)  
{        
    for (int i = 0; i < locations.Count; i += nSize) 
    { 
        yield return locations.GetRange(i, Math.Min(nSize, locations.Count - i)); 
    }  
} 

Tôi sẽ đề nghị sử dụng phương pháp tiện ích mở rộng này để phân chia danh sách nguồn vào danh sách phụ theo kích thước khối được chỉ định:

/// <summary>
/// Helper methods for the lists.
/// </summary>
public static class ListExtensions
{
    public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize) 
    {
        return source
            .Select((x, i) => new { Index = i, Value = x })
            .GroupBy(x => x.Index / chunkSize)
            .Select(x => x.Select(v => v.Value).ToList())
            .ToList();
    }
}

Ví dụ: nếu bạn liệt kê danh sách 18 mục cho 5 mục trên mỗi phần, nó sẽ cung cấp cho bạn danh sách 4 danh sách phụ với các mục sau trong: 5-5-5-3.

làm thế nào về:

while(locations.Any())
{    
    list.Add(locations.Take(nSize).ToList());
    locations= locations.Skip(nSize).ToList();
}

Giải pháp Serj-Tm vẫn ổn, đây cũng là phiên bản chung dưới dạng phương thức mở rộng cho các danh sách (đặt nó vào một lớp tĩnh):

public static List<List<T>> Split<T>(this List<T> items, int sliceSize = 30)
{
    List<List<T>> list = new List<List<T>>();
    for (int i = 0; i < items.Count; i += sliceSize)
        list.Add(items.GetRange(i, Math.Min(sliceSize, items.Count - i)));
    return list;
} 

Tôi thấy câu trả lời được chấp nhận (Serj-Tm) mạnh mẽ nhất, nhưng tôi muốn đề xuất một phiên bản chung.

public static List<List<T>> splitList<T>(List<T> locations, int nSize = 30)
{
    var list = new List<List<T>>();

    for (int i = 0; i < locations.Count; i += nSize)
    {
        list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i)));
    }

    return list;
}

Thư viện MoreLinq có phương thức gọi là Batch

List<int> ids = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; // 10 elements
int counter = 1;
foreach(var batch in ids.Batch(2))
{
    foreach(var eachId in batch)
    {
        Console.WriteLine("Batch: {0}, Id: {1}", counter, eachId);
    }
    counter++;
}

Kết quả là

Batch: 1, Id: 1
Batch: 1, Id: 2
Batch: 2, Id: 3
Batch: 2, Id: 4
Batch: 3, Id: 5
Batch: 3, Id: 6
Batch: 4, Id: 7
Batch: 4, Id: 8
Batch: 5, Id: 9
Batch: 5, Id: 0

ids được chia thành 5 khối với 2 yếu tố.

Tôi có một phương pháp chung có thể sử dụng bất kỳ loại nào bao gồm float và nó đã được thử nghiệm theo đơn vị, hy vọng nó sẽ giúp:

    /// <summary>
    /// Breaks the list into groups with each group containing no more than the specified group size
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="values">The values.</param>
    /// <param name="groupSize">Size of the group.</param>
    /// <returns></returns>
    public static List<List<T>> SplitList<T>(IEnumerable<T> values, int groupSize, int? maxCount = null)
    {
        List<List<T>> result = new List<List<T>>();
        // Quick and special scenario
        if (values.Count() <= groupSize)
        {
            result.Add(values.ToList());
        }
        else
        {
            List<T> valueList = values.ToList();
            int startIndex = 0;
            int count = valueList.Count;
            int elementCount = 0;

            while (startIndex < count && (!maxCount.HasValue || (maxCount.HasValue && startIndex < maxCount)))
            {
                elementCount = (startIndex + groupSize > count) ? count - startIndex : groupSize;
                result.Add(valueList.GetRange(startIndex, elementCount));
                startIndex += elementCount;
            }
        }


        return result;
    }

Mặc dù có rất nhiều câu trả lời ở trên thực hiện công việc, nhưng tất cả chúng đều thất bại khủng khiếp trên một chuỗi không bao giờ kết thúc (hoặc một chuỗi thực sự dài). Sau đây là một triển khai hoàn toàn trực tuyến đảm bảo độ phức tạp của bộ nhớ và thời gian tốt nhất có thể. Chúng tôi chỉ lặp lại nguồn liệt kê chính xác một lần và sử dụng lợi nhuận để đánh giá lười biếng. Người tiêu dùng có thể loại bỏ danh sách trên mỗi lần lặp làm cho dung lượng bộ nhớ bằng với danh sách w / batchSizesố phần tử.

public static IEnumerable<List<T>> BatchBy<T>(this IEnumerable<T> enumerable, int batchSize)
{
    using (var enumerator = enumerable.GetEnumerator())
    {
        List<T> list = null;
        while (enumerator.MoveNext())
        {
            if (list == null)
            {
                list = new List<T> {enumerator.Current};
            }
            else if (list.Count < batchSize)
            {
                list.Add(enumerator.Current);
            }
            else
            {
                yield return list;
                list = new List<T> {enumerator.Current};
            }
        }

        if (list?.Count > 0)
        {
            yield return list;
        }
    }
}

EDIT: Vừa mới nhận ra OP hỏi về việc chia List<T>nhỏ hơn List<T>, vì vậy những nhận xét của tôi về số lượng vô hạn không thể áp dụng cho OP, nhưng có thể giúp những người khác kết thúc tại đây. Những bình luận này đã phản ứng với các giải pháp được đăng khác sử dụng IEnumerable<T>làm đầu vào cho chức năng của chúng, nhưng liệt kê nguồn vô số nhiều lần.

Ngoài ra sau khi nhận xét rất hữu ích của mhand ở cuối

Câu trả lời gốc

Mặc dù hầu hết các giải pháp có thể hoạt động, tôi nghĩ rằng chúng không hiệu quả lắm. Giả sử nếu bạn chỉ muốn một vài mục đầu tiên của một vài khối đầu tiên. Sau đó, bạn sẽ không muốn lặp lại tất cả (hàng triệu) mục trong chuỗi của mình.

Sau đây sẽ liệt kê tối đa hai lần: một lần cho Lấy và một lần cho Bỏ qua. Nó sẽ không liệt kê bất kỳ yếu tố nào nhiều hơn bạn sẽ sử dụng:

public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource>
    (this IEnumerable<TSource> source, int chunkSize)
{
    while (source.Any())                     // while there are elements left
    {   // still something to chunk:
        yield return source.Take(chunkSize); // return a chunk of chunkSize
        source = source.Skip(chunkSize);     // skip the returned chunk
    }
}

Bao nhiêu lần điều này sẽ liệt kê trình tự?

Giả sử bạn chia nguồn của bạn thành nhiều phần chunkSize. Bạn liệt kê chỉ N khối đầu tiên. Từ mỗi khối được liệt kê, bạn sẽ chỉ liệt kê các phần tử M đầu tiên.

While(source.Any())
{
     ...
}

Bất kỳ sẽ nhận được Trình liệt kê, thực hiện 1 MoveNext () và trả về giá trị được trả về sau khi Loại bỏ Trình liệt kê. Điều này sẽ được thực hiện N lần

yield return source.Take(chunkSize);

Theo nguồn tham khảo này sẽ làm một cái gì đó như:

public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
{
    return TakeIterator<TSource>(source, count);
}

static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
{
    foreach (TSource element in source)
    {
        yield return element;
        if (--count == 0) break;
    }
}

Điều này không làm được gì nhiều cho đến khi bạn bắt đầu liệt kê Chunk tìm nạp. Nếu bạn tìm nạp một vài Chun, nhưng quyết định không liệt kê Chunk đầu tiên, thì foreach không được thực thi, vì trình gỡ lỗi của bạn sẽ hiển thị cho bạn.

Nếu bạn quyết định lấy các phần tử M đầu tiên của đoạn đầu tiên thì lợi nhuận mang lại được thực hiện chính xác M lần. Điều này có nghĩa là:

• lấy điều tra viên
• gọi MoveNext () và M lần hiện tại.
• Vứt bỏ điều tra viên

Sau khi phần đầu tiên đã được trả lại, chúng ta bỏ qua phần đầu tiên này:

source = source.Skip(chunkSize);

Một lần nữa: chúng ta sẽ xem nguồn tham khảo để tìmskipiterator

static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
{
    using (IEnumerator<TSource> e = source.GetEnumerator()) 
    {
        while (count > 0 && e.MoveNext()) count--;
        if (count <= 0) 
        {
            while (e.MoveNext()) yield return e.Current;
        }
    }
}

Như bạn thấy, các SkipIteratorcuộc gọi MoveNext()một lần cho mọi phần tử trong Chunk. Nó không gọi Current.

Vì vậy, mỗi Chunk chúng ta thấy rằng những điều sau đây được thực hiện:

• Bất kỳ (): GetEnumerator; 1 MoveNext (); Vứt bỏ ĐTVN;

• Lấy():

  • không có gì nếu nội dung của đoạn không được liệt kê.

  • Nếu nội dung được liệt kê: GetEnumerator (), một MoveNext và một Hiện tại cho mỗi mục liệt kê, liệt kê liệt kê;

  • Bỏ qua (): cho mỗi đoạn được liệt kê (KHÔNG phải nội dung của đoạn): GetEnumerator (), MoveNext () chunkSize lần, không có Hiện tại! Vứt bỏ điều tra viên

Nếu bạn nhìn vào những gì xảy ra với điều tra viên, bạn sẽ thấy rằng có rất nhiều cuộc gọi đến MoveNext () và chỉ gọi Currentcho các mục TSource mà bạn thực sự quyết định truy cập.

Nếu bạn lấy N Chunks có kích thước chunkSize, thì hãy gọi tới MoveNext ()

• N lần cho bất kỳ ()
• chưa có thời gian cho Take, miễn là bạn không liệt kê Chunks
• N lần chunkSize cho Skip ()

Nếu bạn quyết định chỉ liệt kê các phần tử M đầu tiên của mỗi phần được tìm nạp, thì bạn cần gọi MoveNext M lần cho mỗi phần được liệt kê.

Tổng số

MoveNext calls: N + N*M + N*chunkSize
Current calls: N*M; (only the items you really access)

Vì vậy, nếu bạn quyết định liệt kê tất cả các yếu tố của tất cả các khối:

MoveNext: numberOfChunks + all elements + all elements = about twice the sequence
Current: every item is accessed exactly once

MoveNext có nhiều công việc hay không, tùy thuộc vào loại chuỗi nguồn. Đối với danh sách và mảng, đó là một chỉ số tăng đơn giản, có thể là kiểm tra ngoài phạm vi.

Nhưng nếu IEnumerable của bạn là kết quả của truy vấn cơ sở dữ liệu, hãy đảm bảo rằng dữ liệu thực sự được vật chất hóa trên máy tính của bạn, nếu không dữ liệu sẽ được tìm nạp nhiều lần. DbContext và Dapper sẽ chuyển đúng dữ liệu sang quy trình cục bộ trước khi có thể truy cập được. Nếu bạn liệt kê trình tự tương tự nhiều lần, nó không được tìm nạp nhiều lần. Dapper trả về một đối tượng là Danh sách, DbContext nhớ rằng dữ liệu đã được tìm nạp.

Tùy thuộc vào Kho lưu trữ của bạn, liệu có nên gọi AsEnumerable () hoặc ToLists () trước khi bạn bắt đầu phân chia các mục trong Chunks

public static IEnumerable<IEnumerable<T>> SplitIntoSets<T>
    (this IEnumerable<T> source, int itemsPerSet) 
{
    var sourceList = source as List<T> ?? source.ToList();
    for (var index = 0; index < sourceList.Count; index += itemsPerSet)
    {
        yield return sourceList.Skip(index).Take(itemsPerSet);
    }
}

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> items, int maxItems)
{
    return items.Select((item, index) => new { item, index })
                .GroupBy(x => x.index / maxItems)
                .Select(g => g.Select(x => x.item));
}

Cái này thì sao? Ý tưởng là chỉ sử dụng một vòng lặp. Và, ai biết được, có thể bạn chỉ sử dụng các triển khai IList xuyên suốt mã của mình và bạn không muốn chuyển sang Danh sách.

private IEnumerable<IList<T>> SplitList<T>(IList<T> list, int totalChunks)
{
    IList<T> auxList = new List<T>();
    int totalItems = list.Count();

    if (totalChunks <= 0)
    {
        yield return auxList;
    }
    else 
    {
        for (int i = 0; i < totalItems; i++)
        {               
            auxList.Add(list[i]);           

            if ((i + 1) % totalChunks == 0)
            {
                yield return auxList;
                auxList = new List<T>();                
            }

            else if (i == totalItems - 1)
            {
                yield return auxList;
            }
        }
    }   
}

Một lần nữa

public static IList<IList<T>> SplitList<T>(this IList<T> list, int chunkSize)
{
    var chunks = new List<IList<T>>();
    List<T> chunk = null;
    for (var i = 0; i < list.Count; i++)
    {
        if (i % chunkSize == 0)
        {
            chunk = new List<T>(chunkSize);
            chunks.Add(chunk);
        }
        chunk.Add(list[i]);
    }
    return chunks;
}

public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize)
    {           
        var result = new List<List<T>>();
        for (int i = 0; i < source.Count; i += chunkSize)
        {
            var rows = new List<T>();
            for (int j = i; j < i + chunkSize; j++)
            {
                if (j >= source.Count) break;
                rows.Add(source[j]);
            }
            result.Add(rows);
        }
        return result;
    }

List<int> list =new List<int>(){1,2,3,4,5,6,7,8,9,10,12};
Dictionary<int,List<int>> dic = new Dictionary <int,List<int>> ();
int batchcount = list.Count/2; //To List into two 2 parts if you want three give three
List<int> lst = new List<int>();
for (int i=0;i<list.Count; i++)
{
lstdocs.Add(list[i]);
if (i % batchCount == 0 && i!=0)
{
Dic.Add(threadId, lstdocs);
lst = new List<int>();**strong text**
threadId++;
}
}
Dic.Add(threadId, lstdocs);

Tôi đã gặp phải nhu cầu tương tự và tôi đã sử dụng kết hợp các phương thức Skip () và Take () của Linq . Tôi nhân số lượng tôi lấy với số lần lặp cho đến nay và điều đó cho tôi số lượng mục cần bỏ qua, sau đó tôi chọn nhóm tiếp theo.

        var categories = Properties.Settings.Default.MovementStatsCategories;
        var items = summariesWithinYear
            .Select(s =>  s.sku).Distinct().ToList();

        //need to run by chunks of 10,000
        var count = items.Count;
        var counter = 0;
        var numToTake = 10000;

        while (count > 0)
        {
            var itemsChunk = items.Skip(numToTake * counter).Take(numToTake).ToList();
            counter += 1;

            MovementHistoryUtilities.RecordMovementHistoryStatsBulk(itemsChunk, categories, nLogger);

            count -= numToTake;
        }

Dựa trên câu trả lời của Dimitry Pavlov tôi sẽ xóa .ToList(). Và cũng tránh các lớp ẩn danh. Thay vào đó tôi thích sử dụng một cấu trúc không yêu cầu cấp phát bộ nhớ heap. (A ValueTuplecũng sẽ làm công việc.)

public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource>(this IEnumerable<TSource> source, int chunkSize)
{
    if (source is null)
    {
        throw new ArgumentNullException(nameof(source));
    }
    if (chunkSize <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(chunkSize), chunkSize, "The argument must be greater than zero.");
    }

    return source
        .Select((x, i) => new ChunkedValue<TSource>(x, i / chunkSize))
        .GroupBy(cv => cv.ChunkIndex)
        .Select(g => g.Select(cv => cv.Value));
} 

[StructLayout(LayoutKind.Auto)]
[DebuggerDisplay("{" + nameof(ChunkedValue<T>.ChunkIndex) + "}: {" + nameof(ChunkedValue<T>.Value) + "}")]
private struct ChunkedValue<T>
{
    public ChunkedValue(T value, int chunkIndex)
    {
        this.ChunkIndex = chunkIndex;
        this.Value = value;
    }

    public int ChunkIndex { get; }

    public T Value { get; }
}

Điều này có thể được sử dụng như sau chỉ lặp lại bộ sưu tập một lần và cũng không phân bổ bất kỳ bộ nhớ quan trọng nào.

int chunkSize = 30;
foreach (var chunk in collection.ChunkBy(chunkSize))
{
    foreach (var item in chunk)
    {
        // your code for item here.
    }
}

Nếu một danh sách cụ thể là thực sự cần thiết thì tôi sẽ làm như thế này:

int chunkSize = 30;
var chunkList = new List<List<T>>();
foreach (var chunk in collection.ChunkBy(chunkSize))
{
    // create a list with the correct capacity to be able to contain one chunk
    // to avoid the resizing (additional memory allocation and memory copy) within the List<T>.
    var list = new List<T>(chunkSize);
    list.AddRange(chunk);
    chunkList.Add(list);
}