Java 如何更改二维阵列的大小？

我如何改变2d数组的大小，而不重新排列数组中主要使用for循环和内置方法的数字？ 例如，{4,5,6,7,10}，{8,4,3,9,13}}变成{4}，{5,6}，{7,10,8}，{4,3,9,13}

---

我尝试将二维阵列分成两个独立的部分，然后将其添加回新的二维阵列。我不确定如何创建第二个2d数组。

如果我理解您的问题，我建议您使用

列表

，例如ArrayList，而不是纯数组，您可以这样设置聚合：

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

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

    //  add {4,5,6,7,10} to array, result = {{4,5,6,7,10}}
    values = new ArrayList<>(Arrays.asList(4,5,6,7,10));
    matrix.add(values);

    //  add {8,4,3,9,13} to last array, result = {{4,5,6,7,10}, {8,4,3,9,13}}
    values = new ArrayList<>(Arrays.asList(8,4,3,9,13));
    matrix.add(values);

    System.out.println("start="+ matrix);

    //  reset array or you can use another array to copy
    matrix = new ArrayList<>();

    values = new ArrayList<>(Arrays.asList(4));
    matrix.add(values);

    values = new ArrayList<>(Arrays.asList(5,6));
    matrix.add(values);

    values = new ArrayList<>(Arrays.asList(7,10,8));
    matrix.add(values);

    values = new ArrayList<>(Arrays.asList(4,3,9,13));
    matrix.add(values);

    System.out.println("end="+ matrix);

List matrix=new ArrayList（）；
列表值=新的ArrayList（）；
//将{4,5,6,7,10}添加到数组中，结果={4,5,6,7,10}
值=新的ArrayList（Arrays.asList（4,5,6,7,10））；
矩阵。添加（值）；
//将{8,4,3,9,13}添加到最后一个数组，结果={4,5,6,7,10}，{8,4,3,9,13}
值=新的ArrayList（Arrays.asList（8,4,3,9,13））；
矩阵。添加（值）；
System.out.println（“开始=”+矩阵）；
//重置数组，也可以使用其他数组进行复制
矩阵=新的ArrayList（）；
values=newarraylist（Arrays.asList（4））；
矩阵。添加（值）；
values=newarraylist（Arrays.asList（5,6））；
矩阵。添加（值）；
values=newarraylist（Arrays.asList（7,10,8））；
矩阵。添加（值）；
值=新的ArrayList（Arrays.asList（4,3,9,13））；
矩阵。添加（值）；
System.out.println（“end=”+矩阵）；

输出： 开始=[[4,5,6,7,10]，[8,4,3,9,13]] end=[[4]、[5,6]、[7,10,8]、[4,3,9,13]]

可能不推荐的解决方案

展平二维阵列

按求和序列分组收集

使用单个原子计数器可能会有所改进（我无法思考）

导入java.util.array；
导入java.util.Collection；
导入java.util.List；
导入java.util.concurrent.AtomicInteger；
导入java.util.stream.collector；
公共类数组Resize{
公共静态void main（字符串[]args）{
整数[][]输入=新整数[][{{10,11,12,13,14}，{15,16,17,18,19}；
AtomicInteger索引=新的AtomicInteger（0）；
AtomicInteger组=新的AtomicInteger（1）；
Collection out=Arrays.stream（输入）
.flatMap（i->Arrays.stream（i））//展平
.collect（收集器）。分组方式（i->{
final int currentIndex=index.getAndIncrement（）；
return（group.get（）*（group.get（）+1））/2==currentIndex
？group.incrementAndGet（）//如果索引与范围的总和匹配，则增量组
：group.get（）；//返回组
}))
.values（）；
System.out.println（out）；
}
}

输出必须是任何整数数组

导入java.util.array；
导入java.util.concurrent.AtomicInteger；
导入java.util.stream.collector；
公共类数组Resize{
公共静态void main（字符串[]args）{
整数[][]输入=新整数[][{{10,11,12,13,14}，{15,16,17,18,19}；
AtomicInteger索引=新的AtomicInteger（0）；
AtomicInteger组=新的AtomicInteger（1）；
整数[][]输出=数组.流（输入）
.flatMap（i->Arrays.stream（i））//展平
.collect（收集器）。分组方式（i->{
final int currentIndex=index.getAndIncrement（）；
return（group.get（）*（group.get（）+1））/2==currentIndex
？group.incrementAndGet（）//如果索引与范围的总和匹配，则增量组
：group.get（）；//返回组
})).values（）.stream（）//流集合
.map（subgroup->subgroup.toArray（新整数[0]）//将子组映射到数组
.collect（Collectors.toList（））//收集为数组列表
.toArray（新整数[0][0]）；//转换为数组
System.out.println（Arrays.deepToString（output））；
}
}

免责声明

我不会在我的任何生产系统中编写上述代码

在当前状态下，它将因并行流使用而失败

使用索引计数的解决方案

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.stream.collector；
公共类数组Resize{
公共静态void main（字符串[]args）{
整数[][]输入=新整数[][{{10,11,12,13,14}，{15,16,17,18,19}；
List flatten=Arrays.stream（input）.flatMap（i->Arrays.stream（i））.collect（Collectors.toList（））；
List temporary=new ArrayList（）；
最终整数计数=展平的.size（）；
int start=0；
int范围=1；
while（开始<计数）{
临时.add（展平的.subList（start，Math.min（start+range，count））.toArray（新整数[0]）；
开始+=范围；
range++；
}
整数[][]结果=临时.toArray（新整数[0][0]）；
System.out.println（Arrays.deepToString（result））；
}
}

有很多方法可以做到这一点。这是一个适用于任何三角形数的函数
源于二维数组的元素的集合

首先，将它们全部展平为单个阵列

int[] oneD = Arrays.stream(src).flatMapToInt(Arrays::stream).toArray();

然后反转长度，该长度应为

k

，其中

k=n（n+1）/2

行数如下所示。并且2D结果被部分分配

int rows = (int)(Math.sqrt(2*oneD.length + .25) -.5);
int[][] dest = new int[rows][];

现在只需将

数组复制到目标

for (int i = 0, s = 0, e = 1; i < rows; i++) {
    dest[i] = Arrays.copyOfRange(oneD, s, e );
    s = e;
    e += i+2;
}

for (int[] arr : dest) {
   System.out.println(Arrays.toString(arr));
}   

这里有一种方法，使用纯Java代码（例如循环），而不使用任何方法

静态int[]toTriangle（int[]input）{
//计算值的数目
int valueCount=0；
for（int[]inputRow:input）
valueCount+=inputRow.length；
如果（valueCount==0）
返回新整数[0][0]；
//确定结果行的数量，以及可以存储多少值
int resultRowCount=0，resultCount=0；
for（int行=0；resultCount[4]
[5, 6]
[7, 10, 8]
[4, 3, 9, 13]