Как разделить массив списков на несколько * в Java? Я не хочу просматривать новые списки, но хочу создать их

Question

Итак, я много читал о том, как создать Arraylist из множества множественных arraylists, но не наоборот. Я обнаружил, что в некоторых кодах есть ПРОСМОТР некоторых массивов, основанный на одном массиве, но мне это представление не нужно. Мне нужно СОЗДАТЬ новый список arraylists (длиной 9) из arraylist (длиной 81). Дело в том, что мне нужно иметь возможность управлять каждым массивом отдельно.

static ArrayList<Integer> nums = new ArrayList<Integer>();

> Output : 
[0, 0, 1, 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0,
    > 6, 7, 0, 7, 8, 0, 8, 9, 1, 0, 2, 1, 1, 3, 1, 2, 4, 1, 3, 5, 1, 4, 6,
    > 1, 5, 7, 1, 6, 8, 1, 7, 9, 1, 8, 1, 2, 0, 3, 2, 1, 4, 2, 2, 5, 2, 3,
    > 6, 2, 4, 7, 2, 5, 8, 2, 6, 9, 2, 7, 1, 2, 8, 2, 3, 0, 4, 3, 1, 5, 3,
    > 2, 6, 3, 3, 7, 3, 4, 8, 3, 5, 9, 3, 6, 1, 3, 7, 2, 3, 8, 3, 4, 0, 5,
    > 4, 1, 6, 4, 2, 7, 4, 3, 8, 4, 4, 9, 4, 5, 1, 4, 6, 2, 4, 7, 3, 4, 8,
    > 4, 5, 0, 6, 5, 1, 7, 5, 2, 8, 5, 3, 9, 5, 4, 1, 5, 5, 2, 5, 6, 3, 5,
    > 7, 4, 5, 8, 5, 6, 0, 7, 6, 1, 8, 6, 2, 9, 6, 3, 1, 6, 4, 2, 6, 5, 3,
    > 6, 6, 4, 6, 7, 5, 6, 8, 6, 7, 0, 8, 7, 1, 9, 7, 2, 1, 7, 3, 2, 7, 4,
    > 3, 7, 5, 4, 7, 6, 5, 7, 7, 6, 7, 8, 7, 8, 0, 9, 8, 1, 1, 8, 2, 2, 8,
    > 3, 3, 8, 4, 4, 8, 5, 5, 8, 6, 6, 8, 7, 7, 8, 8, 8]

Я нашел этот код:

List<Integer> bigList = nums
List<List<Integer>> smallerLists = Lists.partition(bigList, 10);

Но по какой-то причине он не работает, так как я невозможно импортировать метод lists.partition () в библиотеке Guava

Answer 1

Вы можете сделать это следующим образом:

import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> bigList = List.of(0, 0, 1, 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 8, 0, 8, 9,
                1, 0, 2, 1, 1, 3, 1, 2, 4, 1, 3, 5, 1, 4, 6, 1, 5, 7, 1, 6, 8, 1, 7, 9, 1, 8, 1, 2, 0, 3, 2, 1, 4, 2, 2,
                5, 2, 3, 6, 2, 4, 7, 2, 5, 8, 2, 6, 9, 2, 7, 1, 2, 8, 2, 3, 0, 4, 3, 1, 5, 3, 2, 6, 3, 3, 7, 3, 4, 8, 3,
                5, 9, 3, 6, 1, 3, 7, 2, 3, 8, 3, 4, 0, 5, 4, 1, 6, 4, 2, 7, 4, 3, 8, 4, 4, 9, 4, 5, 1, 4, 6, 2, 4, 7, 3,
                4, 8, 4, 5, 0, 6, 5, 1, 7, 5, 2, 8, 5, 3, 9, 5, 4, 1, 5, 5, 2, 5, 6, 3, 5, 7, 4, 5, 8, 5, 6, 0, 7, 6, 1,
                8, 6, 2, 9, 6, 3, 1, 6, 4, 2, 6, 5, 3, 6, 6, 4, 6, 7, 5, 6, 8, 6, 7, 0, 8, 7, 1, 9, 7, 2, 1, 7, 3, 2, 7,
                4, 3, 7, 5, 4, 7, 6, 5, 7, 7, 6, 7, 8, 7, 8, 0, 9, 8, 1, 1, 8, 2, 2, 8, 3, 3, 8, 4, 4, 8, 5, 5, 8, 6, 6,
                8, 7, 7, 8, 8, 8);

        final AtomicInteger counter = new AtomicInteger(0);
        Collection<List<Integer>> smallerLists = bigList.stream()
                .collect(Collectors.groupingBy(i -> counter.getAndIncrement() / 9)).values();

        // Display the smaller lists
        smallerLists.stream().forEach(System.out::println);
    }
}

