Java 将数组操纵为新数组

我正在尝试编写一个方法，该方法接受一个数组，并将相邻的单元格相加以生成一个新数组。用例子更容易解释：

{11,4,3,18,23,9}-->{15,21,32}

{5,5,21,13,1}-->{10,34}（第六个单元格刚刚被忽略）

公共静态int[]折叠（int[]a）{
int[]b=新的int[a.长度/2]；
对于（int j=0；j<（a.length-1）；j+2）{//遍历原始数组
对于（int i=0；i

---

我认为这需要使用嵌套for循环，第一个循环遍历原始数组，第二个循环填充新数组。我知道第一个for循环中的j+2在语法上是不正确的，但我想不出另一种方法来实现同样的想法。

不要使用两个循环。只需保留一个表示您在输出数组中位置的计数器（outputIndex），并在每次使用后递增：

public static int[] collapse(int[] a) {
    int[] b = new int[a.length / 2];
    int outputIndex = 0;
    for (int j = 1 ; j < a.length ; j+=2) {    //goes thru original array
        b[outputIndex++] = a[j - 1] + a[j];
    }
    return b;
}

公共静态int[]折叠（int[]a）{
int[]b=新的int[a.长度/2]；
int outputIndex=0；
对于（int j=1；j

---

另外，我在j=1处开始循环，这样它可以处理缺少最后一个要添加的项的情况。请记住，您要添加的两个项目位于[j-1]和[j]，而不是[j]和[j+1]。

不要使用两个循环。只需保留一个表示您在输出数组中位置的计数器（outputIndex），并在每次使用后递增：

public static int[] collapse(int[] a) {
    int[] b = new int[a.length / 2];
    int outputIndex = 0;
    for (int j = 1 ; j < a.length ; j+=2) {    //goes thru original array
        b[outputIndex++] = a[j - 1] + a[j];
    }
    return b;
}

公共静态int[]折叠（int[]a）{
int[]b=新的int[a.长度/2]；
int outputIndex=0；
对于（int j=1；j

---

另外，我在j=1处开始循环，这样它可以处理缺少最后一个要添加的项的情况。请记住，您要添加的两个项目位于[j-1]和[j]，而不是[j]和[j+1]。

不要使用两个循环。只需保留一个表示您在输出数组中位置的计数器（outputIndex），并在每次使用后递增：

public static int[] collapse(int[] a) {
    int[] b = new int[a.length / 2];
    int outputIndex = 0;
    for (int j = 1 ; j < a.length ; j+=2) {    //goes thru original array
        b[outputIndex++] = a[j - 1] + a[j];
    }
    return b;
}

公共静态int[]折叠（int[]a）{
int[]b=新的int[a.长度/2]；
int outputIndex=0；
对于（int j=1；j

---

另外，我在j=1处开始循环，这样它可以处理缺少最后一个要添加的项的情况。请记住，您要添加的两个项目位于[j-1]和[j]，而不是[j]和[j+1]。

不要使用两个循环。只需保留一个表示您在输出数组中位置的计数器（outputIndex），并在每次使用后递增：

public static int[] collapse(int[] a) {
    int[] b = new int[a.length / 2];
    int outputIndex = 0;
    for (int j = 1 ; j < a.length ; j+=2) {    //goes thru original array
        b[outputIndex++] = a[j - 1] + a[j];
    }
    return b;
}

公共静态int[]折叠（int[]a）{
int[]b=新的int[a.长度/2]；
int outputIndex=0；
对于（int j=1；j

---

另外，我在j=1处开始循环，这样它可以处理缺少最后一个要添加的项的情况。请记住，您要添加的两项位于[j-1]和[j]，而不是[j]和[j+1]。

您的意思可能是

j=j+2

，而不仅仅是

j+2

事实上，这可以通过一个

for

循环来完成

for(int i = 0; i < oldArray.length - oldArray.length % 2; i+=2) {
    newArray[i/2] = oldArray[i] + oldArray[i+1]
}

for（int i=0；i

---

i

确保对于奇数数组，忽略最后一个元素。

您的意思可能是

j=j+2

，而不仅仅是

j+2

事实上，这可以通过一个

for

循环来完成

for(int i = 0; i < oldArray.length - oldArray.length % 2; i+=2) {
    newArray[i/2] = oldArray[i] + oldArray[i+1]
}

for（int i=0；i

---

i

确保对于奇数数组，忽略最后一个元素。

您的意思可能是

j=j+2

，而不仅仅是

j+2

事实上，这可以通过一个

for

循环来完成

for(int i = 0; i < oldArray.length - oldArray.length % 2; i+=2) {
    newArray[i/2] = oldArray[i] + oldArray[i+1]
}

for（int i=0；i

---

i

确保对于奇数数组，忽略最后一个元素。

您的意思可能是

j=j+2

，而不仅仅是

j+2

事实上，这可以通过一个

for

循环来完成

for(int i = 0; i < oldArray.length - oldArray.length % 2; i+=2) {
    newArray[i/2] = oldArray[i] + oldArray[i+1]
}

for（int i=0；i

i

确保对于奇数数组，忽略最后一个元素。

问题1:for的

中的第三个表达式通常需要修改索引<代码>j+2本身并不能做到这一点<代码>j=j+2将。（或
j+=2
）

问题2：您不希望为

循环使用嵌套的

。它的作用是：首先将
j
设置为0，让
i
遍历整个
b
数组。然后它增加
j
（在您解决第一个问题之后），并让
i
再次遍历整个
b
数组。这不是你想要的；你想让它们同时增加

一种方法是将
i
声明为循环外的变量：

int i = 0;
for (int j = 0; j < a.length - 1; j += 2) {
     b[i++] = a[j] + a[j + 1];
}

让for的
增加两个索引。
问题1:for的
中的第三个表达式通常需要修改索引<代码>j+2本身并不能做到这一点<代码>j=j+2将。（或
j+=2
）

问题2：您不希望为
循环使用嵌套的
。这是什么