Conhecendo a classe String: métodos

byFábio Fernandes •
2
Conhecendo a classe String: métodos
logo Java

Ei, devs! Quantas vezes nos deparamos com as seguintes questões:

  • Como verifico quantos caracteres tem esse texto? ou
  • Como verifico se este texto é igual à outro? ou ainda
  • Como posso juntar blocos de textos?
  • Ou como sei que este bloco é/está vazio? entre outras...

E a resposta para todas estas questões está no mesmo lugar, isto é, na mesma classe, a java.lang.String. Assim, neste post, nossa proposta é lhe apresentar os principais (e não únicos) métodos propostos por ela.

Bom, esta classe representa todo e qualquer tipo de atributo textual/literal, cujo valor é obrigatoriamente apresentado entre aspas duplas. Veja um exemplo abaixo:

// Type attributeName = "attributeValue";
String alphabet = "abcdefghijklmnopqrstuvwxyz";

Os métodos

Cada método será apresentado com nome, assinatura, descrição e exemplos. Para representar a assinatura usaremos a notação UML, cuja sintaxe é:

modifier methodName(parameterName1: parameterType1,...): returnType

Vamos lá?!

charAt

+ charAt(index: int): char

Este método retorna o valor (char) presente no índice informado. Exemplo(s):

char letter = alphabet.charAt(5);
System.out.println(letter); // imprime o valor 'f'

Nota 1: O primeiro caractere de uma String se encontra no índice 0.
Nota 2: Se o índice informado for um número negativo, ou superior à (quantidade de caracteres - 1) uma IndexOutOfBoundsException será reportada.

concat

+ concat(str: String): String

Concatena uma String (informada como parâmetro) ao final de uma String. Exemplo(s):

String vowels = "aeiou";
String invertedVowels = "uoiea";
String newVowels = vowels.concat(invertedVowels);

System.out.println(newVowels); // Imprime o valor "aeiouuoiea"
System.out.println("2".concat("2")); // Imprime o valor "22" 
System.out.println("".concat("Name").concat(" Lastname")); // Imprime o valor "Name Lastname"

contains

+ contains(s: CharSequence): boolean

Retorna true se e somente se esta string contiver a sequência especificada de caracteres, do contrário, retorna falso. Exemplo(s):

boolean result1 = vowels.contains("ei");
boolean result2 = vowels.contains("eo");
boolean result3 = vowels.contains("EI");

System.out.println(result1); // Imprime o valor true
System.out.println(result2); // Imprime o valor false
System.out.println(result3); // Imprime o valor false,
// pois "ei" é DIFERENTE de "EI"

// Compara o resultado false, por meio da NEGAÇÃO de um resultado true
if(!vowels.contains("iu")){
    System.out.println("Não contêm a sequência");
} else {
    System.out.println("Contêm a sequência");
}

endsWith

+ endsWith(suffix: String): boolean

Verifica se uma String termina com o sufixo (String) especificado. Exemplo(s):

System.out.println(alphabet.endsWith("vwxyz")); // Imprime o valor true
System.out.println(alphabet.endsWith("yz")); // Imprime o valor true
System.out.println(alphabet.endsWith("vwyz")); // Imprime o valor false
System.out.println(alphabet.endsWith("zya")); // Imprime o valor false
System.out.println(vowels.endsWith("aei")); // Imprime o valor false
System.out.println(vowels.endsWith("aeiou")); // Imprime o valor true
System.out.println(vowels.endsWith("u")); // Imprime o valor true
System.out.println("bcaeiou".endsWith(vowels)); // Imprime o valor true
System.out.println("aeioubcd".endsWith(vowels)); // Imprime o valor false

equals

+ equals(anObject: Object): boolean

Compara uma String com um Object (String) e verifica se são iguais. Se o parâmetro for null ou diferente da String, um valor false é retornado. Exemplo(s):

boolean c1 = vowels.equals("aeiou"); 
boolean c2 = vowels.equals("AeIou"); 
boolean c3 = vowels.equals("aeio"); 

System.out.println(c1); // Imprime o valor true
System.out.println(c2); // Imprime o valor false
System.out.println(c3); // Imprime o valor false

equalsIgnoreCase

+ equalsIgnoreCase(anotherString: String): boolean

