Cómo invertir una cadena en Java

Invertir una cadena significa producir una nueva cadena cuyos caracteres aparecen en orden inverso — "Hello" se convierte en "olleH". Dado que las cadenas Java son inmutables, nunca se invierte una cadena en su lugar; siempre se construye una nueva. Existen varios modos idiomáticos de hacerlo, y la elección correcta depende de si se desea el código más corto, la menor cantidad de dependencias o el manejo correcto de caracteres fuera del plano multilingüe básico (como los emoji).

Esta página cubre cuatro enfoques — el StringBuilder.reverse integrado, un bucle manual sobre un array de caracteres, la recursión y un pipeline de stream — los compara en una tabla y luego ejecuta los cuatro con la misma entrada más dos casos límite para que puedas ver exactamente cómo se comportan.

La forma idiomática: StringBuilder.reverse

La biblioteca estándar ya tiene un método reverse en StringBuilder (y StringBuffer). Es la respuesta en casi todas las situaciones:

String reversed = new StringBuilder("Hello").reverse().toString();
// reversed = "olleH"

Envuelve la cadena original en un StringBuilder, llama a reverse() y llama a toString() para obtener un String normal. Es rápido (una sola pasada, sin boxing) y se lee con claridad. Una ventaja adicional: StringBuilder.reverse() es consciente de los pares sustitutos — mantiene los dos chars de un punto de código suplementario (como un emoji) juntos en lugar de invertirlos y producir caracteres corruptos.

Bucle manual sobre un array de caracteres

Cuando quieres ver la mecánica — o estás en un entorno donde no puedes usar StringBuilder — recorre un char[] desde el último índice hasta el primero:

char[] chars = "Hello".toCharArray();
StringBuilder out = new StringBuilder();
for (int i = chars.length - 1; i >= 0; i--) {
  out.append(chars[i]);
}
String reversed = out.toString();

Esto es exactamente lo que hace StringBuilder.reverse internamente, sin el manejo de pares sustitutos. Evita construir el resultado con reversed += chars[i] sobre un String puro: la concatenación de cadenas en un bucle crea un nuevo objeto en cada iteración y convierte una tarea O(n) en O(n²).

Recursión y streams

Una solución recursiva se lee como su propia definición — la inversión de una cadena es la inversión de su cola seguida de su primer carácter:

static String reverse(String s) {
  if (s.isEmpty()) return s;
  return reverse(s.substring(1)) + s.charAt(0);
}

Es elegante, pero asigna una subcadena por llamada y puede desbordar la pila en entradas muy largas, así que trátala como una herramienta de enseñanza y no como código de producción. Una solución de una línea basada en streams evita la recursión, pero es la menos legible de todas:

String reversed = "Hello".chars()
    .mapToObj(c -> String.valueOf((char) c))
    .reduce("", (a, b) -> b + a);

Enfoque	Líneas	Velocidad	Seguro para sustitutos
`StringBuilder.reverse`	1	Rápido	Sí
Bucle manual sobre char array	~5	Rápido	No
Recursión	~4	Lento, limitado por la pila	No
Stream + reduce	~3	Lento (reconstruye la cadena)	No

Un ejemplo práctico

Este programa invierte "Hello" de cuatro maneras distintas, confirma que todas coinciden y luego verifica dos casos límite: una cadena vacía y una cadena que contiene un emoji (un par sustituto).

java— editable, runs on the server

public class ReverseStringDemo {
  public static void main(String[] args) {
    String s = "Hello";

// 1. StringBuilder.reverse: the idiomatic one-liner.
    String byBuilder = new StringBuilder(s).reverse().toString();
    System.out.println("StringBuilder : " + byBuilder);

// 2. Manual loop over a char array, walking from the end.
    char[] chars = s.toCharArray();
    StringBuilder loop = new StringBuilder();
    for (int i = chars.length - 1; i >= 0; i--) {
      loop.append(chars[i]);
    }
    System.out.println("manual loop   : " + loop);

// 3. Recursion: reverse(tail) + firstChar.
    System.out.println("recursion     : " + reverse(s));

// 4. Streams over code points (handles characters generically).
    String byStream = s.chars()
        .mapToObj(c -> String.valueOf((char) c))
        .reduce("", (a, b) -> b + a);
    System.out.println("stream        : " + byStream);

// Edge cases: empty string and emoji (surrogate pair).
    System.out.println("empty         : '" + new StringBuilder("").reverse() + "'");

String emoji = "ab\uD83D\uDE00";          // 'a', 'b', grinning face
    String naive = new StringBuilder(emoji).reverse().toString();
    System.out.println("naive emoji ok: " + naive.contains("\uD83D\uDE00"));
  }

static String reverse(String s) {
    if (s.isEmpty()) {
      return s;
    }
    return reverse(s.substring(1)) + s.charAt(0);
  }
}

Qué extraer de la ejecución:

Los cuatro enfoques imprimen olleH, por lo que son intercambiables para texto ASCII simple — la elección entre ellos es de legibilidad y rendimiento, no de corrección.
StringBuilder.reverse produjo el resultado en una sola expresión, razón por la cual es la recomendación por defecto sobre el bucle, la recursión y las variantes con stream.
Invertir la cadena vacía devuelve la cadena vacía (''), lo que confirma que los métodos son seguros para llamarse sin comprobar la longitud — no es necesario ningún caso especial.
El reverse recursivo terminó porque su caso base (s.isEmpty()) detiene la cadena de llamadas a substring(1); sin esa condición nunca retornaría.
naive emoji ok: true muestra que StringBuilder.reverse mantuvo el emoji de cara sonriente intacto — movió el par sustituto como una unidad. Un bucle char a char escrito a mano dividiría ese par y corrompería el emoji.

Práctica

¿Qué método integrado invierte una cadena en una sola expresión y mantiene intactos los pares sustitutos (como los emoji)?

new StringBuilder(s).reverse().toString()s.reverse()Collections.reverse(s)s.toCharArray().reverse()

Temas relacionados

Métodos de String en Java — el conjunto completo de herramientas para dividir, buscar y transformar cadenas.
Java StringBuilder — el buffer mutable detrás de reverse() y la construcción eficiente de cadenas.
Inmutabilidad de String — por qué un String nunca puede modificarse en su lugar.