Вывод:

[0, 0, 1, 0, 1, 2, 0, 2, 3]
[0, 3, 4, 0, 4, 5, 0, 5, 6]
[0, 6, 7, 0, 7, 8, 0, 8, 9]
[1, 0, 2, 1, 1, 3, 1, 2, 4]
[1, 3, 5, 1, 4, 6, 1, 5, 7]
[1, 6, 8, 1, 7, 9, 1, 8, 1]
[2, 0, 3, 2, 1, 4, 2, 2, 5]
[2, 3, 6, 2, 4, 7, 2, 5, 8]
[2, 6, 9, 2, 7, 1, 2, 8, 2]
[3, 0, 4, 3, 1, 5, 3, 2, 6]
[3, 3, 7, 3, 4, 8, 3, 5, 9]
[3, 6, 1, 3, 7, 2, 3, 8, 3]
[4, 0, 5, 4, 1, 6, 4, 2, 7]
[4, 3, 8, 4, 4, 9, 4, 5, 1]
[4, 6, 2, 4, 7, 3, 4, 8, 4]
[5, 0, 6, 5, 1, 7, 5, 2, 8]
[5, 3, 9, 5, 4, 1, 5, 5, 2]
[5, 6, 3, 5, 7, 4, 5, 8, 5]
[6, 0, 7, 6, 1, 8, 6, 2, 9]
[6, 3, 1, 6, 4, 2, 6, 5, 3]
[6, 6, 4, 6, 7, 5, 6, 8, 6]
[7, 0, 8, 7, 1, 9, 7, 2, 1]
[7, 3, 2, 7, 4, 3, 7, 5, 4]
[7, 6, 5, 7, 7, 6, 7, 8, 7]
[8, 0, 9, 8, 1, 1, 8, 2, 2]
[8, 3, 3, 8, 4, 4, 8, 5, 5]
[8, 6, 6, 8, 7, 7, 8, 8, 8]

Answer 2

Самый простой подход заключается в следующем:

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

       List<List<Integer>> lists=   IntStream
                .iterate(0, a -> a < initialList.size(),
                        a -> a + 9)
                .mapToObj(a->new ArrayList<>(initialList.subList(a, a + 9)))
                .collect(Collectors.toList());

Answer 3

Существует метод для копирования разделов одного массива в другой: Arrays.copyOfRange Дополнительная информация: https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html

Для получения части 0 - 8:

Предположим, что int [] data - это массив данных, который вы хотите разделить.

int[] part.0_8 = Arrays.copyOfRange(data, 0, 8);

Answer 4

Я хотел бы рассмотреть возможность использования List.subList для его самостоятельного разбиения.

Учитывая набор данных длины X и желаемый размер раздела Y вы сможете сделать X / Y полные списки и 1 подсписок элементов X% Y (где X% Y! = 0).

