Strings em Java

Uma String representa uma sequência de caracteres e é, depois de int, o tipo que você mais usará. É uma classe (não um primitivo), mas o Java lhe dá uma sintaxe especial — literais entre aspas duplas, o operador + para concatenação — então ela parece um primitivo na prática. O fato mais importante sobre strings: elas são imutáveis.

Este capítulo abrange como criar strings, por que a imutabilidade importa, como medir e indexar nelas, como compará-las corretamente, os métodos do dia a dia, concatenação, blocos de texto multi-linha e formatação.

Criando uma string

A forma mais simples é um literal de string entre aspas duplas:

String greeting = "Hello, World!";
String empty = "";
String multi = "Line 1\nLine 2";   // \n is a newline

Você também pode construir uma com new, embora raramente haja motivo para isso:

String fromLiteral = "Hello";
String fromNew = new String("Hello");

new String(...) sempre aloca um novo objeto. Literais são agrupados em pool — dois literais com os mesmos caracteres são o mesmo objeto. Isso importa para comparações com ==, mas pouco mais; você deve sempre usar .equals() para comparar conteúdos de qualquer forma.

Strings são imutáveis

Uma vez que uma String é criada, seu conteúdo nunca muda. Todo método que "modifica" uma string na verdade retorna uma nova string:

String s = "hello";
s.toUpperCase();
System.out.println(s);   // "hello" — unchanged

s = s.toUpperCase();
System.out.println(s);   // "HELLO" — new string assigned

A imutabilidade tem vários benefícios:

• Segura para compartilhar entre threads — nenhuma sincronização necessária.
• O hash code pode ser armazenado em cache.
• Strings podem ser usadas com segurança como chaves de map.

A desvantagem: construir uma string longa em um loop com + cria muitas strings intermediárias. Para isso, use StringBuilder (Concatenação de Strings).

Comprimento e indexação

length() retorna o número de caracteres:

String s = "hello";
System.out.println(s.length());   // 5

charAt(i) retorna o caractere no índice i (baseado em zero):

System.out.println(s.charAt(0));   // 'h'
System.out.println(s.charAt(4));   // 'o'
// s.charAt(5);  // StringIndexOutOfBoundsException

Nota: length() é o número de unidades de código UTF-16, nem sempre o número de caracteres percebidos pelo usuário. Para a maioria dos textos ASCII e BMP são iguais, mas emoji e alguns scripts não-latinos usam pares substitutos e contam como 2.

Comparando strings

Use .equals() para igualdade de conteúdo, nunca ==:

String a = new String("hi");
String b = new String("hi");

System.out.println(a == b);         // false
System.out.println(a.equals(b));    // true

equalsIgnoreCase ignora maiúsculas e minúsculas:

"HELLO".equalsIgnoreCase("hello");  // true

Para ordenação, use compareTo. Ele compara strings lexicograficamente (por código de caractere) e retorna um número negativo quando a primeira string vem antes da segunda, 0 quando são iguais, e um número positivo quando vem depois:

"apple".compareTo("banana");        // negative (a < b)
"apple".compareTo("apple");         // 0  — equal
"banana".compareTo("apple");        // positive (b > a)

Como a comparação é por código de caractere, letras maiúsculas (A–Z, códigos 65–90) vêm antes das minúsculas (a–z, códigos 97–122). Use compareToIgnoreCase para ordenação sem distinção de maiúsculas e minúsculas.

Operações comuns

Os métodos mais utilizados, com exemplos:

String s = "  Hello, World!  ";

s.length();                  // 17
s.trim();                    // "Hello, World!" (whitespace removed)
s.strip();                   // "Hello, World!" (Unicode-aware, Java 11+)
s.toUpperCase();             // "  HELLO, WORLD!  "
s.toLowerCase();             // "  hello, world!  "
s.contains("World");         // true
s.startsWith("  Hello");     // true
s.endsWith("!  ");           // true
s.indexOf("World");          // 9
s.indexOf("xyz");            // -1
s.replace(",", ";");         // "  Hello; World!  "
s.substring(2, 7);           // "Hello"
s.split(", ");               // ["  Hello", "World!  "]
s.isEmpty();                 // false  — length() == 0?
s.isBlank();                 // false  — only whitespace? (Java 11+)

Para a referência completa, veja Métodos de String em Java.

Concatenação

O operador + une strings e converte outros tipos para string conforme necessário:

String name = "Ada";
int age = 36;
String msg = "Name: " + name + ", Age: " + age;
// "Name: Ada, Age: 36"

Dentro de um loop, prefira StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

Blocos de texto — strings multi-linha

Desde o Java 15, os blocos de texto permitem escrever strings multi-linha sem escapes:

String json = """
        {
          "name": "Ada",
          "age": 36
        }
        """;

O compilador remove o espaço em branco inicial comum de cada linha, para que a indentação no código-fonte não afete a string.

Formatação

String.format constrói uma string com marcadores de posição no estilo printf:

String s = String.format("Name: %s, Age: %d", "Ada", 36);

Os marcadores de posição são os mesmos de System.out.printf — veja Saída em Java.

Uma demonstração

O que vem a seguir

Métodos de String em Java — uma referência de todos os métodos que você usará regularmente.

Prática