Compara uma String com outra e verifica se são iguais, ignorando a diferença entre caracteres maiúsculos e minúsculos. Exemplo(s):

System.out.println(vowels.equalsIgnoreCase("aeiou")); // Imprime o valor true
System.out.println(vowels.equalsIgnoreCase("AEIOU"));  // Imprime o valor true
System.out.println(vowels.equalsIgnoreCase("aEiOu"));  // Imprime o valor true
System.out.println(vowels.equalsIgnoreCase(null));  // Imprime o valor false
System.out.println(vowels.equalsIgnoreCase("A Eiou"));  // Imprime o valor false
System.out.println(vowels.equalsIgnoreCase("AEioU "));  // Imprime o valor false
System.out.println(vowels.equalsIgnoreCase("AEióU"));  // Imprime o valor false

hashCode

+ hashCode(): int

Retorna um código hash (do tipo int) de uma String. Exemplo(s):

String password = "yourPassword";
int hashedPassword = password.hashCode();
System.out.println(hashedPassword); // Imprime o valor 714009582
System.out.println("".hashCode()); // Imprime o valor 0

Nota 1: Este método usa a expressão s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] para gerar o código hash, onde:
- s[i] é o i-ésimo caractere da String
- n é o comprimento da String e
- ^ indica exponenciação
Nota 2: Código hash de uma String vazia é 0.

indexOf

+ indexOf(ch: char): int

Retorna o índice da primeira ocorrência do caractere especificado dentro da String. Exemplo(s):

String text1 = "asdfa2dfa2df";
String text2 = "fdsafdsafdsa";

int res1 = text1.indexOf('d');
int res2 = text2.indexOf('f');
int res3 = text1.indexOf('2');
int res4 = text2.indexOf('m');

System.out.println(res1); // Imprime o valor 2
System.out.println(res2); // Imprime o valor 0
System.out.println(res3); // Imprime o valor 5
System.out.println(res4); // Imprime o valor -1 (nenhuma ocorrência)
+ indexOf(ch: char, fromIndex: int): int

Retorna o índice dentro dessa String da primeira ocorrência do caractere especificado, iniciando a pesquisa no índice fromIndex. Exemplo(s):

System.out.println(text1.indexOf('d', 0)); // Imprime o valor 2
System.out.println(text1.indexOf('d', 2)); // Imprime o valor 2
System.out.println(text1.indexOf('d', 3)); // Imprime o valor 6
System.out.println(text1.indexOf('d', 6)); // Imprime o valor 6
System.out.println(text1.indexOf('d', 11)); // Imprime o valor -1 
// (nenhuma ocorrência)
+ indexOf(str: String): int

Retorna o índice dentro desta String da primeira ocorrência da substring especificada.

System.out.println(text1.indexOf("dfa")); // Imprime o valor 2
System.out.println(text1.indexOf("dfad")); // Imprime o valor -1 
// (nenhuma ocorrência)
+ indexOf(str: String, fromIndex: int): int

Retorna o índice dentro desta String da primeira ocorrência da substring especificada, iniciando a pesquisa no índice fromIndex.

System.out.println(text1.indexOf("dfa", 1)); // Imprime o valor 2
System.out.println(text1.indexOf("dfa", 5)); // Imprime o valor 6
System.out.println(text1.indexOf("dfa", 9)); // Imprime o valor -1 
// (nenhuma ocorrência)

isEmpty

+ isEmpty(): boolean

Retorna true se o comprimento da String for 0, do contrário, retorna false. Exemplo(s):

String s1 = ""; // String com valor vazio (comprimento: 0)
String s2 = " "; // String com espaço em branco como valor (comprimento: 1)
String s3 = "abc";

System.out.println(s1.isEmpty()); // Imprime o valor true
System.out.println(s2.isEmpty()); // Imprime o valor false
System.out.println(s3.isEmpty()); // Imprime o valor false

lastIndexOf

+ lastIndexOf(ch: char): int

Retorna o índice dentro desta String da última ocorrência do caractere especificado. Exemplo(s):

int index = "hahahaha".lastIndexOf('h');
System.out.println(index); // Imprime o valor 6
System.out.println("hahahaha".lastIndexOf('g')); // Imprime o valor -1 
// (nenhuma ocorrência)
+ lastIndexOf(ch: char, fromIndex: int): int

