Как перевернуть массив int в Java?

Чтобы перевернуть массив 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;
}

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

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

ArrayUtils.reverse(int[] array)

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

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

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

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

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

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

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

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

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

С гуавой:

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

В случае Java 8 мы также можем использовать IntStream для обращения массива целых чисел следующим образом:

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]

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

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

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

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

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

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

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

Если вы работаете с более примитивными данными (например, char, byte, int и т. д.), вы можете выполнить несколько забавных операций XOR.

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}

Ваша программа будет работать только для length = 0, 1. Можешь попробовать :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}

Выше есть несколько отличных ответов, но я сделал это так:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}

Наиболее эффективно просто перебирать массив в обратном порядке.

Я не уверен, что решение Аарона делает это в этом вызове Collections.reverse(list); Кто-нибудь знает?

Разве это не будет гораздо более маловероятным для ошибок?

    int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[] temp = new int[intArray.length];
    for(int i = intArray.length - 1; i > -1; i --){
            temp[intArray.length - i -1] = intArray[i];
    }
    intArray = temp;

Решение с временной сложностью o(n) и пространственной сложностью o(1).

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

Есть два пути решения проблемы:

<сильный>1. Перевернуть массив в пространстве.

Шаг 1. Поменяйте местами элементы в начале и в конце индекса.

Шаг 2. Увеличьте начальный индекс, уменьшите конечный индекс.

Шаг 3. Повторяйте Шаг 1 и Шаг 2 до начального индекса ‹ конечного индекса

Для этого временная сложность будет O (n), а пространственная сложность будет O (1).

Пример кода для обращения массива в пространстве выглядит так:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

<сильный>2. Обратить массив с помощью вспомогательного массива.

Шаг 1. Создайте новый массив размера, равного заданному массиву.

Шаг 2. Вставить элементы в новый массив, начиная с начального индекса, из заданного массива, начиная с конечного индекса.

Для этого временная сложность будет O (n), а пространственная сложность будет O (n).

Пример кода для реверсирования массива с помощью вспомогательного массива выглядит так:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

Кроме того, для этого мы можем использовать Collections API из Java.

API коллекций внутренне использует тот же обратный подход в пространстве.

Пример кода для использования API коллекций выглядит так:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

2 способа инвертировать массив.

1. Использование цикла For и замена элементов до середины с временной сложностью O (n/2).

   private static void reverseArray() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   for (int i = 0; i < array.length / 2; i++) {
       int temp = array[i];
       int index = array.length - i - 1;
       array[i] = array[index];
       array[index] = temp;
   }
   System.out.println(Arrays.toString(array));
   

   }

2. Использование встроенной функции (Collections.reverse())

   private static void reverseArrayUsingBuiltInFun() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   Collections.reverse(Ints.asList(array));
   System.out.println(Arrays.toString(array));
   

   }

   Выход: [6, 5, 4, 3, 2, 1]

Ниже приведена полная программа для запуска на вашем компьютере.

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

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

Используя решение XOR, чтобы избежать временной переменной, ваш код должен выглядеть так

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

Смотрите эту ссылку для лучшего объяснения:

http://betterexplained.com/articles/swap-two-variables-using-xor/

Вот простая реализация для реверсирования массива любого типа, а также полная/частичная поддержка.

import java.util.logging.Logger;

public final class ArrayReverser {
 private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());

 private ArrayReverser () {

 }

 public static <T> void reverse(T[] seed) {
    reverse(seed, 0, seed.length);
 }

 public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
    if (seed == null || seed.length == 0) {
        LOGGER.warning("Nothing to rotate");
    }
    int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
    int end = Math.min(seed.length, endIndexExclusive) - 1;
    while (start < end) {
        swap(seed, start, end);
        start++;
        end--;
    }
}

 private static <T> void swap(T[] seed, int start, int end) {
    T temp =  seed[start];
    seed[start] = seed[end];
    seed[end] = temp;
 }  

}

Вот соответствующий модульный тест

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Before;
import org.junit.Test;

public class ArrayReverserTest {
private Integer[] seed;

@Before
public void doBeforeEachTestCase() {
    this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}

@Test
public void wholeArrayReverse() {
    ArrayReverser.<Integer>reverse(seed);
    assertThat(seed[0], is(8));
}

 @Test
 public void partialArrayReverse() {
    ArrayReverser.<Integer>reverse(seed, 1, 5);
    assertThat(seed[1], is(5));
 }
}

Вот что я придумал:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

кусок торта. я сделал это для строки, но это не сильно отличается

Короткий способ реверсирования без дополнительных библиотек, импорта или статических ссылок.

int[] a = {1,2,3,4,5,6,7,23,9}, b; //compound declaration
var j = a.length;
b = new int[j];
for (var i : a)
    b[--j] = i; //--j so you don't have to subtract 1 from j. Otherwise you would get ArrayIndexOutOfBoundsException;
System.out.println(Arrays.toString(b));

Конечно, если вам действительно нужно, чтобы a был обратным массивом, просто используйте

a = b; //after the loop

Вот сжатая версия:

Мое решение создает новый массив в обратном порядке. С каждой итерацией i цикл for вставляет последний индекс [array.length - 1] в текущий индекс [i]. Затем продолжает тот же процесс, вычитая массив текущей итерации [(array.length - 1) - i] из последнего индекса и вставка элемента в следующий индекс обратного массива!

