Java Métodos de String

Todos os métodos de String que você vai usar no dia a dia, agrupados pelo que fazem. Cada linha tem a assinatura, uma explicação curta, um exemplo e o resultado real, conferido no JShell do JDK 25. Para aprender com calma, veja as aulas Strings e Métodos de String.

Como ler as tabelas

A assinatura começa pelo tipo do resultado: int length() devolve um int; String substring(…) devolve uma String.
Os resultados estão no formato do JShell: textos entre aspas duplas ("nana"), caracteres entre aspas simples ('A') e arrays como String[3] { "a", "b", "c" }.
Os índices começam em 0: em "banana", o b é a posição 0 e o último a é a 5.
Nenhum método muda o texto original: String é imutável. Todos devolvem um valor novo (veja abaixo).

Atalhos: Tamanho · Pedaços · Procurar · Comparar · Maiúsculas e espaços · Trocar · Dividir e juntar · Converter · Linhas · Formatar

Experimente: qualquer linha das tabelas pode ser digitada aqui. Comece descobrindo a posição do segundo "na" de "banana" com indexOf("na", 3).

"banana".indexOf("na", 3)

Tamanho e caracteres

Método	O que faz	Exemplo	Resultado
`int length()`	Quantos caracteres o texto tem. Strings	`"Ana".length()` `"".length()`	`3` `0`
`char charAt(int índice)`	O caractere na posição (começa em 0). Fora do intervalo: `StringIndexOutOfBoundsException`. Métodos de String	`"Ana".charAt(0)` `"Ana".charAt(2)`	`'A'` `'a'`
`boolean isEmpty()`	`true` se o tamanho é 0. Métodos de String	`"".isEmpty()` `" ".isEmpty()`	`true` `false`
`boolean isBlank()` Java 11+	`true` se está vazio ou só tem espaços. Métodos de String	`" ".isBlank()` `"Ana".isBlank()`	`true` `false`
`int codePointAt(int índice)`	O código Unicode do caractere na posição. char e boolean	`"Ana".codePointAt(0)`	`65`
`char[] toCharArray()`	Um array com os caracteres. Arrays	`"Ana".toCharArray()`	`char[3] { 'A', 'n', 'a' }`
`IntStream chars()`	Um stream com os códigos dos caracteres (aqui, 97 + 98 + 99). Streams	`"abc".chars().sum()`	`294`

Pedaços

Método	O que faz	Exemplo	Resultado
`String substring(int início)`	Do índice `início` até o fim. Métodos de String	`"banana".substring(2)` `"banana".substring(6)`	`"nana"` `""`
`String substring(int início, int fim)`	De `início` até `fim`, sem incluir o `fim`. Tamanho do pedaço = fim − início. Métodos de String	`"banana".substring(1, 4)`	`"ana"`

Procurar

Método	O que faz	Exemplo	Resultado
`int indexOf(String texto)`	Posição da primeira ocorrência, ou `-1` se não achar. Métodos de String	`"banana".indexOf("na")` `"banana".indexOf("x")`	`2` `-1`
`int indexOf(String texto, int aPartirDe)`	Procura começando na posição indicada. Métodos de String	`"banana".indexOf("na", 3)`	`4`
`int indexOf(char c)`	O mesmo, para um caractere. Métodos de String	`"banana".indexOf('a')`	`1`
`int indexOf(char c, int início, int fim)` Java 21+	Procura só no trecho [início, fim). Métodos de String	`"banana".indexOf('a', 2, 4)`	`3`
`int lastIndexOf(String texto)`	Posição da última ocorrência. Métodos de String	`"banana".lastIndexOf("na")`	`4`
`int lastIndexOf(char c)`	Última ocorrência do caractere. Métodos de String	`"banana".lastIndexOf('a')`	`5`
`boolean contains(CharSequence texto)`	`true` se o texto aparece em qualquer lugar. Métodos de String	`"banana".contains("nan")`	`true`
`boolean startsWith(String prefixo)`	Começa com o prefixo? Métodos de String	`"banana".startsWith("ba")`	`true`
`boolean startsWith(String prefixo, int posição)`	Começa com o prefixo a partir da posição? Métodos de String	`"banana".startsWith("na", 2)`	`true`
`boolean endsWith(String sufixo)`	Termina com o sufixo? Métodos de String	`"banana".endsWith("na")`	`true`
`boolean matches(String regex)`	O texto inteiro casa com a expressão regular? Expressões Regulares	`"banana".matches("b[an]+")`	`true`

