Invertir una array en Java

Dada una array, la tarea es invertir la array dada en Java.

Ejemplos: 

Input : 1, 2, 3, 4, 5
Output :5, 4, 3, 2, 1

Input :  10, 20, 30, 40
Output : 40, 30, 20, 10

Para conocer los conceptos básicos de Array, consulte Estructura de datos de array.

Enfoques

Existen numerosos enfoques para invertir una array en Java. Estos son:

• Usando array temporal
• Usando el intercambio
• Usando el método Collections.reverse()
• Usando el método StringBuilder.append()

1. Usando la array temporal

El primer método es el siguiente: 

• Ingrese el tamaño de la array y los elementos de la array.
• Considere una función inversa que toma los parámetros: la array (digamos arr) y el tamaño de la array (digamos n).
• Dentro de la función, se inicializa una nueva array (con el tamaño de array de la primera array, arr). La array arr[] se itera desde el primer elemento, y cada elemento de la array arr[] se coloca en la nueva array desde atrás, es decir, la nueva array se itera desde su último elemento.
• De esta forma, todos los elementos del arreglo arr[] se colocan al revés en el nuevo arreglo.
• Además, podemos iterar a través de la nueva array desde el principio e imprimir los elementos de la array.

// Basic Java program that reverses an array
  
public class reverseArray {
  
    // function that reverses array and stores it 
    // in another array
    static void reverse(int a[], int n)
    {
        int[] b = new int[n];
        int j = n;
        for (int i = 0; i < n; i++) {
            b[j - 1] = a[i];
            j = j - 1;
        }
  
        // printing the reversed array
        System.out.println("Reversed array is: \n");
        for (int k = 0; k < n; k++) {
            System.out.println(b[k]);
        }
    }
  
    public static void main(String[] args)
    {
        int [] arr = {10, 20, 30, 40, 50};
        reverse(arr, arr.length);
    }
}

Reversed array is: 

50
40
30
20
10

2. Usando el intercambio

El segundo método usa un código similar para ingresar e imprimir la array. Sin embargo, no creamos una nueva array como el método anterior. En cambio, invertimos la array original en sí. En este método, intercambiamos los elementos de la array. El primer elemento se intercambia con el último elemento. El segundo elemento se intercambia con el penúltimo elemento y así sucesivamente. 
Por ejemplo, considere la array [1, 2, 3, …., n-2, n-1, n]. Intercambiamos 1 con n, 2 con n-1, 3 con n-2 y más. 
 

// Java Program that reverses array
// in less number of swaps
  
public class arrayReverse {
  
    // function swaps the array's first element with last
    // element, second element with last second element and
    // so on
    static void reverse(int a[], int n)
    {
        int i, k, t;
        for (i = 0; i < n / 2; i++) {
            t = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = t;
        }
  
        // printing the reversed array
        System.out.println("Reversed array is: \n");
        for (k = 0; k < n; k++) {
            System.out.println(a[k]);
        }
    }
  
    public static void main(String[] args)
    {
        int[] arr = { 10, 20, 30, 40, 50 };
        reverse(arr, arr.length);
    }
}

Reversed array is: 

50
40
30
20
10

3. Usando el método Collections.reverse()

El tercer método es utilizar el método de función java.util.Collections.reverse(List list) . Este método invierte los elementos de la lista especificada. Por lo tanto, primero convertimos la array en una lista usando java.util.Arrays.asList(array) y luego invertimos la lista. 
 

// Reversing an array using Java collections
import java.util.*;
  
public class reversingArray {
  
    // function reverses the elements of the array
    static void reverse(Integer a[])
    {
        Collections.reverse(Arrays.asList(a));
        System.out.println(Arrays.asList(a));
    }
  
    public static void main(String[] args)
    {
        Integer [] arr = {10, 20, 30, 40, 50};
        reverse(arr);
    }
}

[50, 40, 30, 20, 10]

4. Usando el método StringBuilder.append()

Como cuarto método , si está trabajando con una array de strings, podemos usar un StringBuilder y agregar cada elemento de la array con un bucle for que disminuya desde la longitud de la array, convertir el StringBuilder en una string y dividirlo nuevamente en una array.

// Java Program for Reversing an array using StringBuilder
  
import java.util.Arrays;
  
class GFG {
    public static void main (String[] args) {
      String[] arr = {"Hello", "World"};
      StringBuilder reversed = new StringBuilder();
  
      for (int i = arr.length; i > 0; i--) {
          reversed.append(arr[i - 1]).append(" ");
      };
        
      String[] reversedArray = reversed.toString().split(" ");
        
      System.out.println(Arrays.toString(reversedArray));
    }
}

[World, Hello]