我在Java中反转数组时哪里出错了？

我的代码：

public static int invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 0; i < werte.length; i++) {
        for (int j = werte.length - 1; i < j; j--) {
            werte1[j] = werte[i];
        }
    }
    return werte1[0];
}

我需要在位置0-

werte1[0]

中返回

5

werte1[0] = 5
werte1[1] = 7
werte1[2] = 4

我的新数组应该是这样的：

int[]werte={5,7,4,3,2,1}

---

我的质疑我以前没有得到回答，因为我在询问我的代码，从正确的代码中学习

看起来您正在返回索引0处的值

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    int len = werte.length - 1;
    for (int i = 0; i < len; i++) {
        werte1[len-i] = werte[i];
    }
    return werte1;
}

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int len=werte.length-1；
对于（int i=0；i

看起来您正在返回索引0处的值

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    int len = werte.length - 1;
    for (int i = 0; i < len; i++) {
        werte1[len-i] = werte[i];
    }
    return werte1;
}

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int len=werte.length-1；
对于（int i=0；i

看起来您正在返回索引0处的值

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    int len = werte.length - 1;
    for (int i = 0; i < len; i++) {
        werte1[len-i] = werte[i];
    }
    return werte1;
}

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int len=werte.length-1；
对于（int i=0；i

看起来您正在返回索引0处的值

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    int len = werte.length - 1;
    for (int i = 0; i < len; i++) {
        werte1[len-i] = werte[i];
    }
    return werte1;
}

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int len=werte.length-1；
对于（int i=0；i

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int length=werte.length-1；
对于（int i=0；i

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int length=werte.length-1；
对于（int i=0；i

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int length=werte.length-1；
对于（int i=0；i

公共静态int[]invertieren（int[]werte）{
int[]werte1=新的int[werte.length]；
int length=werte.length-1；
对于（int i=0；i

如果不正确地使用嵌套循环，请改用单个循环：

public int[] invertArray(int[] oldInts)
{
    int[] newInts = new int[oldInts.length];

    for (int i = oldInts.length - 1; i >= 0; i--)
    {
        newInts[oldInts.length - i - 1] = oldInts[i];
    }

    return newInts;
}

---

如果不正确地使用嵌套循环，请改用单个循环：

public int[] invertArray(int[] oldInts)
{
    int[] newInts = new int[oldInts.length];

    for (int i = oldInts.length - 1; i >= 0; i--)
    {
        newInts[oldInts.length - i - 1] = oldInts[i];
    }

    return newInts;
}

---

如果不正确地使用嵌套循环，请改用单个循环：

public int[] invertArray(int[] oldInts)
{
    int[] newInts = new int[oldInts.length];

    for (int i = oldInts.length - 1; i >= 0; i--)
    {
        newInts[oldInts.length - i - 1] = oldInts[i];
    }

    return newInts;
}

---

如果不正确地使用嵌套循环，请改用单个循环：

public int[] invertArray(int[] oldInts)
{
    int[] newInts = new int[oldInts.length];

    for (int i = oldInts.length - 1; i >= 0; i--)
    {
        newInts[oldInts.length - i - 1] = oldInts[i];
    }

    return newInts;
}

---

如果你这样做是为了一门课或为了你自己的知识，那么这不是你的答案。否则，我将使用apachecommons。它们有几个重载的反向方法。

如果您是为了一个类或您自己的知识而这样做，那么这不是您的答案。否则，我将使用apachecommons。它们有几个重载的反向方法。

如果您是为了一个类或您自己的知识而这样做，那么这不是您的答案。否则，我将使用apachecommons。它们有几个重载的反向方法。

如果您是为了一个类或您自己的知识而这样做，那么这不是您的答案。否则，我将使用apachecommons。它们有几个重载的反向方法。

您不需要嵌套循环来反向数组。您只需要像这样循环遍历阵列：

static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 0; i < werte.length; i++) {
        werte1[i] = werte[werte.length - i - 1];
    }
    return werte1;
}

对于

i=1

：

werte1[1] = werte[6 - 1 - 1] = werte[4] = 7

等等。因此，我们通过

werte1

从

0

到

5

存储

werte

中的值，从

5

到

0

如果您分析

invertieren（）

当前的工作原理，您将看到结果错误的原因：

Initial values:
    werte = {1,2,3,4,7,5}
    werte1 = {0,0,0,0,0,0}

for i = 0:
    for j from 5 to 1:
        werte1[j] = werte[0]

intermediate result: werte1 = {0,1,1,1,1,1}

for i = 1:
    for j fom 5 to 2:
        werte1[j] = werte[1]

intermediate result: werte1 = {0,1,2,2,2,2}

for i = 2:
    for j from 5 to 3:
        werte1[j] = werte[2]

intermediate result: werte1 = {0,1,2,3,3,3}

for i = 3:
    for j from 5 to 4:
        werte1[j] = werte[3]

intermediate result: werte1 = {0,1,2,3,4,4}

for i = 4:
    for j from 5 to 5:
        werte1[j] = werte[4]

final result: werte1 = {0,1,2,3,4,7}

for i = 5 it will do nothing, since j starts at 5.

---

它根本不会反转原始数组，因此不需要嵌套循环来反转数组。您只需要像这样循环遍历阵列：

static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 0; i < werte.length; i++) {
        werte1[i] = werte[werte.length - i - 1];
    }
    return werte1;
}

对于

i=1