Comparar

Método	O que faz	Exemplo	Resultado
`boolean equals(Object outro)`	Mesmo conteúdo, letra por letra. Use sempre este, nunca `==`. Strings	`"Ana".equals("ana")`	`false`
`boolean equalsIgnoreCase(String outro)`	Igual, ignorando maiúsculas e minúsculas. Métodos de String	`"Ana".equalsIgnoreCase("ana")`	`true`
`int compareTo(String outro)`	Ordem de dicionário (pelos códigos Unicode): negativo se vem antes, 0 se igual, positivo se vem depois. Maiúsculas vêm antes de minúsculas. Comparable e Comparator	`"abacate".compareTo("banana")` `"banana".compareTo("abacate")` `"Ana".compareTo("Ana")` `"ana".compareTo("Bia")`	`-1` `1` `0` `31`
`int compareToIgnoreCase(String outro)`	Ordem ignorando maiúsculas. Comparable e Comparator	`"ana".compareToIgnoreCase("Bia")`	`-1`
`boolean contentEquals(CharSequence cs)`	Compara com um `StringBuilder` (ou outra sequência de caracteres). StringBuilder	`"Ana".contentEquals(new StringBuilder("Ana"))`	`true`
`int hashCode()`	Um número calculado do conteúdo, usado pelo `HashMap`. HashMap	`"Ana".hashCode()`	`65972`

Maiúsculas, minúsculas e espaços

Método	O que faz	Exemplo	Resultado
`String toUpperCase()`	Tudo em maiúsculas (acentos incluídos). Métodos de String	`"Olá, Ana".toUpperCase()`	`"OLÁ, ANA"`
`String toLowerCase()`	Tudo em minúsculas. Métodos de String	`"Olá, Ana".toLowerCase()`	`"olá, ana"`
`String trim()`	Tira espaços (e caracteres de controle) do começo e do fim. Não conhece os espaços Unicode, como o `\u2003`. Métodos de String	`" Ana ".trim()` `"\u2003Ana\u2003".trim().length()`	`"Ana"` `5`
`String strip()` Java 11+	Como o `trim`, mas entende todos os espaços Unicode. Prefira este. Métodos de String	`" Ana ".strip()` `"\u2003Ana\u2003".strip().length()`	`"Ana"` `3`
`String stripLeading()` Java 11+	Só do começo. Métodos de String	`" Ana ".stripLeading()`	`"Ana "`
`String stripTrailing()` Java 11+	Só do fim. Métodos de String	`" Ana ".stripTrailing()`	`" Ana"`

Trocar

Método	O que faz	Exemplo	Resultado
`String replace(char velho, char novo)`	Troca todas as ocorrências do caractere. Métodos de String	`"banana".replace('a', 'o')`	`"bonono"`
`String replace(CharSequence velho, CharSequence novo)`	Troca todas as ocorrências do texto (literal, sem regex). Métodos de String	`"banana".replace("na", "NA")`	`"baNANA"`
`String replaceAll(String regex, String novo)`	Troca tudo que casa com a expressão regular. Expressões Regulares	`"a1b22c333".replaceAll("[0-9]+", "#")`	`"a#b#c#"`
`String replaceFirst(String regex, String novo)`	Só a primeira ocorrência. Expressões Regulares	`"a1b22c333".replaceFirst("[0-9]+", "#")`	`"a#b22c333"`

Dividir e juntar