Retorna o índice dentro dessa String da última ocorrência do caractere especificado, pesquisando para trás iniciando no índice especificado. Exemplo(s):

System.out.println("hahah".lastIndexOf('a', 3)); // Imprime o valor 3
System.out.println("hahah".lastIndexOf('a', 0)); // Imprime o valor -1
// (nenhuma ocorrência)

+ lastIndexOf(str: String): int

Retorna o índice dentro desta string da última ocorrência da substring especificada. Exemplo(s):

System.out.println("haha".lastIndexOf("ha")); // Imprime o valor 2
System.out.println("haha".lastIndexOf("h a")); // Imprime o valor -1 (nenhuma ocorrência)
+ lastIndexOf(str: String, int: fromIndex): int

Retorna o índice dentro dessa string da última ocorrência da substring especificada, pesquisando para trás iniciando no índice especificado. Exemplo(s):

System.out.println("haaah".lastIndexOf("aa", 2)); // Imprime o valor 2
System.out.println("haaah".lastIndexOf("aa", 0)); // Imprime o valor -1 (nenhuma ocorrência)

length

+ length(): int

Retorna o comprimento da String. Comprimento refere-se à quantidade de caracteres Unicode na String. Exemplos:

String str1 = "";
String str2 = " ";
String str3 = "Rio de Janeiro";
String str4 = "São Gonçalo";
String str5 = "âáàãa";
String str6 = "52º 30' 00\" N / 13º 25' 48\" E"; // Aspas duplas (dentro da String) sendo escapadas com o caractere '\'
String str7 = "\\"; // Barra invertida sendo escapada por '\\'
String str8 = "\\\\"; // 2 Barras invertidas sendo escapadas por '\\'	
    
System.out.println(str1.length()); // Imprime o valor 0
System.out.println(str2.length()); // Imprime o valor 1
System.out.println(str3.length()); // Imprime o valor 14
System.out.println(str4.length()); // Imprime o valor 11
System.out.println(str5.length()); // Imprime o valor 5
System.out.println(str6.length()); // Imprime o valor 29, o caractere '\' não é contado, pois é usado como símbolo de escape
System.out.println(str7.length()); // Imprime o valor 1
System.out.println(str8.length()); // Imprime o valor 2

matches

+ matches(regex: String): boolean

Informa se uma String corresponde ou não à expressão regular (regex) fornecida. Exemplos:

String regex = "ab(b*|c)a+"; // Contêm "ab", seguido por 0 ou mais "b", ou 1 "c" e depois 1 ou mais "a"
        
String t1 = "aabaa";
String t2 = "abbbba";
String t3 = "aba";
String t4 = "abca";
String t5 = "abbaa";
String t6 = "abb";
String t7 = "abcca";
        
System.out.println(t1.matches(regex)); // Imprime o valor false
System.out.println(t2.matches(regex)); // Imprime o valor true
System.out.println(t3.matches(regex)); // Imprime o valor true
System.out.println(t4.matches(regex)); // Imprime o valor true
System.out.println(t5.matches(regex)); // Imprime o valor true
System.out.println(t6.matches(regex)); // Imprime o valor false
System.out.println(t7.matches(regex)); // Imprime o valor false

Nota: Para conhecer mais sobre Regex, visite a documentação.

repeat

+ repeat(count: int): String

Retorna uma String cujo valor é a concatenação desta string repetidas vezes. Exemplo(s):

System.out.println(t1.repeat(1)); // Imprime o valor "aabaa"
System.out.println(t1.repeat(3)); // Imprime o valor "aabaaaabaaaabaa"
System.out.println(t1.repeat(0)); // Imprime o valor ""

Nota 1: Se o count informado for um número negativo uma IllegalArgumentException é reportada.
Nota 2: Método disponível no Java 11 ou superior.

replace

+ replace(oldChar: char, newChar: char): String

Retorna uma String resultante da substituição de todas as ocorrências de oldChar nesta String por newChar. Exemplo(s):

String t8 = t1.replace('a','A');
String t9 = t1.replace('b','$');
String t10 = t2.replace('a','2').replace('b','@');
String t11 = t2.replace('c','a');

