Métodos Comuns e

Funcionamento da Manipulação
de Strings em Java
A manipulação de strings é uma tarefa fundamental na programação Java, essencial para o processamento e representação de
dados textuais em diversas aplicações 1. A classe String em Java é a base para trabalhar com sequências de caracteres,
oferecendo uma vasta gama de métodos para realizar operações como modificar a caixa, extrair partes de strings, buscar padrões,
substituir texto e comparar sequências 3. Compreender esses métodos e seu funcionamento interno é crucial para o
desenvolvimento eficaz em Java.

Métodos Comuns de Manipulação de Strings em Java

A classe String fornece diversos métodos para manipular o conteúdo das strings. Estes métodos podem ser agrupados por
categorias de funcionalidade, facilitando a compreensão e o uso.

Métodos para Modificar a Caixa (Maiúscula/Minúscula)

A alteração da capitalização das letras em uma string é uma operação comum para padronização de texto.

toLowerCase(): Este método converte todos os caracteres da string para minúsculas, utilizando as regras do locale padrão
3. A padronização para minúsculas é frequentemente utilizada em comparações que não devem distinguir entre maiúsculas
e minúsculas ou na formatação de saída de dados. Por exemplo:

String texto = "Olá Mundo";

String textoMinusculo = [Link]();
[Link](textoMinusculo); // Saída: olá mundo

toUpperCase(): Similarmente, este método transforma todos os caracteres da string para maiúsculas, seguindo as regras
do locale padrão 3. A conversão para maiúsculas pode ser útil para destacar texto ou para realizar comparações que
ignoram a capitalização. Veja o exemplo:

Java

String texto = "Olá Mundo";

String textoMaiusculo = [Link]();
[Link](textoMaiusculo); // Saída: OLÁ MUNDO

Métodos para Extrair Substrings

A extração de partes específicas de uma string é essencial para acessar informações contidas em sequências de texto maiores.

substring(int beginIndex): Este método retorna uma nova string que é uma substring da original, começando no
índice especificado (beginIndex) e estendendo-se até o final da string 3. A capacidade de obter a parte final de uma string
a partir de um ponto específico é útil em diversas situações, como ao processar logs ou arquivos de texto. O exemplo a
 seguir ilustra seu uso:

Java

String texto = "Hello World";

String sub = [Link](6);
[Link](sub); // Saída: World

substring(int beginIndex, int endIndex): Esta versão do método substring permite especificar o índice de
início (inclusivo) e o índice de fim (exclusivo) da substring a ser extraída 3. Essa flexibilidade é importante para isolar
segmentos precisos de texto, como palavras dentro de uma frase ou códigos específicos em uma string. O código demonstra
a extração de uma parte do texto:

Java

String texto = "Hello World";

String sub = [Link](0, 5);
[Link](sub); // Saída: Hello

subSequence(int beginIndex, int endIndex): Este método retorna uma CharSequence que é uma subsequência
da string original, comportando-se de maneira idêntica ao substring(int beginIndex, int endIndex) 4. Embora
retorne um tipo mais genérico (CharSequence), seu uso prático para extrair uma parte da string é o mesmo. Um exemplo
de uso é:

Java

String texto = "Hello World";

CharSequence sub = [Link](6, 11);
[Link](sub); // Saída: World

Métodos para Buscar ou Verificar a Presença de Caracteres ou Substrings

A capacidade de encontrar a localização de caracteres ou substrings dentro de uma string, ou simplesmente verificar sua existência,
é fundamental para a análise de texto.

indexOf(int ch): Este método retorna o índice da primeira ocorrência do caractere especificado (representado pelo seu
valor Unicode) dentro da string. Se o caractere não for encontrado, retorna -1 3. A identificação da primeira posição de um
caractere é útil em tarefas como a análise de formatos de arquivo ou a separação de dados. O exemplo mostra como
encontrar a primeira ocorrência de um caractere:

Java

String texto = "Hello World";

int indice = [Link]('o');
[Link](indice); // Saída: 4
indexOf(int ch, int fromIndex): Esta versão do método indexOf permite especificar o índice a partir do qual a
busca pelo caractere deve começar 3. Isso é útil para encontrar ocorrências subsequentes de um caractere após uma
determinada posição. O código demonstra a busca de um caractere a partir de um índice específico:

Java

String texto = "Hello World o";