Método	O que faz	Exemplo	Resultado
`String[] split(String regex)`	Corta nos separadores. O separador é uma regex: o ponto precisa de `"\\."`. Pedaços vazios do fim são descartados. Métodos de String	`"maçã,banana,uva".split(",")` `"a,b,,c,,".split(",")` `"um dois tres".split(" +")` `"a.b.c".split(".")` `"a.b.c".split("\\.")`	`String[3] { "maçã", "banana", "uva" }` `String[4] { "a", "b", "", "c" }` `String[3] { "um", "dois", "tres" }` `String[0] { }` `String[3] { "a", "b", "c" }`
`String[] split(String regex, int limite)`	Com limite positivo, no máximo esse número de pedaços (o último leva o resto). Com `-1`, mantém os vazios do fim. Métodos de String	`"a,b,,c,,".split(",", -1)` `"2;false;Ler; e anotar".split(";", 3)`	`String[6] { "a", "b", "", "c", "", "" }` `String[3] { "2", "false", "Ler; e anotar" }`
`static String join(CharSequence separador, …)`	Junta vários textos (ou uma lista) com o separador entre eles. Concatenação	`String.join(", ", "maçã", "banana", "uva")` `String.join("-", java.util.List.of("2026", "10", "16"))`	`"maçã, banana, uva"` `"2026-10-16"`
`String concat(String outro)`	Junta no fim, como o `+`. Concatenação	`"Ana".concat(" Souza")`	`"Ana Souza"`
`String repeat(int vezes)` Java 11+	O texto repetido. Métodos de String	`"ab".repeat(3)` `"-".repeat(10)`	`"ababab"` `"----------"`

Converter para texto

Método	O que faz	Exemplo	Resultado
`static String valueOf(…)`	Transforma número, `boolean`, `char[]` ou qualquer objeto em `String`. Conversão de Tipos	`String.valueOf(42)` `String.valueOf(3.5)` `String.valueOf(true)` `String.valueOf(new char[] {'o', 'i'})`	`"42"` `"3.5"` `"true"` `"oi"`

Linhas e text blocks

Método	O que faz	Exemplo	Resultado
`Stream<String> lines()` Java 11+	Um stream com as linhas do texto. Text Blocks	`"linha 1\nlinha 2\nlinha 3".lines().count()`	`3`
`String indent(int n)` Java 12+	Acrescenta `n` espaços no começo de cada linha (ou tira, se negativo) e garante `\n` no fim. Text Blocks	`"Ana\nBia".indent(2)`	`" Ana\n Bia\n"`
`String stripIndent()` Java 15+	Tira o recuo comum de todas as linhas, como faz um text block. Text Blocks	`" Ana\n Bia".stripIndent()`	`"Ana\nBia"`
`String translateEscapes()` Java 15+	Transforma os códigos escritos (`\t`, `\n`…) nos caracteres de verdade. Caracteres Especiais	`"a\\tb".translateEscapes()`	`"a\tb"`

Formatar

Método	O que faz	Exemplo	Resultado
`static String format(String modelo, Object... valores)`	Monta um texto a partir de um modelo com `%s`, `%d`, `%.2f`… Usa o idioma do sistema: em pt_BR, vírgula decimal. Formatar Texto	`String.format("%s tem %d anos", "Ana", 29)` `String.format("%.2f", 3.14159)` `String.format("%08.3f", 3.14159)`	`"Ana tem 29 anos"` `"3,14"` `"0003,142"`
`String formatted(Object... valores)` Java 15+	O mesmo, chamado no próprio modelo. Formatar Texto	`"%s comprou %d itens".formatted("Bia", 3)`	`"Bia comprou 3 itens"`
`<R> R transform(Function f)` Java 12+	Aplica uma função ao texto e devolve o resultado. Lambdas	`"Ana".transform(t -> t + "!")`	`"Ana!"`

Armadilhas

Esquecer que String é imutável

        String nome = "Ana";
        nome.toUpperCase();
        System.out.println(nome);
        nome = nome.toUpperCase();
        System.out.println(nome);

$ java Main.java
Ana
ANA