private static List<List<Integer>> partition(List<Integer> data, int partitionListLen) {
    int fullPartitionQty = data.size() / partitionListLen;

    List<List<Integer>> partitions = new ArrayList<List<Integer>>();

    for (int listIndex = 0; listIndex < fullPartitionQty; listIndex++) {
        int startIndex = listIndex * partitionListLen;
        int endIndex = startIndex + partitionListLen;
        List<Integer> subList = data.subList(startIndex, endIndex);
       // System.out.println(subList);
        partitions.add(subList);
    }

    //Make one last list that includes the remainder content at the end of the list (if applicable)
    int remainder = data.size() % partitionListLen; 
    if (remainder != 0 ) {
        List<Integer> remainderContent = data.subList(data.size() - remainder, data.size());
        //System.out.println(remainderContent);
        partitions.add(remainderContent);
    }
    return partitions;
}


public static void main(String[] args) {
    //I use this below to generate data sets of these sizes.
    int[] dataSampleSizes = new int[] {0, 37, 81,82};

    //# of elements to put in each sublist.   
    int partitionListLen = 9;
    for (int dataSize : dataSampleSizes) {
        //This is the 'data' element
        List<Integer> genData = new ArrayList<Integer>();
        //Filling the data set with ints up to the requested size
        for (int dataPoint = 0; dataPoint < dataSize; dataPoint ++) {
            genData.add(dataPoint);
        }           
        //partition the generated list into chunk blocks
        List<List<Integer>> result = partition(genData, partitionListLen);

        //Courtesy output for validation.  This should be verified via unit test.
        System.out.println(String.format("Partitioning a list of %s elements into sublists of %s elements", dataSize, partitionListLen));           
        System.out.println(result.size() + " sublists created");
        System.out.println(result);
    }

}

Вывод:

Partitioning a list of 0 elements into sublists of 9 elements
0 sublists created
[]
Partitioning a list of 37 elements into sublists of 9 elements
5 sublists created
[[0, 1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23, 24, 25, 26], [27, 28, 29, 30, 31, 32, 33, 34, 35], [36]]
Partitioning a list of 81 elements into sublists of 9 elements
9 sublists created
[[0, 1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23, 24, 25, 26], [27, 28, 29, 30, 31, 32, 33, 34, 35], [36, 37, 38, 39, 40, 41, 42, 43, 44], [45, 46, 47, 48, 49, 50, 51, 52, 53], [54, 55, 56, 57, 58, 59, 60, 61, 62], [63, 64, 65, 66, 67, 68, 69, 70, 71], [72, 73, 74, 75, 76, 77, 78, 79, 80]]
Partitioning a list of 82 elements into sublists of 9 elements
10 sublists created
[[0, 1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23, 24, 25, 26], [27, 28, 29, 30, 31, 32, 33, 34, 35], [36, 37, 38, 39, 40, 41, 42, 43, 44], [45, 46, 47, 48, 49, 50, 51, 52, 53], [54, 55, 56, 57, 58, 59, 60, 61, 62], [63, 64, 65, 66, 67, 68, 69, 70, 71], [72, 73, 74, 75, 76, 77, 78, 79, 80], [81]]

Answer 5

Вы можете перебирать каждый элемент вручную, и если ваш подсписок содержит 9 элементов, вы создаете новый (вы можете заменить 9 на любое число, которое вам нравится). Не то чтобы при наличии ряда элементов, которые не делятся на 9, длина последнего подсписка в listOfLists будет <9. </p>

import java.util.ArrayList;

public class Test {
    public static void main(String s[]) {  
        int[] data = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };

        ArrayList<ArrayList<Integer>> listOfLists = new ArrayList<>();

        // Initialize to 9, so that we are forced to make a new sub-list initially
        int subListLength = 9;

        for (int i = 0; i < data.length; i++) {
            // If our previous sub list is full, make a new one and reset our subListLength
            if (subListLength == 9) {
                listOfLists.add(new ArrayList<Integer>());
                subListLength = 0;
            }

            // Add the next data element to the last generated sub-list and increment the sub list length
            listOfLists.get(listOfLists.size()-1).add(data[i]);
            subListLength++;
        }

        System.out.println(listOfLists);
    }  
}