int indice = [Link]('o', 5);
[Link](indice); // Saída: 10

indexOf(String str): Este método retorna o índice da primeira ocorrência da substring especificada dentro da string. Se
a substring não for encontrada, retorna -1 3. A busca por substrings é crucial para identificar padrões específicos em textos,
como palavras-chave ou frases. Veja o exemplo:

Java

String texto = "Hello World";

int indice = [Link]("World");
[Link](indice); // Saída: 6

indexOf(String str, int fromIndex): Similar à versão para caracteres, este método permite especificar o índice a
partir do qual a busca pela substring deve começar 3. Isso é útil para encontrar ocorrências posteriores de uma substring. O
exemplo ilustra a busca de uma substring a partir de um índice:

Java

String texto = "Hello World World";

int indice = [Link]("World", 7);
[Link](indice); // Saída: 12

lastIndexOf(int ch): Este método retorna o índice da última ocorrência do caractere especificado dentro da string 3.
Encontrar a última posição de um caractere pode ser importante em cenários como a análise do final de um arquivo ou a
identificação do último delimitador. O código mostra como encontrar a última ocorrência de um caractere:

Java

String texto = "Hello World o";

int indice = [Link]('o');
[Link](indice); // Saída: 10

lastIndexOf(int ch, int fromIndex): Esta versão do método lastIndexOf permite especificar o índice a partir do
qual a busca pelo caractere deve começar, buscando para trás 3. Isso possibilita encontrar a última ocorrência de um
caractere antes de uma determinada posição. O exemplo demonstra a busca da última ocorrência de um caractere antes de
um índice específico:

Java
 String texto = "Hello World o";
int indice = [Link]('o', 9);
[Link](indice); // Saída: 4

lastIndexOf(String str): Este método retorna o índice da última ocorrência da substring especificada dentro da string
3. Similar ao indexOf para substrings, mas buscando a última ocorrência. O exemplo a seguir ilustra seu uso:

Java

String texto = "Hello World World";

int indice = [Link]("World");
[Link](indice); // Saída: 12

lastIndexOf(String str, int fromIndex): Similar à versão para caracteres, este método permite especificar o
índice a partir do qual a busca pela substring deve começar, buscando para trás 3. Isso é útil para encontrar a última
ocorrência de uma substring antes de um índice específico. O código demonstra a busca da última ocorrência de uma
substring antes de um índice:

Java

String texto = "Hello World World";

int indice = [Link]("World", 11);
[Link](indice); // Saída: 6

contains(CharSequence s): Este método retorna true se e somente se a string contiver a sequência de caracteres
especificada 3. É uma maneira simples de verificar a presença de uma substring sem precisar saber sua posição exata. O
exemplo mostra como verificar se uma string contém outra:

Java

String texto = "Hello World";

boolean contem = [Link]("World");
[Link](contem); // Saída: true

startsWith(String prefix): Este método verifica se a string começa com o prefixo especificado 3. É útil para validar
formatos de strings ou para filtrar dados com base em um início comum. O exemplo a seguir ilustra seu uso:

Java

String texto = "Hello World";

boolean comecaCom = [Link]("Hello");
[Link](comecaCom); // Saída: true

startsWith(String prefix, int toffset): Esta versão do método startsWith permite especificar um índice
inicial (toffset) a partir do qual a verificação do prefixo deve começar 4. Isso oferece mais flexibilidade ao verificar o início
de uma substring dentro da string original. O código demonstra a verificação de um prefixo a partir de um índice específico:
Java

String texto = "Hello World";

boolean comecaCom = [Link]("World", 6);
[Link](comecaCom); // Saída: true

endsWith(String suffix): Este método verifica se a string termina com o sufixo especificado 3. É comumente usado
para validar extensões de arquivos ou para identificar o final de sequências de dados. O exemplo mostra como verificar o
sufixo de uma string:

Java

String texto = "Hello World";

boolean terminaCom = [Link]("World");
[Link](terminaCom); // Saída: true

Métodos para Substituir Caracteres ou Substrings

A substituição de caracteres ou substrings é uma operação essencial para modificar o conteúdo de uma string.

replace(char oldChar, char newChar): Este método retorna uma nova string resultante da substituição de todas as
ocorrências do caractere oldChar por newChar 3. É útil para realizar substituições simples de caracteres em toda a string.
O código a seguir ilustra seu uso:

