En este post voy a mostrarte dos maneras de invertir un arreglo (de cualquier tipo) en Java. Los arreglos son colecciones de datos a los que se accede a través de un índice, también son conocidos como arrays.

El primer método es un algoritmo “manual” programado por mí, y el segundo método utiliza un método de la clase Collections. Vamos a ver ambos métodos.

Invertir con Collections

La clase Collections proporciona el método reverse que en realidad invierte una lista (List) pero eso no es problema, ya que podemos convertir el arreglo a una lista con Arrays.asList. Por lo tanto tenemos:

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

Al final del post dejaré un ejemplo completo.

Nota: el método reverse no devuelve un arreglo, sino que lo invierte directamente.

Invertir arreglo con método manual

Este método utiliza un ciclo for e intercambia los valores del arreglo. El primer elemento se intercambia por el último, el segundo por el penúltimo y así sucesivamente.

De esta manera solo usamos una variable extra: una variable temporal para hacer el intercambio.

public static void invertirManual(String[] arreglo) {
    String temporal; // El elemento temporal del arreglo que vamos a intercambiar
    int longitudDeArreglo = arreglo.length;
    // Nota: al dividir entre 2, si es flotante, se pasa al entero anterior. P. ej.
    // 5 / 2 = 2
    for (int x = 0; x < longitudDeArreglo / 2; x++) {
      // Guardar el actual
      temporal = arreglo[x];
      // El índice de la otra mitad
      int indiceContrario = longitudDeArreglo - x - 1;
      // El valor actual es el valor contrario, el de la otra mitad
      arreglo[x] = arreglo[indiceContrario];
      // Y el de la otra mitad, es el que había en el actual originalmente
      arreglo[indiceContrario] = temporal;
    }
    // El arreglo ya está invertido internamente
  }

El ciclo que hacemos va desde 0 hasta la mitad (redondeada hacia abajo) del arreglo. Dentro del mismo hacemos el intercambio y al final de la función no es necesario regresar nada, porque hemos modificado el arreglo directamente y ahora ya está invertido.

Ejemplos para invertir arreglo con Java

A continuación dejo el código completo que demuestra las dos maneras de invertir un arreglo en Java:

/*
  2 maneras de invertir un arreglo en Java
  El primer método invierte un arreglo con un método manual,
  intercambiando los elementos dentro de un ciclo for

  El segundo utiliza un método incluido dentro de Collections

  @author parzibyte
  Visita: parzibyte.me/blog
*/import java.util.*;// Para Collections y Arrays

class Main {
  public static void main(String[] args) {
    // Definir el arreglo original
    String[] lenguajes = { "Java", "JavaScript", "Go", "Kotlin", "C#", "Python", "PHP" };
    // Imprimir el arreglo antes de invertirlo
    System.out.println("\n\n\n=====\nImprimiendo arreglo normal:\n=====");
    for (String lenguaje : lenguajes) {
      System.out.println(lenguaje);
    }
    // Invertir el arreglo con método manual
    invertirManual(lenguajes);
    System.out.println("\n\n\n=====\nImprimiendo arreglo invertido\n=====");
    for (String lenguaje : lenguajes) {
      System.out.println(lenguaje);
    }
    // Invertir el arreglo con métodos de Collections
    // Nota: Collections.reverse invierte una lista, por eso convertimos el arreglo a lista
    Collections.reverse(Arrays.asList(lenguajes));
    System.out.println("\n\n\n=====\nImprimiendo arreglo invertido (debería ser igual al original)\n=====");
    for (String lenguaje : lenguajes) {
      System.out.println(lenguaje);
    }
  }

  public static void invertirManual(String[] arreglo) {
    String temporal; // El elemento temporal del arreglo que vamos a intercambiar
    int longitudDeArreglo = arreglo.length;
    // Nota: al dividir entre 2, si es flotante, se pasa al entero anterior. P. ej.
    // 5 / 2 = 2
    for (int x = 0; x < longitudDeArreglo / 2; x++) {
      // Guardar el actual
      temporal = arreglo[x];
      // El índice de la otra mitad
      int indiceContrario = longitudDeArreglo - x - 1;
      // El valor actual es el valor contrario, el de la otra mitad
      arreglo[x] = arreglo[indiceContrario];
      // Y el de la otra mitad, es el que había en el actual originalmente
      arreglo[indiceContrario] = temporal;
    }
    // El arreglo ya está invertido internamente
  }

}

Conclusión

En los ejemplos vimos cómo invertir un arreglo de cadenas, y para invertir un arreglo de otro tipo solo se necesita declarar la temporal de distinta manera, así como la firma del método; de tal manera que se cambie el tipo de dato.