Neste artigo, vamos ajudá-lo a entender substrings em Java. Não apenas daremos uma explicação teórica, mas também exemplos de códigos reais para ajudá-lo a visualizar. Vamos ensiná-lo a criar substrings e ajudá-lo a encontrar substrings dentro de uma string.
Mas antes de aprendê-los, temos que ter o básico sobre substrings.
últimas postagens
O que são strings e substrings?
No contexto de Java, uma string representa uma sequência de caracteres. Cada string em Java é um objeto. Uma string em Java pode conter caracteres, símbolos e até espaços em branco. Por outro lado, uma substring em Java é uma parte ou um subconjunto de uma string Java.
Por exemplo, “Geek” é uma substring de “etechpt.com”. Substrings ajudam você a obter uma parte específica de uma string.
Se você tem o nome “John Doe” e deseja apenas o primeiro nome “John”, pode obtê-lo facilmente com substrings. Além disso, considerando que você tem uma lista de nomes “John, Jack, Jolly” e deseja descobrir se “John” está nela, você também pode fazer isso com substrings. Estes são apenas meros exemplos. Podemos usar substrings em várias operações depois de entendê-las.
Como já sabemos o conceito de substrings em Java, agora vamos saber como criar e trabalhar com substrings em Java.
#1. Usando o método ‘substring()’
O método ‘substring()’ nos permite criar substrings com muita facilidade. Leva até dois parâmetros como entrada – startIndex ou ambos startIndex e endIndex e nos retorna a substring que queremos.
Dependendo do número de parâmetros, podemos utilizá-lo de duas formas. Agora, vamos aprender sobre eles em detalhes.
substring(int startIndex)
Para começar, podemos usar o método no formulário ‘substring(startIndex)’. Aqui, este método usa um valor inteiro como entrada, onde a entrada é a posição inicial da substring. Ele retorna uma string a partir do índice inicial fornecido até o final da string original.
Como exemplo, vejamos o seguinte código:
public class Substrings{
public static void main(String args[]){
String str="etechpt.com";
System.out.println("Given String: " + str);
System.out.println("Substring: " +str.substring(4)); //index of strings start from 0
}
}
SAÍDA:
Given String: etechpt.com Substring: Flare
Na saída, vemos que a string de entrada é “etechpt.com” e o valor de retorno é a substring “Flare”. Faz uma substring a partir do índice dado (4), ou seja, da posição 5 até o final da string.
substring(int startIndex, int endIndex)
Essa é outra maneira de usar o método substring da classe String. Podemos passar dois inteiros para o método substring. Um índice inicial e um índice final. Para usar isso, temos que usar o método no formato ‘substring(startIndex,endIndex)’.
Para entendê-lo melhor, vejamos alguns códigos de exemplo:
public class Substrings{
public static void main(String args[]){
String str="GeekFlareFans";
System.out.println("Given String: " + str);
System.out.println("Substring: " +str.substring(4,9)); //You get a substring starting from index no. 4 to index 8.
}
}
SAÍDA:
Given String: GeekFlareFans Substring: Flare
Como podemos ver, dada a string “GeekFlareFans”, ele gera a substring “Flare”. Demos o índice inicial de 4 e o índice final de 9. Começa do elemento com um índice de 4 e termina antes de 9. Temos que observar que ele não imprime o elemento com o índice final. Isso nos dá uma substring que inclui todos os elementos até o índice final, mas exclui o elemento com o índice final.
#2. Usando o método ‘split()’
O ‘split()’ é outro método da classe String em Java que nos ajuda a criar uma substring. É útil quando várias informações são armazenadas dentro de uma string com um caractere separador comum.
A sintaxe menciona o termo “regex” que pode parecer um pouco intimidante para você, então vamos entender o que é regex antes de prosseguir. Regex é a abreviação de “Expressões Regulares”. Um regex é uma sequência de caracteres que descreve um padrão dentro de uma string ou texto. No contexto do método split, o regex é o nosso separador.
O método ‘split()’ pode receber até duas variáveis como entrada, elas são uma string regex e um número inteiro limite. O regex é o separador que, quando encontrado, resulta na divisão da string original em 2 partes – a parte antes do regex e a parte após o regex.
Por exemplo, suponha que você esteja tentando dividir a string “abcdef” com “bcd” como regex. Teríamos as substrings “a” e “ef” como resultado.
O método retorna um array com as strings separadas. Podemos especificar apenas o regex ou o regex e o limite. Vamos conhecer as várias maneiras de chamar esse método uma a uma.
split(String regex)
O primeiro método recebe apenas a string regex no formato ‘split(regex)’. Não possui variável limite; portanto, retorna todas as substrings separadas em uma matriz.
Vamos obter um entendimento claro com algum código:
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare";
String[] substrings=str.split("%");
System.out.println("Given String: " + str);
System.out.println("First Substring: " + substrings[0]);
System.out.println("Second Substring: " + substrings[1]);
}
}
SAÍDA:
Given String: Geek%Flare First Substring: Geek Second Substring: Flare
Como observamos no código, a string fornecida tem uma regex separadora “%”. Não precisa ser um único caractere, pode ser qualquer string com qualquer número de caracteres. O método ‘split()’ ignora este regex e nos dá todas as strings que foram separadas por este regex. As substrings são armazenadas dentro de um array.
No código, a string fornecida é “Geek%Flare”. Assim, obtemos uma matriz com dois elementos, que são “Geek” e “Flare”. Posteriormente, acessamos com seus respectivos índices, que são 0,1 respectivamente, e imprimimos “Geek” e “Flare” no console.
Aqui também devemos observar que, se nenhum parâmetro for passado para o método, ele simplesmente lançará um erro. Mas se dermos uma string vazia (“”) como um regex, obteremos cada caractere individual como uma substring. Vejamos o exemplo para visualizar.
import java.util.Arrays;
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare";
String[] substrings=str.split("");
System.out.println(Arrays.toString(substrings));
}
}
SAÍDA:
[G, e, e, k, %, F, l, a, r, e]
A partir do exemplo, é aparente que o parâmetro regex é uma string vazia, ele retorna todos os caracteres como substrings separadas, e podemos ver isso claramente imprimindo a matriz de saída do método ‘split()’.
split(String regex, limite int)
Com a segunda variante deste método, temos mais controle sobre a saída e podemos ajustar ainda mais a saída do método ‘split()’. Aqui, o método ‘split()’ recebe duas variáveis como entrada. Neste caso, juntamente com o regex, também fornecemos um parâmetro de limite no formato especificado de ‘split(regex, limit)’.
O ‘limite’ é o número de strings resultantes que são produzidas. Dependendo do valor do limite, pode haver três possibilidades:
Caso 1: Se limite>0, a matriz resultante conteria a saída, mas aplicaria no máximo as vezes divididas (limite-1). Aqui, a matriz resultante não conteria mais elementos do que o limite especificado e toda a string restante que não fosse dividida seria armazenada como estava. Vamos facilitar o entendimento com algum código.
import java.util.Arrays;
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare%is%the%best";
String[] substrings=str.split("%",2);
System.out.println(Arrays.toString(substrings));
}
}
SAÍDA:
[Geek, Flare%is%the%best]
Veja na saída como existem apenas dois elementos na matriz de resultados, que é o número fornecido no parâmetro limite. Além disso, observe que a divisão é aplicada apenas uma vez, portanto (limite-1) vezes.
No entanto, se o regex estiver lá duas vezes seguidas (“%%”), ele terá substrings vazias. Veja este trecho de código para entender melhor.
import java.util.Arrays;
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare%is%%the%best%%%";
String[] substrings=str.split("%",5);
System.out.println(Arrays.toString(substrings));
}
}
SAÍDA:
[Geek, Flare, is, , the%best%%%]
Basicamente, se “%” for seguido por outro “%” ou o final da string, ela se transforma em uma substring vazia.
Caso 2: Se limit<0, a ação de divisão seria aplicada quantas vezes fosse possível sem limite para o tamanho do array, mas o array conteria substrings vazias se o regex estivesse lá duas vezes seguidas (“%%”).
import java.util.Arrays;
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare%is%%the%best%%%";
String[] substrings=str.split("%",-1);
System.out.println(Arrays.toString(substrings));
}
}
SAÍDA:
[Geek, Flare, is, , the, best, , , ]
A partir da saída, é aparente que a divisão é aplicada tantas vezes quanto possível e também existem substrings vazias presentes.
Caso 3: Se limit=0, a ação split também seria aplicada tantas vezes quanto possível, mas aqui todas as substrings vazias no final da string seriam descartadas do array.
import java.util.Arrays;
public class Substrings{
public static void main(String args[]){
String str="Geek%Flare%is%%the%best%%%";
String[] substrings=str.split("%",0);
System.out.println(Arrays.toString(substrings));
}
}
SAÍDA:
[Geek, Flare, is, , the, best]
Podemos ver que a saída é bastante semelhante entre quando limite=-1 e quando limite=0, mas não há substrings vazias à direita. Em outras palavras, as substrings vazias no final da matriz de substrings são ignoradas.
Observe também que, se o regex não estiver presente na string, ele retornará toda a string original como resultado.
Descubra se uma string contém uma substring
Além de criar substrings a partir de strings existentes, também podemos especificar uma substring e descobrir se essa substring existe dentro de uma string. Essa é uma maneira rápida e fácil de consultar uma substring e é útil em muitos casos de uso. Mas como fazemos isso? Vários métodos podem nos ajudar a conseguir isso. Vamos passar por eles um por um.
Usando o método ‘contains ()’:
Podemos encontrar facilmente a existência de uma substring com o método ‘contains()’. Este método da Classe String recebe como entrada uma string, que é a nossa substring, e retorna um valor booleano verificando se a substring está dentro da string ou não. Esse método pode ser usado dentro de blocos if-else, operadores unários e vários outros locais para implementar lógica complexa.
Vamos conhecer um pouco mais sobre esse método.
public class Substrings{
public static void main(String args[]){
String str="etechpt.com";
System.out.println("Does it contain Flare? n"+ str.contains("Flare"));
}
}
SAÍDA:
Does it contain Flare? true
O código verifica a string “etechpt.com” em busca da palavra “Flare” e, ao encontrá-la com sucesso, retorna um booleano “true”, confirmando assim a existência da substring.
public class Substrings{
public static void main(String args[]){
String str="etechpt.com";
System.out.println("Does it contain Flare? n"+ str.contains("Flare1"));
}
}
SAÍDA:
Does it contain Flare? false
Pelo exemplo, entendemos que se a substring não estiver dentro da string, o método retornará false para indicar sua inexistência. Assim, podemos ter certeza se a substring existe.
Encontrando a posição de uma substring
#1. Usando ‘indexOf ()’:
O método ‘indexOf()’ pode ser usado para encontrar a existência de uma substring e também encontrar seu índice. O método recebe como entrada uma string ou um caractere e nos dá a posição de sua primeira ocorrência. Mas ele só pode nos dar o índice da primeira ocorrência e não pode confirmar se existem outras ocorrências desta. Outra coisa a observar aqui, se a substring não existir, o método retornará -1.
Então, vamos explorar um pouco mais esse método.
public class Substrings{
public static void main(String args[]){
String str="GeekFlareGeekFlare";
System.out.println("Index of Flare: "+ str.indexOf("Flare"));
}
}
SAÍDA:
Index of Flare: 4
Aqui no exemplo, a primeira ocorrência da substring “Flare” começa no índice 4 na string “GeekFlareGeekFlare”. Então, como esperado, a função retornou o índice.
#2. Usando ‘lastIndexOf ()’:
‘lastIndexOf()’ é muito semelhante a ‘indexOf()’. Ambos os métodos recebem como entrada a substring e retornam o índice de sua posição. Ele ainda tem o mesmo valor de retorno quando não consegue encontrar a substring na string especificada. Ambos os métodos retornam -1 para uma localização malsucedida.
Mas enquanto ‘indexOf()’ retorna o índice da primeira ocorrência da substring, ‘lastIndexOf()’ retorna a última ocorrência.
Vamos vê-lo em ação através do código:
public class Substrings{
public static void main(String args[]){
String str="GeekFlareGeekFlare";
System.out.println("Last index of Flare: "+ str.lastIndexOf("Flare"));
}
}
SAÍDA:
Last index of Flare:13
Observando esta saída, entendemos que o método ‘lastIndexOf()’ se comporta conforme o esperado e obtemos o índice da última ocorrência da substring “Flare” na string “GeekFlareGeekFlare”.
perguntas frequentes
Como usar o método ‘split ()’ para criar substrings não vazias?
Se houver várias instâncias regex da string regex na string principal, uma após a outra(“Hello%%Hi”, onde regex é “%”), o método ‘split()’ considera a primeira instância como um caractere de quebra e o restante fornece a saída de uma string vazia. Para atenuar isso, podemos especificar o parâmetro de limite como 0. Portanto, ele fornecerá apenas strings não vazias como saída.
‘indexOf ()’ retorna índices de todas as instâncias de uma substring?
Não, ‘indexOf()’ não retorna índices de todas as instâncias de uma substring. Com ‘indexOf()’, obtemos um valor inteiro de retorno contendo o índice da primeira ocorrência da substring. Mas se não conseguir encontrar a substring, o método retornará -1.
O que o método ‘substring ()’ retorna se os índices fornecidos não existirem na string?
Se o índice inicial e o índice final fornecidos não existirem na string, o compilador lançará um erro. O erro deve ter “java.lang.StringIndexOutOfBoundsException: ” e simplesmente não será executado.
Conclusão
Neste artigo, discutimos vários métodos e fundamentos para começar com substrings. Discutimos a criação de uma substring e a verificação da existência de uma substring dentro de uma string. Isso lhe dará uma melhor compreensão de como trabalhar com substrings. Siga os exemplos e pratique mais para obter uma compreensão completa das substrings.
Em seguida, você pode verificar nossa lista de perguntas de entrevista sobre Java.