System.out.println(t8); // Imprime o valor "AAbAA"
System.out.println(t9);  // Imprime o valor "aa$aa"
System.out.println(t10); // Imprime o valor "2@@@@2"
System.out.println(t11); // Imprime o valor "abbbba", 
// isto é, a própria String, já que oldChar informado 
// não existe na String.
+ replace(target: CharSequence, replacement: CharSequence): String

Substitui cada substring dessa string que corresponde à sequência de destino literal pela sequência de substituição literal especificada. A substituição prossegue desde o início da string até o final, por exemplo, substituir "aa" por "b" na string "aaa" resultará em "ba" em vez de "ab". Exemplo(s)

String t12 = t1.replace("aab","abababa");
String t13 = t2.replace("bb",""); // Substituir por vazio, é equivalente à remover todas as ocorrências "bb"
String t14 = t3.replace("abb","abab");
String t15 = t4.replace("ab","ba").replace("ba","BA"); // Substituição combinada. Veja que "ab" é substituído por "ba", que por sua vez também é substituído.
String t16 = t2.replace("bbb","aaa");
        
System.out.println(t12); // Imprime o valor "abababaaa"
System.out.println(t13); // Imprime o valor "aa"
System.out.println(t14); // Imprime o valor "aba", que é o valor da String t3, já que o parâmetro informado não existe.
System.out.println(t15); // Imprime o valor "BAca"
System.out.println(t16); // Imprime o valor "aaaaba"

replaceAll

+ replaceAll(regex: String, replacement: String): String

Substitui cada substring dessa String que corresponde à expressão regular fornecida.

String regex2 = "\\d+";  // Corresponde à sequências de dígitos
String regex3 = "(-|/)+"; // Corresponde à sequências dos operadores aritméticos '-' ou '/'
        
System.out.println("adrew452kjsl902a1@".replaceAll(regex2, "*")); // Imprime o valor "adrew*kjsl*a*@"
System.out.println("2+(-1*3)5///+".replaceAll(regex3, "#")); // Imprime o valor "2+(#1*3)5#+"

split

split(regex: String): String[]

Divide essa string em torno de correspondências da expressão regular fornecida, alocando as partes obtidas em um String[]. Exemplo(s):

String expression = "2-2/3*5+23.59-12-26/2";
String[] partString = expression.split(regex3);

System.out.println(partString[0]); // Imprime o valor "2"
System.out.println(partString[1]); // Imprime o valor "2"
System.out.println(partString[2]); // Imprime o valor "3*5+23.59"
System.out.println(partString[3]); // Imprime o valor "12"
System.out.println(partString[4]); // Imprime o valor "26"
System.out.println(partString[5]); // Imprime o valor "2"

Nota: Se a sintaxe da expressão regular (regex) for inválida uma PatternSyntaxException é reportada.

split(regex: String, limit: int): String[]

Divide essa string em torno de correspondências da expressão regular fornecida, alocando as partes obtidas em um String[], limitando o resultado do seguinte modo:

  • limit > 0 : Estabelece a quantidade de vezes que queremos dividir a String
  • limit < 0 : Estabelece que a regex será aplicada quantas vezes forem necessárias, conforme a regex aplicada.
  • limit = 0 : Estabelece que a regex será aplicada quantas vezes forem necessárias, conforme a regex aplicada, descartando strings vazias à direita.

Exemplo(s):

String test = "abc;;abc;abc;abc;abc;;";
		
String[] partes1 = test.split(";", 2);
for(int i = 0; i < partes1.length; i++){
    System.out.println(partes1[i]); // Imprime os valores: 
    // {"abc",";abc;abc;abc;abc;;"}
}        
        
String[] partes2 = test.split(";", 4);
for(int i = 0; i < partes2.length; i++){
    System.out.println(partes2[i]); // Imprime os valores: 
    // {"abc","","abc","abc;abc;abc;;"}
}
        
String[] partes3 = test.split(";", -1);
for(int i = 0; i < partes3.length; i++){
    System.out.println(partes3[i]); // Imprime os valores: 
    // {"abc","","abc","abc","abc","abc","",""}
}
        
String[] partes4 = test.split(";", 0);
for(int i = 0; i < partes4.length; i++){
    System.out.println(partes4[i]); // Imprime os valores: 
    // {"abc","","abc","abc","abc","abc"}
}
                
