Grouping of collection in java

Question

I Have a collection of integers(This can be a dynamic data source)

ArrayList<Int> data = [1,2,3,4,5,6,7]

What I am able to do

I can generate Equal data set like [1,2,3][4,5,6] [7] using the answer from here

Question: How can I give a limit to the number of groups like max 2 so that resulting output is [1,2,3,4][5,6,7]or [1,2,3][4,5,6,7]

what is preventing you to take the mid position and do a subList from 0 to mid and mid+1 to length-1? — SomeDude, Mar 08 '20 at 16:29

vcmkrtchyan · Accepted Answer · 2020-03-13T22:06:26.780

Instead of using a third party library, you can just iterate over the list, divide the items into subgroups until you reach the limit, and add the rest of the elements to the last group

private static List<List<Integer>> partition(List<Integer> list, int groupSize, int limit) {
    List<List<Integer>> result = new ArrayList<>();

    for (int i = 0; i < list.size(); i++) {
        int groupIndex = i / groupSize;
        if(groupIndex > limit - 1) {
            groupIndex = limit - 1;
        }

        if(groupIndex >= result.size()) {
            result.add(new ArrayList<>());
        }
        result.get(groupIndex).add(list.get(i));
    }

    return result;
}

WJS · Answer 2 · 2020-03-08T17:13:31.897

Here is what I came up with. Not certain how you wanted to divide up the "stragglers". Note that since sublists are just a view of the original list, they must be passed into a List constructor to be independent of the original list.

        List<Integer> list =
            new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8, 9));

        List<List<Integer>> lists = new ArrayList<>();
        int groupSize = 2;
        int ngroups = 6;
        for (int i = 0; i < ngroups && !list.isEmpty(); i++) {

            if (groupSize > list.size()) {
                groupSize = list.size();
            }
            List<Integer> sublist = new ArrayList<>(list.subList(0, groupSize));
            list = list.subList(groupSize,list.size());

            lists.add(sublist);

        }

        System.out.println(lists);

Md Golam Rahman Tushar · Answer 3 · 2020-03-08T17:17:53.297

Here the logic is if the size of the list is divisible by maximum partition number then by just partitioning the list to the Quotient value sizes solve the problem. But if not divisible then the extra values(reminder) are added to the first partition and the remaining list size is divisible by the maximum partition number and can be partitioned to Quotient sizes.

public static List<List<Integer>> performePartition(List<Integer> list, int mx) {
    if(list.size() % mx == 0) {
        return Lists.partition(list, list.size() / mx);
    }

    int reminder = list.size() % mx;
    int div = list.size() / mx;
    List<Integer> firstList = list.subList(0, div + reminder);

    List<List<Integer>> ret = new ArrayList<>();
    ret.add(firstList);
    List<Integer> remainingList = list.subList(div + reminder, list.size());
    ret.addAll(Lists.partition(remainingList, div));

    return ret;
}

Grouping of collection in java

3 Answers3