Java—将数组分组为更小的数组

这让我绞尽脑汁，想知道我是否能得到一个建议

子列表的分组将取决于原始组的大小，而原始组的大小将有所不同。 但如果我有这个：

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

我需要把这些分组成这个

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

如果我有这个：

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

我需要将它分成4部分，如下所示：

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

我需要找到每个小组中最小的一个，但我能处理

已编辑：很抱歉忘记提及，每次显示4个数组，但可以是3或5或其他值。 我认为这使得这个问题更加复杂。

变量 分组算法中有两个变量

输入数组的大小 组数或每组元素数 行为 根据输入参数对输入数组进行分组 如果数组的大小不是组数的精确倍数，则某些组的计数可能与其他组不同 给出了假设分组数的算法 初始化列表外部列表将包含N个列表 迭代输入数组 让输入数组的当前索引为i 将元素作为list.geti%N.addinput[i]添加到第i%N个列表中 密码 公共列表groupint[]输入，最终int groupCount{ 列表组=IntStream.range0，groupCount .mapToObji->new ArrayList .toList； 对于int i=0；i 输入数组的大小 组数或每组元素数 行为 根据输入参数对输入数组进行分组 如果数组的大小不是组数的精确倍数，则某些组的计数可能与其他组不同 给出了假设分组数的算法 初始化列表外部列表将包含N个列表 迭代输入数组 让输入数组的当前索引为i 将元素作为list.geti%N.addinput[i]添加到第i%N个列表中 密码 公共列表groupint[]输入，最终int groupCount{ 列表组=IntStream.range0，groupCount .mapToObji->new ArrayList .toList； 对于int i=0；i所以基本上：每次都要将一个数组拆分为四个数组

然后，您可以执行以下操作：

public static List<Integer[]> getSubArrays(int[] target, int numberOfArrays)
{
    System.out.println("+++");
    List<Integer[]> arrays = new ArrayList<>();     
    for(int i = 0; i<numberOfArrays; i++)
    {
        
        Integer[] partArray = new Integer[target.length/numberOfArrays];
                
        int itt = 0;
        for(int b = i; b<target.length; b=b+numberOfArrays)
        {
            partArray[itt++] = target[b];
        }
        
        System.out.println(Arrays.deepToString(partArray));
        arrays.add(partArray);
        
    }
    return arrays;
    
    
}

public static void main(String[] args)
{
    
    int[] firstArray =  {0,1,2,3,4,5,6,7,8,9,10,11};
    int[] secondArray = {0,1,2,3,4,5,6,7};
    int[] thirdArray = {0,1,2,3};
    int[] unequalArray = {0,1,2,3,4};
    
    getSubArrays(firstArray,4);
    getSubArrays(secondArray,4);
    getSubArrays(thirdArray,4);
    getSubArrays(unequalArray,4);
}

---

所以基本上：每次都要将一个数组拆分为四个数组

然后，您可以执行以下操作：

public static List<Integer[]> getSubArrays(int[] target, int numberOfArrays)
{
    System.out.println("+++");
    List<Integer[]> arrays = new ArrayList<>();     
    for(int i = 0; i<numberOfArrays; i++)
    {
        
        Integer[] partArray = new Integer[target.length/numberOfArrays];
                
        int itt = 0;
        for(int b = i; b<target.length; b=b+numberOfArrays)
        {
            partArray[itt++] = target[b];
        }
        
        System.out.println(Arrays.deepToString(partArray));
        arrays.add(partArray);
        
    }
    return arrays;
    
    
}

public static void main(String[] args)
{
    
    int[] firstArray =  {0,1,2,3,4,5,6,7,8,9,10,11};
    int[] secondArray = {0,1,2,3,4,5,6,7};
    int[] thirdArray = {0,1,2,3};
    int[] unequalArray = {0,1,2,3,4};
    
    getSubArrays(firstArray,4);
    getSubArrays(secondArray,4);
    getSubArrays(thirdArray,4);
    getSubArrays(unequalArray,4);
}

---

这里有三种解决方案，第一种是列表列表。第二个是数组的数组。如果提供的数组长度不是组大小的整数倍，则每个方法都会引发异常

第三种方法允许组大小的非整数倍数

所有方法都使用嵌套流来创建所需的结果

int[] v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

List<?> lists = groupLists(v, 4);
for (Object o : lists) {
    System.out.println(o);
}
int[][] vals = groupArrays(v, 4);
for (int[] o : vals) {
    System.out.println(Arrays.toString(o));
}

方法返回列表

public static List<List<Integer>> groupLists(final int[] vals,
        final int groupSize) {
    if (vals.length % groupSize != 0) {
        throw new IllegalArgumentException(
                "Array length not a multiple of group size");
    }

    return IntStream.range(0, groupSize)
            .mapToObj(i -> IntStream
                    .range(0, vals.length / groupSize)
                    .mapToObj(k -> Integer
                            .valueOf(vals[k * groupSize + i]))
                    .collect(Collectors.toList()))
            .collect(Collectors.toList());
}

此方法使用筛选器尽可能多地填充返回的列表，以避免生成索引越界异常

int[] v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
List<?> lists = groupListsPartial(v, 4);
for (Object o : lists) {
    System.out.println(o);
}

方法

public static List<List<Integer>> groupListsPartial(final int[] vals,
        final int groupSize) {
    
    return IntStream.range(0, groupSize)
            .mapToObj(i -> IntStream
                    .range(0, (vals.length+(groupSize-1)) / groupSize)
                    .filter(k->k*groupSize + i <vals.length)
                    .mapToObj(k -> Integer
                            .valueOf(vals[k * groupSize + i]))
                    .collect(Collectors.toList()))
            .collect(Collectors.toList());
}

---

这里有三种解决方案，第一种是列表列表。第二个是数组的数组。如果提供的数组长度不是组大小的整数倍，则每个方法都会引发异常

第三种方法允许组大小的非整数倍数

所有方法都使用嵌套流来创建所需的结果

int[] v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

List<?> lists = groupLists(v, 4);
for (Object o : lists) {
    System.out.println(o);
}
int[][] vals = groupArrays(v, 4);
for (int[] o : vals) {
    System.out.println(Arrays.toString(o));
}

方法返回列表

public static List<List<Integer>> groupLists(final int[] vals,
        final int groupSize) {
    if (vals.length % groupSize != 0) {
        throw new IllegalArgumentException(
                "Array length not a multiple of group size");
    }

    return IntStream.range(0, groupSize)
            .mapToObj(i -> IntStream
                    .range(0, vals.length / groupSize)
                    .mapToObj(k -> Integer
                            .valueOf(vals[k * groupSize + i]))
                    .collect(Collectors.toList()))
            .collect(Collectors.toList());
}

此方法使用筛选器尽可能多地填充返回的列表，以避免生成索引越界异常

int[] v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
List<?> lists = groupListsPartial(v, 4);
for (Object o : lists) {
    System.out.println(o);
}

方法

public static List<List<Integer>> groupListsPartial(final int[] vals,
        final int groupSize) {
    
    return IntStream.range(0, groupSize)
            .mapToObj(i -> IntStream
                    .range(0, (vals.length+(groupSize-1)) / groupSize)
                    .filter(k->k*groupSize + i <vals.length)
                    .mapToObj(k -> Integer
                            .valueOf(vals[k * groupSize + i]))
                    .collect(Collectors.toList()))
            .collect(Collectors.toList());
}

---

我相信我已经找到了一种方法，可以根据组数是4还是其他来实现这一点

  i++ // in an outer loop

 .....................
 ArrayList compareSet = new ArrayList();
 int nCrement = 0;
 int nX = 4; // is 4 right now but could be something else
 for (int j = 0; j < listSet.size(); j++) {  
 String value = (String) listSet.get(i + nCrement);   // i is increased above
       compareSet.add(value);
       nCrement = nCrement + nX;
       j = nCrement;
 }
  
 ..........

// compareSet checks each group to see which is smallest then continues outer loop to get another group

---

我相信我已经找到了一种方法，可以根据组数是4还是其他来实现这一点

  i++ // in an outer loop

 .....................
 ArrayList compareSet = new ArrayList();
 int nCrement = 0;
 int nX = 4; // is 4 right now but could be something else
 for (int j = 0; j < listSet.size(); j++) {  
 String value = (String) listSet.get(i + nCrement);   // i is increased above
       compareSet.add(value);
       nCrement = nCrement + nX;
       j = nCrement;
 }
  
 ..........

// compareSet checks each group to see which is smallest then continues outer loop to get another group

---

对不起，你能澄清一下每个小组中最小的一个吗？起初我以为你在问如何知道这4个组中的每个组包含多少个元素，但现在我不确定你想问什么。尝试在algo broWhat逻辑中使用模，你用它将初始数组拆分为多个组吗？抱歉，但你能澄清一下，找到每个较小组中最小的一个吗？起初我认为你在问如何知道这4组中的每一组包含多少个元素，但现在我不确定你在问什么。试着在你的algo broWhat逻辑中使用模，你用它来将初始数组拆分为组吗？你的输出有一个例外行。不能将包含五个元素的数组拆分为四个大小相同的数组；它不会每次都是4，但我可以确定它是4还是其他值。那么，这是动态的吗？因为您正在静态设置4个子数组，所以它不起作用吗？只要target.length/numberOfArray是平滑整数，它就起作用。您的输出有一个异常行。不能将包含五个元素的数组拆分为四个大小相同的数组；它不会每次都是4，但我可以确定它是4还是其他值。这就是动力吗

---

c不起作用，因为您正在静态设置4个子数组？只要target.length/numberOfArray是平滑整数，它就可以工作。