A primeira chamada calculou "ANA" e jogou fora: nome continuou "Ana". Para guardar o resultado, atribua: nome = nome.toUpperCase();. Vale para todos os métodos desta página.

Comparar com ==

        String a = "Ana";
        String b = new Scanner("Ana").next();
        System.out.println(a == b);
        System.out.println(a.equals(b));

$ java Main.java
false
true

O texto é o mesmo, mas o que veio do Scanner é outro objeto. O == compara se são o mesmo objeto; o equals compara o conteúdo. Com textos digitados, lidos de arquivo ou montados no programa, o == dá false. Use sempre equals (veja Strings).

Índice fora do texto

$ java Main.java
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:55)
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:52)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:213)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:210)
	at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:98)
	at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:106)
	at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:302)
	at java.base/java.lang.String.checkIndex(String.java:4904)
	at java.base/java.lang.StringLatin1.charAt(StringLatin1.java:45)
	at java.base/java.lang.String.charAt(String.java:1624)
	at Main.main(Main.java:4)

"Ana".charAt(3): o texto tem 3 caracteres, nas posições 0, 1 e 2. O último índice válido é sempre length() - 1. Só a última linha do stack trace é do seu código. No substring, a mensagem mostra o intervalo pedido:

$ java Main.java
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 6
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:55)
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:52)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:213)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:210)
	at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:98)
	at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckFromToIndex(Preconditions.java:112)
	at java.base/jdk.internal.util.Preconditions.checkFromToIndex(Preconditions.java:349)
	at java.base/java.lang.String.checkBoundsBeginEnd(String.java:4937)
	at java.base/java.lang.String.substring(String.java:2899)
	at Main.main(Main.java:4)

"banana".substring(4, 2): o início (4) não pode ser maior que o fim (2). A notação [4, 2) quer dizer "de 4, incluído, até 2, excluído".

Missão: separe o e-mail em usuário e domínio usando indexOf('@') e substring (sem split), mostrando Usuário: ana.souza e Domínio: exemplo.com. O e-mail tem espaços sobrando e uma letra maiúscula: limpe com strip() e toLowerCase() antes.

public class Main {
    public static void main(String[] args) {
        String email = "  Ana.Souza@exemplo.com ";
        // limpe o e-mail, ache a posição do @ e separe as duas partes
    }
}

public class Main {
    public static void main(String[] args) {
        String email = "  Ana.Souza@exemplo.com ";
        email = email.strip().toLowerCase();
        int arroba = email.indexOf('@');
        String usuario = email.substring(0, arroba);
        String dominio = email.substring(arroba + 1);
        System.out.println("Usuário: " + usuario);
        System.out.println("Domínio: " + dominio);
    }
}

Exercícios

1. Quanto vale "banana".substring(1, 4)?

"bana" "ana" "anan" "nan"

2. Por que "a.b.c".split(".") devolve um array vazio?

Porque o ponto não pode aparecer em textos. Porque split só aceita vírgula. É um defeito do Java. O separador é uma regex, e . casa com qualquer caractere: tudo vira separador e os pedaços vazios do fim são descartados. Use "\\.".

3. Na máquina da Ana (pt_BR), quanto vale String.format("%.2f", 3.14159)?

"3,14" "3.14" "3.14159" "3"

4. Qual a diferença entre trim() e strip()?

trim tira só do começo. Nenhuma. strip (Java 11) entende todos os espaços Unicode; trim só os do ASCII. strip tira também as letras repetidas.

Complete para saber se o nome termina com "a":

nome.("a")

Resumo

Tamanho e posições: length, charAt, indexOf/lastIndexOf (−1 se não achar), substring(início, fim) sem o fim.
Testes: isEmpty, isBlank, contains, startsWith, endsWith, equals, equalsIgnoreCase, compareTo.
Transformações: toUpperCase, strip, replace, repeat, split (regex!), String.join, String.format (vírgula em pt_BR).
Nenhum método altera a String: guarde o resultado. Compare com equals, nunca com ==.