Java

String texto = "Hello World";

String substituido = [Link]('o', 'u');
[Link](substituido); // Saída: Hellu Wurld

replace(CharSequence target, CharSequence replacement): Este método substitui cada substring da string que
corresponda à sequência literal target pela sequência literal replacement especificada 4. Isso permite substituir
substrings inteiras por outras. O exemplo demonstra a substituição de uma substring por outra:

Java

String texto = "Hello World";

String substituido = [Link]("World", "Java");
[Link](substituido); // Saída: Hello Java

replaceAll(String regex, String replacement): Este método substitui cada substring da string que corresponda
à expressão regular fornecida (regex) pela string replacement 4. A utilização de expressões regulares oferece um poder
significativo para realizar substituições baseadas em padrões complexos. O código a seguir mostra um exemplo de
substituição usando uma expressão regular:

Java
 String texto = "Hello 123 World";
String substituido = [Link]("\\d+", "Número");
[Link](substituido); // Saída: Hello Número World

replaceFirst(String regex, String replacement): Este método substitui a primeira substring da string que
corresponda à expressão regular fornecida (regex) pela string replacement 4. É útil quando apenas a primeira ocorrência
de um padrão precisa ser substituída. O exemplo ilustra a substituição da primeira ocorrência de um padrão:

Java

String texto = "Hello 123 World 456";

String substituido = [Link]("\\d+", "Número");
[Link](substituido); // Saída: Hello Número World 456

Métodos para Comparar Strings

A comparação de strings é fundamental para determinar se duas sequências de caracteres são iguais ou para estabelecer uma
ordem entre elas.

equals(Object anObject): Este método compara a string com o objeto especificado. Retorna true se o objeto for uma
String e representar a mesma sequência de caracteres que a string original; caso contrário, retorna false 3. Esta é a
maneira padrão de verificar a igualdade de conteúdo entre duas strings. O exemplo mostra como comparar duas strings:

Java

String texto1 = "Hello";

String texto2 = "Hello";
boolean igual = [Link](texto2);
[Link](igual); // Saída: true

equalsIgnoreCase(String anotherString): Este método compara a string com outra string, ignorando diferenças de
caixa 3. Isso é útil em situações onde a capitalização não é relevante para a comparação, como na validação de entradas de
usuários. O código a seguir ilustra seu uso:

Java

String texto1 = "Hello";

String texto2 = "hello";
boolean igualIgnorandoCase = [Link](texto2);
[Link](igualIgnorandoCase); // Saída: true

compareTo(String anotherString): Este método compara duas strings lexicograficamente, com base no valor
Unicode de cada caractere. Retorna um inteiro negativo, zero ou positivo se esta string for menor que, igual a ou maior que a
outra string, respectivamente 3. A comparação lexicográfica é usada para ordenar strings alfabeticamente ou para
determinar sua ordem relativa. O exemplo demonstra a comparação lexicográfica de duas strings:

Java
 String texto1 = "Apple";
String texto2 = "Banana";
int resultadoComparacao = [Link](texto2);
[Link](resultadoComparacao); // Saída: -1 (aproximadamente)

compareToIgnoreCase(String str): Similar ao compareTo, este método compara duas strings lexicograficamente,
mas ignorando diferenças de caixa 3. Isso combina a ordenação alfabética com a insensibilidade à capitalização. O código
mostra um exemplo de comparação lexicográfica ignorando a caixa:

Java

String texto1 = "Apple";

String texto2 = "apple";
int resultadoComparacaoIgnorandoCase = [Link](texto2);
[Link](resultadoComparacaoIgnorandoCase); // Saída: 0

regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len): Este método
verifica se duas regiões de string são iguais. Permite especificar se a comparação deve ignorar a caixa 4. Isso é útil para
comparar partes específicas de duas strings. O exemplo a seguir ilustra seu uso:

Java

String texto1 = "Hello World";

String texto2 = "World";
boolean correspondenciaDeRegiao = [Link](true, 6, texto2, 0, 5);
[Link](correspondenciaDeRegiao); // Saída: true

regionMatches(int toffset, String other, int ooffset, int len): Similar ao método anterior, mas realiza
uma comparação sensível à caixa 4. O código demonstra uma comparação de região sensível à caixa:

Java

String texto1 = "Hello World";

