Как разбить массив строк на небольшие массивы блоков в java?

Ответ 1

Вы можете использовать Arrays.copyOfRange(int[] original, int from, int to) Код может быть примерно таким:

int chunk = 2; // chunk size to divide
for(int i=0;i<original.length;i+=chunk){
    System.out.println(Arrays.toString(Arrays.copyOfRange(original, i, Math.min(original.length,i+chunk))));
}          

Ответ 2

Просто наткнулся на этот пост, столкнувшись с тем же вопросом. Вот как я его решил (я использовал Arrays.copyOfRange():

public static int[][] splitArray(int[] arrayToSplit, int chunkSize){
    if(chunkSize<=0){
        return null;  // just in case :)
    }
    // first we have to check if the array can be split in multiple 
    // arrays of equal 'chunk' size
    int rest = arrayToSplit.length % chunkSize;  // if rest>0 then our last array will have less elements than the others 
    // then we check in how many arrays we can split our input array
    int chunks = arrayToSplit.length / chunkSize + (rest > 0 ? 1 : 0); // we may have to add an additional array for the 'rest'
    // now we know how many arrays we need and create our result array
    int[][] arrays = new int[chunks][];
    // we create our resulting arrays by copying the corresponding 
    // part from the input array. If we have a rest (rest>0), then
    // the last array will have less elements than the others. This 
    // needs to be handled separately, so we iterate 1 times less.
    for(int i = 0; i < (rest > 0 ? chunks - 1 : chunks); i++){
        // this copies 'chunk' times 'chunkSize' elements into a new array
        arrays[i] = Arrays.copyOfRange(arrayToSplit, i * chunkSize, i * chunkSize + chunkSize);
    }
    if(rest > 0){ // only when we have a rest
        // we copy the remaining elements into the last chunk
        arrays[chunks - 1] = Arrays.copyOfRange(arrayToSplit, (chunks - 1) * chunkSize, (chunks - 1) * chunkSize + rest);
    }
    return arrays; // that it
}

И результаты:

chunkSize = 1
[1]
[2]
[3]
[4]
[5]

chunkSize = 2
[1, 2]
[3, 4]
[5]

chunkSize = 3
[1, 2, 3]
[4, 5]

chunkSize = 4
[1, 2, 3, 4]
[5]

chunkSize = 5
[1, 2, 3, 4, 5]

chunkSize = 6
[1, 2, 3, 4, 5]

Ответ 3

Если вы не возражаете против импорта Google Guava и преобразования в список, есть способ разделения списков:

https://google.github.io/guava/releases/27.1-jre/api/docs/com/google/common/collect/Lists.html#partition-java.util.List-int-

Следующие могут достичь желаемого результата:

List<Integer> listToBeSplit = Arrays.asList(sourceArray);
int chunkSize = 3;
Lists.partition(listToBeSplit, chunkSize);

Ответ 4

Попробуй это,

Итерируйте его и проверьте, чтобы размер куска.

int chunkSize = userInput;

//итерация и проверка условия

char[] resultArray = Arrays.copyOfRange(inputArray, start, end);
start = start + end;  // check whether the start will exceeds the length of the array

Ответ 5

Используя чистую Java 8:

public class Chunk {
    public static void main(String[] args) {
        int[] input = {1,2,3,4,78,999,-1,456};
        int chunkSize = 3;

        int[][] chunked = chunk(input, chunkSize);

        Arrays.stream(chunked)
                .map(Arrays::toString)
                    .forEach(System.out::println);
    }

    public static int[][] chunk(int[] input, int chunkSize) {
        return IntStream.iterate(0, i -> i + chunkSize)
                .limit((long) Math.ceil((double) input.length / chunkSize))
                .mapToObj(j -> Arrays.copyOfRange(input, j, j + chunkSize > input.length ? input.length : j + chunkSize))
                .toArray(int[][]::new);
    }
}

[1, 2, 3]
[4, 78, 999]
[-1, 456]

Ответ 6

В общем случае вы можете использовать Arrays.copyOfRange для копирования

Ответ 7

Это должно сделать трюк

public static List<String> split(String string, int chunk) {
    Pattern pattern = Pattern.compile("(([0-9]+,){" + (chunk - 1)
            + "}[0-9]+)|[0-9]+");
    Matcher matcher = pattern.matcher(string);

    List<String> result = new ArrayList<String>();
    while (matcher.find())
        result.add("[" + matcher.group() + "]");

    return result;
}

Тестовый код:

for (int chunkSize = 1; chunkSize < 6; ++chunkSize) {
    System.out.println("test for chunk size: " + chunkSize);
    for (String string : split("[1,2,3,4,5]", chunkSize))
        System.out.format("\t%s\n", string);
}

Вывод:

test for chunk size: 1
    [1]
    [2]
    [3]
    [4]
    [5]
test for chunk size: 2
    [1,2]
    [3,4]
    [5]
test for chunk size: 3
    [1,2,3]
    [4]
    [5]
test for chunk size: 4
    [1,2,3,4]
    [5]
test for chunk size: 5
    [1,2,3,4,5]

Ответ 8

public static int[][] chunkArray(int[] array, int chunkSize) {
        // first we need to get number of chunks by dividing length by chunkSize.
        int numOfChunks = (int)Math.ceil((double)array.length / chunkSize);
// we declare 2d array to save in the chunks
        int[][] output = new int[numOfChunks][];

        for(int i = 0; i < numOfChunks; i++) {
            int start = i * chunkSize;
            int length = Math.min(array.length - start, chunkSize);

            int[] temp = new int[length];
            System.arraycopy(array, start, temp, 0, length);
            output[i] = temp;
        }

        return output;
    }

Ответ 9

public class ArrayChunk {
    public static void main(String[] args) {

        String[][] chunked = chunkArray("1,2,3,4,5,6,7,8,9".split(","), 2);
        System.out.println("Array with chunk size 2");
        Arrays.stream(chunked).forEach(strings -> System.out.println(String.join(",", strings)));

        chunked = chunkArray("1,2,3,4,5,6,7,8,9".split(","), 3);
        System.out.println("Array with chunk size 3");
        Arrays.stream(chunked).forEach(strings -> System.out.println(String.join(",", strings)));

        chunked = chunkArray("1,2,3,4,5,6,7,8,9".split(","), 4);
        System.out.println("Array with chunk size 4");
        Arrays.stream(chunked).forEach(strings -> System.out.println(String.join(",", strings)));

        chunked = chunkArray("1,2,3,4,5,6,7,8,9".split(","), 5);
        System.out.println("Array with chunk size 5");
        Arrays.stream(chunked).forEach(strings -> System.out.println(String.join(",", strings)));
    }

    private static String[][] chunkArray(String[] array, int chunkSize) {
        int chunkedSize = (int) Math.ceil((double) array.length / chunkSize); // chunked array size
        String[][] chunked = new String[chunkedSize][chunkSize];
        for (int index = 0; index < chunkedSize; index++) {
            String[] chunk = new String[chunkSize]; // small array
            System.arraycopy(array, index * chunkSize, chunk, 0, Math.min(chunkSize, array.length - index * chunkSize));
            chunked[index] = chunk;
        }
        return chunked;
    }
}

Выход

Array with chunk size 2
1,2
3,4
5,6
7,8
9,null

Array with chunk size 3
1,2,3
4,5,6
7,8,9

Array with chunk size 4
1,2,3,4
5,6,7,8
9,null,null,null

Array with chunk size 5
1,2,3,4,5
6,7,8,9,null

Ответ 10

   for(int i=0;i<list.size();){
    ArrayList<Integer>row = new ArrayList<Integer>();
    int k=0;
    while(k < chunksize){
        chunk.add(list.get(i));
        i++;
        k++;
    }
    System.out.println(chunk);
    nestedlist.add(chunk);
}   

где список массив 1 размер и кусок является вложенной массив размера chunksize

Ответ 11

Простой способ сделать это,

    int loopcount = employeeList.size() / constCount;
    int leftcount = employeeList.size() % constCount;
    for (int i = 0; i < loopcount - 1; i++) {
        //query.setParameterList("values"+i, employeeList.subList(tempCount, tempCount + constCount));

        System.out.println(employeeList.subList(tempCount, tempCount + constCount));
        tempCount = tempCount + 1000;
    }