Как изменить массив int в Java?

Question

Я пытаюсь перевернуть массив int в Java.

Этот метод не переворачивает массив.

for(int i = 0; i < validData.length; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

Что с ним не так?

Answer 1

С Commons.Lang , вы можете просто использовать

ArrayUtils.reverse(int[] array)

В большинстве случаев быстрее и безопаснее придерживаться легко доступных библиотек, уже протестированных модулем и протестированных пользователем, когда они решают вашу проблему.

Answer 2

Чтобы инвертировать массив int, вы меняете элементы вверх, пока не достигнете средней точки, например:

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

То, как вы это делаете, вы меняете местами каждый элемент дважды, поэтому результат совпадает с исходным списком.

Answer 3

public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

Answer 4

Я думаю, что немного легче следовать логике алгоритма, если вы объявляете явные переменные для отслеживания индексов, которые вы меняете на каждой итерации цикла.

public static void reverse(int[] data) {
    for (int left = 0, right = data.length - 1; left < right; left++, right--) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left]  = data[right];
        data[right] = temp;
    }
}

Я также думаю, что это легче сделать в цикле while.

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}

Answer 5

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse() может перевернуть java.util.List с, а java.util.Arrays.asList() возвращает список, который оборачивает определенный массив, который вы передаете ему, поэтому yourArray переворачивается после вызова Collections.reverse().

Стоимость - это просто создание одного объекта List, дополнительные библиотеки не требуются.

Аналогичное решение было представлено в ответе Тарика и его комментаторов, но я думаю, что этот ответ был бы более кратким и более простым для анализа.

Answer 6

Здесь уже есть много ответов, в основном направленных на изменение массива на месте. Но для полноты картины, есть другой подход, использующий потоки Java для сохранения исходного массива и создания нового обращенного массива:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

Answer 7

с гуавой:

Collections.reverse(Ints.asList(array));

Answer 8

Простой цикл!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}

Answer 9

Это вам поможет

int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
    int temp = a[k];
    a[k] = a[a.length-(1+k)];
    a[a.length-(1+k)] = temp;
}

Answer 10

Вот как бы я лично решил это. Причиной создания параметризованного метода является возможность сортировки любого массива, а не только целых чисел.

Я надеюсь, что вы что-то почерпнули из этого.

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}