String texto2 = "World";
boolean correspondenciaDeRegiao = [Link](6, texto2, 0, 5);
[Link](correspondenciaDeRegiao); // Saída: true

Outros Métodos Relevantes

Além dos métodos agrupados por funcionalidade, existem outros métodos importantes para a manipulação de strings.

length(): Retorna o número de caracteres (code units Unicode) nesta string 3. É um método fundamental para determinar
o tamanho de uma string. Exemplo:

Java
 String texto = "Hello";
int tamanho = [Link]();
[Link](tamanho); // Saída: 5

charAt(int index): Retorna o valor do caractere (char) no índice especificado 3. Permite acessar caracteres individuais
dentro da string. Exemplo:

Java

String texto = "Hello";

char caractere = [Link](0);
[Link](caractere); // Saída: H

toCharArray(): Converte esta string em um novo array de caracteres 3. Útil quando a string precisa ser manipulada como
uma coleção de caracteres. Exemplo:

Java

String texto = "Hello";

char arrayDeCaracteres = [Link]();
[Link]([Link](arrayDeCaracteres)); // Saída: [H, e, l, l, o]

trim(): Retorna uma string cujo valor é esta string, com quaisquer espaços em branco iniciais e finais removidos 3.
Importante para limpar entradas de usuários ou dados de fontes externas. Exemplo:

Java

String texto = " Hello World ";

String textoTrimmed = [Link]();
[Link](textoTrimmed); // Saída: Hello World

concat(String str): Concatena a string especificada ao final desta string 3. Usado para combinar duas ou mais strings.
Note que o operador + é mais comumente usado para concatenação. Exemplo:

Java

String texto1 = "Hello";

String texto2 = " World";
String textoCombinado = [Link](texto2);
[Link](textoCombinado); // Saída: Hello World

split(String regex): Divide esta string em torno de correspondências da expressão regular fornecida. Retorna um
array de strings 3. Útil para analisar strings em partes menores com base em um delimitador. Exemplo:

Java
 String texto = "Hello,World,Java";
String partes = [Link](",");
[Link]([Link](partes)); // Saída: [Hello, World, Java]

split(String regex, int limit): Divide esta string em torno de correspondências da expressão regular fornecida,
com o parâmetro limit controlando o número de vezes que o padrão é aplicado e, portanto, o comprimento do array
resultante 4. Oferece controle sobre o número de substrings resultantes após a divisão. Exemplo:

Java

String texto = "Hello,World,Java,Spring";

String partes = [Link](",", 2);
[Link]([Link](partes)); // Saída:

valueOf(various types): Existem várias versões sobrecarregadas do método valueOf que convertem diferentes tipos
de dados primitivos (boolean, char, int, long, float, double) e Object para suas representações em string 4. Essencial para
converter dados não string em strings para exibição ou manipulação. Exemplos:

Java

int numero = 10;

String stringNumero = [Link](numero);
[Link](stringNumero); // Saída: 10

boolean flag = true;

String stringFlag = [Link](flag);
[Link](stringFlag); // Saída: true

strip(): Remove todos os espaços em branco iniciais e finais da string especificada. Similar a trim(), mas lida também
com caracteres de espaço em branco Unicode 5. Oferece uma remoção de espaços em branco mais abrangente que
trim(). Exemplo:

Java

String texto = "\u2000 Hello World \u2000"; // \u2000 é um caractere de espaço Unicode
String textoStripped = [Link]();
[Link](textoStripped); // Saída: Hello World

isEmpty(): Retorna true se e somente se length() for 0 4. Uma maneira conveniente de verificar se uma string está
vazia. Exemplo:

Java
 String texto1 = "";
String texto2 = "Hello";
[Link]([Link]()); // Saída: true
[Link]([Link]()); // Saída: false

intern(): Retorna uma representação canônica para o objeto string. Ele recupera a string do pool de strings se ela existir,
ou a adiciona ao pool e retorna a referência 4. Pode ser usado para otimizar a memória, garantindo que apenas uma
instância de um literal de string exista na JVM. Exemplo:

Java

String texto1 = new String("Hello");

String texto2 = "Hello";
[Link](texto1 == texto2); // Saída: false
[Link]([Link]() == texto2); // Saída: true

matches(String regex): Informa se esta string corresponde ou não à expressão regular fornecida 4. Poderoso para
validar formatos de string em relação a padrões complexos. Exemplo:

