Como Inverter uma String em Java

Inverter uma string significa produzir uma nova string cujos caracteres aparecem na ordem oposta — "Hello" torna-se "olleH". Como strings Java são imutáveis, nunca se inverte uma string in place; sempre se cria uma nova. Há várias maneiras idiomáticas de fazer isso, e a escolha certa depende de você querer o código mais curto, o mínimo de dependências, ou o tratamento correto de caracteres fora do plano multilíngue básico (como emoji).

Esta página cobre quatro abordagens — o StringBuilder.reverse embutido, um loop manual sobre array de caracteres, recursão e um pipeline de stream — compara-as em uma tabela e depois executa todas as quatro com a mesma entrada mais dois casos extremos para que você veja exatamente como elas se comportam.

A forma idiomática: StringBuilder.reverse

A biblioteca padrão já possui um método reverse em StringBuilder (e StringBuffer). Ele é a resposta em quase todas as situações:

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

Envolva a string original em um StringBuilder, chame reverse() e chame toString() para obter uma String simples de volta. Isso é rápido (uma única passagem, sem boxing) e é fácil de ler. Um bônus interessante: StringBuilder.reverse() é consciente de surrogates — mantém os dois chars de um ponto de código suplementar (como um emoji) juntos, em vez de invertê-los e produzir resultado corrompido.

Loop manual sobre um array de char

Quando você quer ver a mecânica — ou está em um ambiente onde não pode usar StringBuilder — percorra um char[] do último índice até o primeiro:

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();

Isso é exatamente o que StringBuilder.reverse faz internamente, sem o tratamento de surrogates. Evite construir o resultado com reversed += chars[i] em uma String pura: a concatenação de strings em um loop cria um novo objeto a cada iteração e transforma uma operação O(n) em O(n²).

Recursão e streams

Uma solução recursiva lê como sua definição — o inverso de uma string é o inverso de sua cauda seguido pelo seu primeiro caractere:

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

É elegante, mas aloca uma substring por chamada e pode causar estouro de pilha em entradas muito longas, portanto trate-a como ferramenta didática em vez de código de produção. Uma solução em stream em uma linha evita recursão, mas é a menos legível das opções:

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

Abordagem	Linhas	Velocidade	Seguro para surrogates
`StringBuilder.reverse`	1	Rápido	Sim
Loop manual sobre char array	~5	Rápido	Não
Recursão	~4	Lento, limitado pela pilha	Não
Stream + reduce	~3	Lento (reconstrói a string)	Não

Um exemplo prático

Este programa inverte "Hello" de quatro maneiras diferentes, confirma que todas concordam e depois verifica dois casos extremos: uma string vazia e uma string contendo um emoji (um par de surrogates).

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

O que observar na execução:

Todas as quatro abordagens imprimem olleH, então são intercambiáveis para texto ASCII simples — a escolha entre elas é sobre legibilidade e desempenho, não correção.
StringBuilder.reverse produziu o resultado em uma única expressão, razão pela qual é a recomendação padrão em relação ao loop, recursão e variantes com stream.
Inverter a string vazia retorna a string vazia (''), confirmando que os métodos são seguros para chamar sem verificação de comprimento — nenhum tratamento especial necessário.
O reverse recursivo terminou porque seu caso base (s.isEmpty()) interrompe a cadeia de chamadas substring(1); sem essa guarda, nunca retornaria.
naive emoji ok: true mostra que StringBuilder.reverse manteve o emoji de rosto sorridente intacto — ele moveu o par de surrogates como uma unidade. Um loop char por char feito à mão dividiria esse par e corromperia o emoji.

Prática

Qual método embutido inverte uma string em uma expressão e também mantém pares de surrogates (como emoji) intactos?

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

Tópicos relacionados

Métodos de String em Java — o conjunto completo de ferramentas para fatiar, pesquisar e transformar strings.
Java StringBuilder — o buffer mutável por trás de reverse() e da construção eficiente de strings.
Imutabilidade de String — por que uma String nunca pode ser alterada in place.