Где я ошибся в обращении массива в Java?

Question

Мой код:

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

Это мой код, я разработал метод, который должен полностью изменить свой массив. , например: в основном методе:

public static void main(String[] args) { 
    // TODO Auto-generated method stub 

    int[] a = {1,2,3,4,7,5}; 
    System.out.println(invertieren(a)); 
} 

и мне нужно, что в положении 0 - werte1[0] должен дать мне 5 назад.

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

мой новый массив должен выглядеть так: int[] werte = {5,7,4,3,2,1}

мой quastion Я не ответил раньше, потому что я спрашиваю о своем коде, чтобы узнать от делать это правильно.

Answer 1

Вам не нужны вложенные петли для изменения массива. Вам просто нужно перебрать массивы, как это:

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

Если вы хотите вернуть перевернутый массив, вам нужно изменить тип возвращаемого оригинального метода, чтобы вернуть int[] вместо int, а затем возвращения werte1 вместо werte1[0].

Чтобы понять, как это работает, предположим, что werte.length == 6. Так i = 0 мы имеем:

werte1[i] = werte[werte.length - i - 1] 
werte1[0] = werte[6 - 0 - 1] = werte[5] = 5 

Для i = 1:

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

И так далее. Поэтому мы проходим через werte1 от 0 до 5, сохраняя значения от werte от 5 до 0.

Если вы analise как 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.

Answer 2

Это выглядит так, как будто вы возвращаете значение по индексу 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; 
} 

Answer 3

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

      werte1[length-i] = werte[i]; 

     } 
    return werte1; 
    } 

Answer 4

Вы неправильно используете вложенный цикл, использовать одну петлю вместо:

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

Answer 5

Если вы делаете это для класса или для своих собственных знаний, тогда это не ваш ответ. В противном случае я бы использовал Apache Commons ArrayUtils. У них есть несколько перегруженных обратных методов.

Answer 6

Это работает код с модифицированным 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; 
} 

Измененная main метод:

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