Java

String texto = "12345";

boolean corresponde = [Link]("\\d+");
[Link](corresponde); // Saída: true

join(CharSequence delimiter, CharSequence... elements): Retorna uma nova String composta por cópias
dos elementos CharSequence unidos por uma cópia do delimiter especificado 4. Uma maneira conveniente de
concatenar várias strings com um delimitador especificado. Exemplo:

Java

String unido = [Link]("-", "Hello", "World", "Java");

[Link](unido); // Saída: Hello-World-Java

join(CharSequence delimiter, Iterable<? extends CharSequence> elements): Similar à versão varargs,

mas aceita um Iterable de elementos CharSequence 4. Exemplo:

Java

[Link]<String> palavras = [Link]("Hello", "World", "Java");

String unido = [Link](" ", palavras);
[Link](unido); // Saída: Hello World Java

A Imutabilidade da Classe String em Java

 Em Java, a classe String é imutável, o que significa que, uma vez que um objeto String é criado, seu valor não pode ser
alterado 3. Qualquer operação que pareça modificar uma string, na verdade, cria um novo objeto String na memória 14. Considere
o seguinte exemplo:

Java

String texto1 = "Hello";

String texto2 = [Link](" World");
[Link](texto1); // Saída: Hello
[Link](texto2); // Saída: Hello World

Neste exemplo, a string original texto1 permanece inalterada após a operação concat. O método concat não modifica o objeto
existente; em vez disso, ele cria um novo objeto String (texto2) contendo a concatenação das duas strings.

A imutabilidade das strings em Java oferece várias vantagens importantes:

Segurança: Strings são frequentemente usadas para armazenar informações sensíveis, como nomes de usuários e senhas.
A imutabilidade garante que esses dados não possam ser alterados inadvertidamente após a criação, protegendo contra
possíveis vulnerabilidades de segurança 14.
Thread Safety: Objetos imutáveis são inerentemente thread-safe, pois seu estado não pode ser modificado por múltiplos
threads simultaneamente. Isso elimina a necessidade de sincronização explícita ao compartilhar strings entre threads,
simplificando a programação concorrente 14.
Otimização do Pool de Strings: A Java Virtual Machine (JVM) mantém um pool de strings (String pool) para armazenar
literais de string. Quando uma string literal é criada, a JVM primeiro verifica se uma string com o mesmo valor já existe no
pool. Se existir, a JVM simplesmente retorna uma referência ao objeto existente em vez de criar um novo. A imutabilidade é
crucial para essa otimização, pois permite que múltiplas referências apontem para a mesma string sem o risco de uma
referência alterar o valor para outras 14.
Caching do Hashcode: Como o valor de uma string nunca muda, seu hashcode pode ser calculado uma vez no momento
da criação e armazenado em cache. Isso melhora o desempenho quando as strings são usadas como chaves em coleções
baseadas em hash, como HashMap e HashSet 15.

StringBuilder e StringBuffer para Manipulações Eficientes

Embora a imutabilidade da classe String ofereça muitos benefícios, ela pode levar a uma sobrecarga de desempenho em
situações que exigem modificações frequentes de strings, como a concatenação repetida dentro de um loop 17. Para esses
cenários, Java fornece as classes mutáveis StringBuilder e StringBuffer.

Tanto StringBuilder quanto StringBuffer permitem modificar o conteúdo de um objeto string sem criar uma nova instância a
cada alteração. Eles oferecem métodos como append() para adicionar texto ao final da sequência, insert() para inserir texto em
uma posição específica, delete() para remover caracteres dentro de um intervalo e reverse() para inverter a ordem dos
caracteres 4.

A principal diferença entre StringBuilder e StringBuffer reside na thread safety. StringBuffer é sincronizado, o que o
torna thread-safe e adequado para uso em ambientes multi-threaded onde múltiplas threads podem acessar e modificar a string
simultaneamente 19. No entanto, essa sincronização introduz uma sobrecarga de desempenho, tornando StringBuffer
geralmente mais lento que StringBuilder em cenários single-threaded.

StringBuilder, por outro lado, não é sincronizado e, portanto, oferece melhor desempenho em aplicações single-threaded ou
quando a thread safety não é uma preocupação 19.
 Exemplos de uso:

Java