private static void reverse(int[] array) {
    int[] reversed = new int[array.length];

    for (int i = 0; i < array.length; i++) {
        reversed[i] = array[(array.length - 1) - i];
    }
    System.out.println(Arrays.toString(reversed));
}

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

Поэтому создайте свою реализацию Iterator, которая принимает массив или список и обеспечивает ввод.

/// Reverse Iterator
public class ReverseIterator<T> implements Iterator<T> {
  private int index;
  private final List<T> list;
  public ReverseIterator(List<T> list) {
     this.list = list;
     this.index = list.size() - 1;
  }
  public boolean hasNext() {
    return index >= 0 ? true : false;
  }
  public T next() {
    if(index >= 0) 
      return list.get(index--);
    else 
      throw new NoSuchElementException();
  }
}

Реализация ситуации с массивом очень похожа. Конечно, итератор также может быть источником для потока или коллекции.

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

Это имеет 2 решения

1. Петля

2. Рекурсия

   открытый класс

    public static void main(String[] args) {
        int array[] = {2, 3, 1, 4, 9};
        //reverseArray(array, 0, array.length - 1);
        reverseArrayWhileLoop(array, 0, array.length - 1);
        printArray(array);
    }
   
    private static void printArray(int[] array) {
        for (int a : array) {
            System.out.println(a);
        }
    }
   
    private static void reverseArray(int[] array, int start, int end) {
        if (start > end) {
            return;
        } else {
            int temp;
            temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            reverseArray(array, start + 1, end - 1);
        }
    }
   
    private static void reverseArrayWhileLoop(int[] array, int start, int end) {
        while (start < end) {
            int temp;
            temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            start++;
            end--;
        }
    }
   

   ReverseArray {

    public static void main(String[] args) {
        int array[] = {2, 3, 1, 4, 9};
        //reverseArray(array, 0, array.length - 1);
        reverseArrayWhileLoop(array, 0, array.length - 1);
        printArray(array);
    }
   
    private static void printArray(int[] array) {
        for (int a : array) {
            System.out.println(a);
        }
    }
   
    private static void reverseArray(int[] array, int start, int end) {
        if (start > end) {
            return;
        } else {
            int temp;
            temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            reverseArray(array, start + 1, end - 1);
        }
    }
   
    private static void reverseArrayWhileLoop(int[] array, int start, int end) {
        while (start < end) {
            int temp;
            temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            start++;
            end--;
        }
    }
   

   }

Реализация с использованием дженериков.

    //Reverse and get new Array -preferred
    public static final <T> T[] reverse(final T[] array) {
        final int len = array.length;
        final T[] reverse = (T[]) Array.newInstance(array.getClass().getComponentType(), len);
        for (int i = 0; i < len; i++) {
            reverse[i] = array[len-(i+1)];
        }
        return reverse;
    }
    
    //Reverse existing array - don't have to return it
    public static final <T> T[] reverseExisting(final T[] array) {
        final int len = array.length;
        for (int i = 0; i < len/2; i++) {
            final T temp = array[i];
            array[i] = array[len-(i+1)];
            array[len-(i+1)] = temp;
        }
        return array;
    }

Попробуйте эту программу в JAVA: -

import java.util.Scanner;

public class Rev_one_D {

    static int row;

    static int[] trans_arr = new int[row];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        row = n;

        int[] arr = new int[row];
        for (int i = 0; i < row; i++) {

            arr[i] = sc.nextInt();
            System.out.print(arr[i] + " ");

            System.out.println();
        }

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

        }

        for (int i = 0; i < row; i++) {
            System.out.print(arr[i] + " ");
            System.out.println();
        }
    }
}

Попробуйте этот код:

    int arr[] = new int[]{1,2,3,4,5,6,7};
    for(int i=0;i<arr.length/2;i++){
        int temp = arr[i];
        arr[i] = arr[(arr.length-1)-i];
        arr[(arr.length-1)-i] = temp;
     }
     System.out.println(Arrays.toString(arr));

Вот простое быстрое решение. Надеюсь, поможет!.

public int[] reverse(int[] arr) {
    for(int i = arr.length; i > 0 ; i--){
        System.out.print(arr[i-1] + " ");
    }
    return arr;
}

Другой способ реверсирования массива

public static int []reversing(int[] array){
    int arraysize = array.length;
    int[] reverse = new int [arraysize+1];
    for(int i=1; i <= arraysize ; i++){
        int dec= arraysize -i;
        reverse[i] = array[dec];
    }
    return reverse;
}

Поскольку я намеревался сохранить исходный массив таким, какой он был, я решил эту проблему следующим образом:

List<Integer> normalArray= new ArrayList<>();
List<Integer> reversedArray = new ArrayList<>();

// Fill up array here

for (int i = 1; i <= normalArray.size(); i++) {
  reversedArray .add(normalArray.get(normalArray.size()-i));
}

Таким образом, в основном перебираем исходный массив и добавляем все значения в обратном порядке в новый (обратный) массив. Тип списка может быть любым. Я прорабатываю этот код несколько раз, из-за этого некоторые другие решения не работают.

Вы можете использовать это

public final class ReverseComparator<T extends Comparable<T>> implements  Comparator<T> {
  @Override
  public int compare(T o1, T o2) {      
    return o2.compareTo(o1);
  }
}

просто

Integer[] a = {1,6,23,4,6,8,2}
Arrays.sort(a, new ReverseComparator<Integer>());