Métodos de String em Java

A classe String possui dezenas de métodos. Este capítulo é uma referência prática dos que você realmente vai usar, agrupados pelo que fazem: inspecionar, comparar, pesquisar, fatiar, transformar, dividir/juntar, converter e formatar.

Lembre-se: strings são imutáveis. Cada método abaixo retorna uma nova string (ou outro valor) — ele nunca altera a string sobre a qual foi chamado. Isso significa que uma chamada como s.toUpperCase(); sozinha não faz nada útil; você precisa capturar o resultado:

String s = "hello";
s.toUpperCase();        // result discarded — s is still "hello"
s = s.toUpperCase();    // s is now "HELLO"

Os índices são baseados em zero e contam unidades de código UTF-16, não caracteres percebidos pelo usuário, o que importa para emojis e outros caracteres suplementares.

Inspecionando uma string

"hello".length();      // 5
"".isEmpty();          // true
"   ".isBlank();       // true
"hello".charAt(1);     // 'e'

Comparando strings

"hi".equals("hi");                  // true
"HI".equalsIgnoreCase("hi");        // true
"apple".compareTo("banana");        // negative

Prefira sempre .equals() em vez de == para comparação de conteúdo (Operadores de Comparação). == compara referências de objetos — se duas variáveis apontam para o mesmo objeto — não os caracteres dentro deles. Como o Java interna literais de string, == às vezes parece funcionar, mas falha no momento em que uma string é construída em tempo de execução:

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

a == b;          // true  — both point to the same interned literal
a == c;          // false — c is a different object
a.equals(c);     // true  — same contents

compareTo é o que você precisa para ordenação: retorna um número negativo, zero ou um número positivo, então se encaixa diretamente em Collections.sort ou cadeias de Comparator.

Pesquisando

String s = "abc-xyz-abc";
s.contains("xyz");       // true
s.indexOf("abc");        // 0
s.lastIndexOf("abc");    // 8
s.startsWith("abc");     // true
s.endsWith("xyz");       // false

Fatiando

String s = "Hello, World!";
s.substring(7);        // "World!"
s.substring(7, 12);    // "World"

Índices negativos não são permitidos — eles lançam StringIndexOutOfBoundsException.

Transformando

"  hello  ".strip();                 // "hello"
"banana".replace("a", "_");          // "b_n_n_"
"hello".repeat(3);                   // "hellohellohello"
"abc 123".replaceAll("\\d", "*");    // "abc ***"

Dividindo e juntando

"a,b,c".split(",");                     // ["a","b","c"]
String.join("-", "a", "b", "c");        // "a-b-c"
String.join(",", List.of("a","b"));     // "a,b"
"line1\nline2\nline3".lines().count();  // 3

split recebe uma regex, não uma string simples — por isso escape os meta-caracteres de regex: use split("\\.") para dividir em um ponto literal, não split(".") (que corresponde a todo caractere e retorna um array vazio). Strings vazias no final são descartadas por padrão; passe um limit negativo (ex.: split(",", -1)) para mantê-las.

Conversão

String.valueOf(42);              // "42"
Integer.parseInt("42");          // 42
Double.parseDouble("3.14");      // 3.14
"hello".toCharArray();           // {'h','e','l','l','o'}

Os métodos parse* lançam NumberFormatException se o texto não for um número válido, então envolva a entrada do usuário em um try/catch ou valide-a primeiro. Diferentemente de parseInt, String.valueOf(null) é seguro — retorna a string "null" em vez de lançar uma exceção.

Formatando

String.format("%s is %d", "Ada", 36);     // "Ada is 36"
"%s is %d".formatted("Ada", 36);          // "Ada is 36"

Uma demonstração combinada

O que vem a seguir

Concatenação de String em Java aprofunda +, concat e StringBuilder, incluindo quando cada um é a ferramenta certa.

Prática