StringBuilder sb = new StringBuilder("Hello");

[Link](" World");
String resultadoSb = [Link]();
[Link](resultadoSb); // Saída: Hello World

StringBuffer sbuf = new StringBuffer("Java");

[Link](4, " SE");
String resultadoSbuf = [Link]();
[Link](resultadoSbuf); // Saída: Java SE

Em situações onde a performance é crítica e as modificações de string são frequentes, especialmente em contextos single-threaded,
StringBuilder é a escolha mais eficiente. StringBuffer deve ser usado quando a thread safety é um requisito.

Resumo dos Métodos de String

A tabela a seguir resume os métodos de string comuns discutidos neste relatório, juntamente com sua funcionalidade principal e tipo
de retorno.

Tipo de
Método Funcionalidade
Retorno
toLowerCase()
Converte todos os caracteres para String
minúsculas.
toUpperCase()
Converte todos os caracteres para String
maiúsculas.
substring(int beginIndex)
Retorna uma substring a partir do String
índice inicial até o final.
substring(int beginIndex, int endIndex)
Retorna uma substring entre os índices String
inicial (inclusivo) e final (exclusivo).
subSequence(int beginIndex, int endIndex)
Retorna uma CharSequence que é uma CharSequence
subsequência.
indexOf(int ch)
Retorna o índice da primeira int
ocorrência do caractere.
Retorna o índice da primeira
indexOf(int ch, int fromIndex) ocorrência do caractere, começando int
de um índice.
indexOf(String str)
Retorna o índice da primeira int
ocorrência da substring.
Retorna o índice da primeira
indexOf(String str, int fromIndex) ocorrência da substring, começando int
de um índice.
lastIndexOf(int ch)
Retorna o índice da última ocorrência int
do caractere.
lastIndexOf(int ch, int fromIndex)
Retorna o índice da última ocorrência int
do caractere, buscando para trás.
lastIndexOf(String str)
Retorna o índice da última ocorrência int
da substring.
lastIndexOf(String str, int fromIndex)
Retorna o índice da última ocorrência int
da substring, buscando para trás.
contains(CharSequence s)
Verifica se a string contém a sequência boolean
de caracteres.
startsWith(String prefix)
Verifica se a string começa com o boolean
prefixo.
startsWith(String prefix, int toffset)
Verifica se a substring a partir de um boolean
índice começa com o prefixo.
endsWith(String suffix)
Verifica se a string termina com o boolean
sufixo.
replace(char oldChar, char newChar)
Substitui todas as ocorrências de um String
caractere por outro.
replace(CharSequence target, CharSequence Substitui todas as ocorrências de uma
String
replacement) substring por outra.
replaceAll(String regex, String Substitui todas as substrings String
replacement) correspondentes à regex.
replaceFirst(String regex, String Substitui a primeira substring String
replacement) correspondente à regex.
equals(Object anObject)
Compara a string com outro objeto boolean
para igualdade de conteúdo.
equalsIgnoreCase(String anotherString)
Compara a string com outra ignorando boolean
a caixa.
compareTo(String anotherString)
Compara duas strings int
lexicograficamente.
compareToIgnoreCase(String str)
Compara duas strings int
lexicograficamente, ignorando a caixa.
regionMatches(boolean ignoreCase, int Verifica se duas regiões de string são
toffset, String other, int ooffset, int iguais, opcionalmente ignorando a boolean
len) caixa.
regionMatches(int toffset, String other, Verifica se duas regiões de string são
boolean
int ooffset, int len) iguais.
length() Retorna o comprimento da string. int

charAt(int index)
Retorna o caractere no índice char
especificado.
toCharArray()
Converte a string para um array de char
caracteres.
trim()
Remove espaços em branco iniciais e String
finais.
concat(String str)
Concatena a string especificada ao String
final.
split(String regex)
Divide a string em torno de String
correspondências da regex.
Divide a string em torno de
split(String regex, int limit) correspondências da regex com um String
limite.
valueOf(various types)
Retorna a representação em string de String
diferentes tipos de dados.
strip()
Remove espaços em branco iniciais e String
finais (incluindo Unicode).
isEmpty() Verifica se a string está vazia. boolean