String[] partes5 = test.split(";b", 2);
for(int i = 0; i < partes5.length; i++){
    System.out.println(partes5[i]); // Imprime o valor 
    // da própria String test, já que a regex não se aplica à String. 
    // O valor ocupará o índice 0 do Array, isto é: 
    // {"abc;;abc;abc;abc;abc;;"}
}

startsWith

+ startsWith(prefix: String): boolean

Verifica se uma String inicia com o prefixo (String) especificado. Exemplo(s):

boolean r1 = test.startsWith("abc");
boolean r2 = test.startsWith("ab;");
        
System.out.println(r1); // Imprime o valor true
System.out.println(r2); // Imprime o valor false
+ startsWith(prefix: String, toffset: int): boolean

Verifica se uma String inicia com o prefixo (String) especificado, considerando a pesquisa a partir do índice informado. Exemplo(s):

System.out.println(test.startsWith("abc", 5)); // Imprime o valor true
System.out.println(test.startsWith("abc", 6)); // Imprime o valor false

substring

+ substring(beginIndex: int): String

Retorna uma string que é uma substring desta string. A substring começa com o caractere no índice especificado e se estende até o final dessa string. Exemplo(s):

String sub1 = "qwertyu".substring(4);
String sub2 = "zxcvbnm".substring(2);

System.out.println(sub1); // Imprime o valor "tyu"
System.out.println(sub2); // Imprime o valor "cvbnm"

Se o índice (beginIndex) for negativo ou maior que o comprimento da String uma IndexOutOfBoundsException será reportada.

+ substring(beginIndex: int, endIndex: int): String

Retorna uma string que é uma substring desta string. A substring começa com o caractere no índice (beginIndex) especificado e se estende até o endIndex - 1. Exemplo(s):

System.out.println("qwertyuiop".substring(2, 5)); // Imprime o valor "ert"
System.out.println("asdfghjklç".substring(3, 4)); // Imprime o valor "f"

Se o índice (beginIndex) for negativo ou, endIndex for maior que o comprimento da String, ou ainda se beginIndex for maior que endIndex uma IndexOutOfBoundsException será reportada.

toLowerCase

+ toLowerCase(): String

Converte (todos os) caracteres da String em formato minúsculo. Exemplo(s):

String city = "MancHESteR".toLowerCase();
System.out.println(city); // Imprime o valor "manchester"

toUpperCase

+ toUpperCase(): String

Converte (todos os) caracteres da String em formato maiúsculo. Exemplo(s):

System.out.println("MancHESteR".toUpperCase()); // Imprime o valor "MANCHESTER"

trim

+ trim(): String

Remove os espaços em branco do início e fim de uma String.

String city2 = " New York ";
String city3 = "  ";

System.out.println(city2.trim()); // Importa o valor "New York";
System.out.println(city3.trim()); // Importa o valor (vazio) "";

Se você gostou e quer se aprofundar mais nesta classe, lhe indico que veja todos os métodos na documentação.

E assim finalizamos este post! Se gostaram, por favor, deixem seus COMENTÁRIOS, nos SIGAM e principalmente COMPARTILHEM para que assim, seja possível alcançar mais pessoas, que como vocês, curtem Programação, com conteúdos PRÁTICOS e GRATUITOS!

Para ver e/ou baixar o código-fonte deste post, ou mesmo melhorá-lo, visitem o repositório no GitHub.

Até a próxima!

Cite este material

FERNANDES, Fábio. Conhecendo a classe String: métodos. aprendaCodar, 16 de junho de 2022. Disponível em: <https://aprendacodar.blogspot.com/2022/06/programacao-java-conheca-os-principais.html>. Acesso em:

Tags:
Fábio Fernandes

Graduado em Ciência da Computação e Especialista em Análise de Dados com BI e Big Data. Instrutor, Desenvolvedor e Produtor de Conteúdo. Apaixonado por Tecnologia e pelo compartilhamento de conhecimentos.

2 Comentários

  1. Alexsandro21/12/22 23:02

    Legal o material, tirou algumas dúvidas que tinha, gostei.

    ResponderExcluir
    Respostas
    1. Fábio Fernandes22/12/22 08:49

      Que legal, Alexsandro! Continue acompanhando nossos posts. Um abraço!

      Excluir
Postar um comentário
Postagem Anterior Próxima Postagem