：

werte1[1] = werte[6 - 1 - 1] = werte[4] = 7

等等。因此，我们通过

werte1

从

0

到

5

存储

werte

中的值，从

5

到

0

如果您分析

invertieren（）

当前的工作原理，您将看到结果错误的原因：

Initial values:
    werte = {1,2,3,4,7,5}
    werte1 = {0,0,0,0,0,0}

for i = 0:
    for j from 5 to 1:
        werte1[j] = werte[0]

intermediate result: werte1 = {0,1,1,1,1,1}

for i = 1:
    for j fom 5 to 2:
        werte1[j] = werte[1]

intermediate result: werte1 = {0,1,2,2,2,2}

for i = 2:
    for j from 5 to 3:
        werte1[j] = werte[2]

intermediate result: werte1 = {0,1,2,3,3,3}

for i = 3:
    for j from 5 to 4:
        werte1[j] = werte[3]

intermediate result: werte1 = {0,1,2,3,4,4}

for i = 4:
    for j from 5 to 5:
        werte1[j] = werte[4]

final result: werte1 = {0,1,2,3,4,7}

for i = 5 it will do nothing, since j starts at 5.

---

它根本不会反转原始数组，因此不需要嵌套循环来反转数组。您只需要像这样循环遍历阵列：

static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 0; i < werte.length; i++) {
        werte1[i] = werte[werte.length - i - 1];
    }
    return werte1;
}

对于

i=1

：

werte1[1] = werte[6 - 1 - 1] = werte[4] = 7

等等。因此，我们通过

werte1

从

0

到

5

存储

werte

中的值，从

5

到

0

如果您分析

invertieren（）

当前的工作原理，您将看到结果错误的原因：

Initial values:
    werte = {1,2,3,4,7,5}
    werte1 = {0,0,0,0,0,0}

for i = 0:
    for j from 5 to 1:
        werte1[j] = werte[0]

intermediate result: werte1 = {0,1,1,1,1,1}

for i = 1:
    for j fom 5 to 2:
        werte1[j] = werte[1]

intermediate result: werte1 = {0,1,2,2,2,2}

for i = 2:
    for j from 5 to 3:
        werte1[j] = werte[2]

intermediate result: werte1 = {0,1,2,3,3,3}

for i = 3:
    for j from 5 to 4:
        werte1[j] = werte[3]

intermediate result: werte1 = {0,1,2,3,4,4}

for i = 4:
    for j from 5 to 5:
        werte1[j] = werte[4]

final result: werte1 = {0,1,2,3,4,7}

for i = 5 it will do nothing, since j starts at 5.

---

它根本不会反转原始数组，因此不需要嵌套循环来反转数组。您只需要像这样循环遍历阵列：

static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 0; i < werte.length; i++) {
        werte1[i] = werte[werte.length - i - 1];
    }
    return werte1;
}

对于

i=1

：

werte1[1] = werte[6 - 1 - 1] = werte[4] = 7

等等。因此，我们通过

werte1

从

0

到

5

存储

werte

中的值，从

5

到

0

如果您分析

invertieren（）

当前的工作原理，您将看到结果错误的原因：

Initial values:
    werte = {1,2,3,4,7,5}
    werte1 = {0,0,0,0,0,0}

for i = 0:
    for j from 5 to 1:
        werte1[j] = werte[0]

intermediate result: werte1 = {0,1,1,1,1,1}

for i = 1:
    for j fom 5 to 2:
        werte1[j] = werte[1]

intermediate result: werte1 = {0,1,2,2,2,2}

for i = 2:
    for j from 5 to 3:
        werte1[j] = werte[2]

intermediate result: werte1 = {0,1,2,3,3,3}

for i = 3:
    for j from 5 to 4:
        werte1[j] = werte[3]

intermediate result: werte1 = {0,1,2,3,4,4}

for i = 4:
    for j from 5 to 5:
        werte1[j] = werte[4]

final result: werte1 = {0,1,2,3,4,7}

for i = 5 it will do nothing, since j starts at 5.

---

它根本不会反转原始数组，因此

werte1[0]==0

这是使用修改的

main

方法工作的代码：

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 1; i <= werte.length; i++) {
        werte1[i - 1] = werte[werte.length - i];
    }
    return werte1;
}

public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 7, 5};
    for (int revVal : invertieren(a)) {
        System.out.println(revVal);
    }
}

---

这是使用修改的

main

方法工作的代码：

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 1; i <= werte.length; i++) {
        werte1[i - 1] = werte[werte.length - i];
    }
    return werte1;
}

public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 7, 5};
    for (int revVal : invertieren(a)) {
        System.out.println(revVal);
    }
}

---

这是使用修改的

main

方法工作的代码：

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 1; i <= werte.length; i++) {
        werte1[i - 1] = werte[werte.length - i];
    }
    return werte1;
}

public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 7, 5};
    for (int revVal : invertieren(a)) {
        System.out.println(revVal);
    }
}

---

这是使用修改的

main

方法工作的代码：

public static int[] invertieren(int[] werte) {
    int[] werte1 = new int[werte.length];
    for (int i = 1; i <= werte.length; i++) {
        werte1[i - 1] = werte[werte.length - i];
    }
    return werte1;
}

public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 7, 5};
    for (int revVal : invertieren(a)) {
        System.out.println(revVal);
    }
}

---

你能稍微解释一下代码背后的想法吗？你觉得它怎么样