如何在java中将字符串数组拆分为小块数组？

How to split a string array into small chunk arrays in java?

提问by user2323036

Below is the example of the code snippet which needs the help

以下是需要帮助的代码片段示例

Example:

例子：

[1,2,3,4,5]

• if the chunk size is 1, [1,2,3,4,5]
• if the chunk size is 2, [1,2]and [3,4]and [5]
• if the chunk size is 3, [1,2,3]and [4,5]
• if the chunk size is 4, [1,2,3,4]and [5]

• 如果块大小是1，[1,2,3,4,5]
• 如果块大小是2，[1,2]与[3,4]和[5]
• 如果块大小是3，[1,2,3]并且[4,5]
• 如果块大小是4，[1,2,3,4]并且[5]

Java (from comment):

Java（来自评论）：

int counter = 0;
for (int i=0; i<array.length; i++) {
  if (count == chunksize) {
    //do something and initialize
    counter = 0;
  }
  counter++; 
}

回答by Reza

You can use Arrays.copyOfRange(int[] original, int from, int to)The code could be something like this:

您可以使用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))));
}          

回答by Mior

In general you could use Arrays.copyOfRangeto copy

一般来说，你可以使用Arrays.copyOfRange来复制

回答by newuser

Try this,

尝试这个，

Iterate it and check to give the chunk size.

迭代它并检查以给出块大小。

int chunkSize = userInput;

// iterate and check the condition

// 迭代并检查条件

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

回答by Niels Billen

This should do the trick

这应该可以解决问题

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;
}

Test code:

测试代码：

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);
}

Output:

输出：

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]

回答by GameDroids

Just stumbled upon this post after encountering the same question. Here is how I solved it (I used Arrays.copyOfRange():

在遇到同样的问题后偶然发现了这篇文章。这是我解决它的方法（我使用了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's it
}

And the results:

结果：

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]

回答by abdelrahman elattar

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;
    }

回答by rhel.user

Using pure Java 8:

使用纯 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]

回答by Amiya

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;
    }
}

Output

输出

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

回答by maheshmnj

   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);
}   

where list is a 1 dimension array and chunk is a nested array of size chunksize

其中列表是一维数组，块是大小的嵌套数组 chunksize

回答by Tim

If you don't mind importing Google Guava and converting to a List, there is a method for partitioning Lists:

如果你不介意导入Google Guava并转换成List，这里有一个Lists分区的方法：

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

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

The following may achieve the desired result:

以下可能达到预期的结果：

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