intern()
Retorna a representação canônica da String
string do pool de strings.
matches(String regex)
Verifica se a string corresponde à boolean
expressão regular.
join(CharSequence delimiter, Une várias sequências de caracteres String
CharSequence... elements) com um delimitador.
join(CharSequence delimiter, Iterable<? Une uma coleção de sequências de String
extends CharSequence> elements) caracteres com um delimitador.

Conclusão

A manipulação de strings é uma parte essencial do desenvolvimento em Java, e a classe String oferece uma ampla gama de
métodos para realizar diversas operações. A compreensão da funcionalidade de cada método, juntamente com o conceito
fundamental da imutabilidade das strings, permite aos desenvolvedores escrever código eficiente e correto. Para tarefas que
envolvem modificações frequentes de strings, as classes mutáveis StringBuilder e StringBuffer fornecem alternativas mais
performáticas, sendo StringBuilder preferível para ambientes single-threaded e StringBuffer para cenários multi-threaded. A
escolha do método apropriado para cada situação garante a eficiência e a clareza do código Java.

Referências citadas

1. Java variables: Tutorial de variáveis em Java - IONOS, acessado em março 30, 2025, [Link]
br/digitalguide/sites-de-internet/desenvolvimento-web/java-variables-variaveis-em-java/ ([Link]
br/digitalguide/sites-de-internet/desenvolvimento-web/java-variables-variaveis-em-java/)

2. Variaveis e tipos de dados Java | Fernando Jesus | Java | DIO, acessado em março 30, 2025,
[Link] ([Link]

3. String class in Java | GeeksforGeeks, acessado em março 30, 2025, [Link]

([Link]

4. String (Java Platform SE 8 ) - Oracle Help Center, acessado em março 30, 2025,
[Link]
([Link]

5. 10 Important String Methods In Java You Must Know - [Link], acessado em março 30, 2025, [Link]
methods-in-java/ ([Link]

6. [Link] Class String, acessado em março 30, 2025, [Link]

impl/cldc1.0/jsr030/java/lang/[Link] ([Link]
impl/cldc1.0/jsr030/java/lang/[Link])

7. Java String (With Examples) - Programiz, acessado em março 30, 2025, [Link]
([Link]

8. String Methods - Oracle Help Center, acessado em março 30, 2025,

[Link]
([Link]

9. 10 Java String methods, Reference and their types - Medium, acessado em março 30, 2025,
[Link]
([Link]

10. Strings - Learning the Java Language, acessado em março 30, 2025,
[Link] ([Link]
11. Java String Methods: From Beginner to Expert - [Link], acessado em março 30, 2025, [Link]
string-methods/ ([Link]

12. 10 most useful string methods in Java - DEV Community, acessado em março 30, 2025, [Link]
useful-string-methods-in-java-4lag ([Link]

13. StringBuilder (Java Platform SE 8 ) - Oracle Help Center, acessado em março 30, 2025,
[Link]
([Link]

14. Why Java Strings are Immutable? | GeeksforGeeks, acessado em março 30, 2025, [Link]
string-is-immutable-what-exactly-is-the-meaning/ ([Link]
the-meaning/)

15. Why String is Immutable in Java? - Scaler Topics, acessado em março 30, 2025, [Link]
immutable-in-java/ ([Link]

16. String is immutable. What exactly is the meaning? [duplicate] - Stack Overflow, acessado em março 30, 2025,
[Link]
([Link]

17. What does it mean when they say that a String is "immutable"? : r/javahelp - Reddit, acessado em março 30, 2025,
[Link]
([Link]

18. What is difference between mutable and immutable String in java - Stack Overflow, acessado em março 30, 2025,
[Link]
([Link]

19. String vs StringBuilder vs StringBuffer in Java | GeeksforGeeks, acessado em março 30, 2025,
[Link] ([Link]
stringbuilder-vs-stringbuffer-in-java/)

20. String Handling in Java: Immutability of Strings, StringBuilder vs ..., acessado em março 30, 2025,
[Link]
([Link]

21. “Java Strings: Immutability, Methods, and Performance ... - Medium, acessado em março 30, 2025,
[Link]
586fbe546906 ([Link]
13-586fbe546906)

22. Understanding String Immutability vs StringBuffer/StringBuilder in ..., acessado em março 30, 2025,
[Link]
([Link]

23. Blog | Java: String vs StringBuilder vs StringBuffer, acessado em março 30, 2025, [Link]
string-vs-string-builder-vs-string-buffer ([Link]