Vamos falar sobre o método String.split do Java : o que ele faz e por que é necessário. Não é difícil adivinhar que ele divide uma string Java, mas como isso funciona na prática? Vamos nos aprofundar no funcionamento do método e discutir alguns detalhes não óbvios. Ao mesmo tempo, aprenderemos quantos métodos de divisão a String realmente possui. Vamos!
Observe as diferenças entre as duas últimas linhas na tabela acima. Na penúltima linha, uma vírgula é usada como delimitador. Como resultado, quando a string é dividida, algumas das palavras têm espaços à esquerda. Na última linha, usamos uma vírgula e um espaço como nosso delimitador. É por isso que não havia substrings com espaços à esquerda no array resultante. Este é apenas um detalhe sutil que demonstra como é importante escolher cuidadosamente o delimitador certo.
Descrição e assinatura para String.split do Java
Em Java, o método split divide uma string em substrings usando um delimitador definido usando uma expressão regular. Vamos apresentar a assinatura do método e começar nosso mergulho:String[] split(String regex)
Duas coisas ficam claras na assinatura:
- O método retorna um array de strings.
- O método tem um parâmetro de entrada de string chamado regex .
-
O método retorna um array de strings.
A declaração contém as seguintes palavras: "Em Java, o método split divide uma string em substrings." O método coleta essas substrings em uma matriz que se torna o valor de retorno.
-
O método tem um parâmetro de entrada de string chamado regex .
Novamente, lembre-se da descrição: "divide uma string em substrings usando um delimitador definido usando uma expressão regular". O parâmetro de entrada regex é uma expressão regular aplicada à string original. Quando o caractere ou combinação de caracteres corresponde, eles são tratados como um delimitador.
![O método String.split() em Java: dividindo uma string em partes - 1](https://cdn.codegym.cc/images/article/f9de86dc-447e-46ec-b3b8-322a684c3330/800.jpeg)
Divisão de Java na prática
Agora vamos chegar mais perto do ponto. Vamos imaginar que temos uma sequência de palavras. Por exemplo, assim:
eu amo java
Precisamos dividir a string em palavras. Vemos que as palavras nesta string são separadas umas das outras por espaços. Nesse caso, um caractere de espaço é o candidato perfeito para nosso delimitador. O código para resolver nossa tarefa ficaria assim:
public class Main {
public static void main(String[] args) {
String str = "I love Java";
String[] words = str.split(" ");
for (String word : words) {
System.out.println(word);
}
}
}
A saída do método main será as seguintes linhas:
eu amo java
Vejamos mais alguns exemplos de como funcionaria o método split :
Corda | Delimitador | Resultado do método |
"Eu amo Java" | " " (caractere de espaço) | { "Eu" , "amo" , "Java" } |
"192.168.0.1:8080" | ":" | { "192.168.0.1" , "8080" } |
"Vermelho, laranja, amarelo" | "," | { "Vermelho" , "laranja" , "amarelo" } |
"Vermelho, laranja, amarelo" | ", " | { "Vermelho" , "laranja" , "amarelo" } |
Delimitador inicial
Esta é outra nuance importante. Se a string original começar com o delimitador, o primeiro elemento da matriz resultante será uma string vazia. Por exemplo, ficaria assim: String original: " I love Java" Delimiter: " " Array resultante: { "", "I", "love", "Java" } Mas se a string original terminar com um delimitador em vez do que começar com um, o resultado será diferente: String original: "I love Java " Delimiter: " " Array resultante: { "I", "love", "Java"public class Main {
public static void main(String[] args) {
print("I love Java".split(" "));
print(" I love Java".split(" "));
print("I love Java ".split(" "));
print(" I love Java ".split(" "));
}
static void print(String[] arr) {
System.out.println(Arrays.toString(arr));
}
}
A saída do método principal será assim:
[eu, amo, Java] [, eu, amo, Java] [eu, amo, Java] [, eu, amo, Java]
Novamente, volte sua atenção para o fato de que, quando o primeiro caractere na string original é um caractere delimitador, o resultado é que o primeiro elemento no array será uma string vazia.
irmão sobrecarregado
A classe String tem outro método split com a seguinte assinatura:String[] split(String regex, int limit)
Este método possui um parâmetro de limite adicional : ele determina quantas vezes o padrão regex será aplicado à string original. Veja as explicações abaixo:
limite > 0
O padrão é aplicado no limite -1 vezes. Além do mais, o comprimento da matriz retornada não excederá o valor do parâmetro limite . O último elemento do array será a parte da string que segue o último lugar onde o delimitador foi encontrado. Exemplo:public class Main {
public static void main(String[] args) {
print("I love Java".split(" ", 1));
print("I love Java".split(" ", 2));
/*
Output:
[I love Java]
[I, love Java]
*/
}
static void print(String[] arr) {
System.out.println(Arrays.toString(arr));
}
}
limite < 0
A expressão regular do delimitador é aplicada à string quantas vezes for possível. A matriz resultante pode ter qualquer comprimento. Exemplo:public class Main {
public static void main(String[] args) {
// Note the space at the end of the string
print("I love Java ".split(" ", -1));
print("I love Java ".split(" ", -2));
print("I love Java ".split(" ", -12));
/*
Output:
[I, love, Java, ]
[I, love, Java, ]
[I, love, Java, ]
Please note that the last element of the array is
an empty string. This is caused by the whitespace
at the end of the original string.
*/
}
static void print(String[] arr) {
System.out.println(Arrays.toString(arr));
}
}
limite = 0
Assim como no caso em que limite < 0, o padrão do delimitador é aplicado à string quantas vezes for possível. A matriz final pode ter qualquer comprimento. Se os últimos elementos forem strings vazias, eles serão descartados do array final. Exemplo:public class Main {
public static void main(String[] args) {
// Note the space at the end of the string
print("I love Java ".split(" ", 0));
print("I love Java ".split(" ", 0));
print("I love Java ".split(" ", 0));
/*
Output:
[I, love, Java]
[I, love, Java]
[I, love, Java]
Note the absence of empty strings at the end of the arrays
*/
}
static void print(String[] arr) {
System.out.println(Arrays.toString(arr));
}
}
Se observarmos a implementação da versão de um parâmetro do método split , veremos que é como seu irmão sobrecarregado, mas com o segundo argumento definido como zero:
public String[] split(String regex) {
return split(regex, 0);
}
Vários exemplos
Na prática do mundo real, às vezes acontece que temos strings geradas de acordo com certas regras. Essa string pode entrar em nosso programa de qualquer lugar:- de um serviço de terceiros;
- de uma solicitação enviada ao nosso servidor;
- de um arquivo de configuração;
- e assim por diante.
user_id|user_login|user_email
Vamos pegar alguns valores específicos como exemplo:
135|bender|bender@gmail.com
Suponha que a tarefa do programador seja escrever um método que envie um e-mail ao usuário. O programador tem acesso aos dados do usuário, que são registrados no formato fornecido acima. A subtarefa que continuaremos analisando agora é como isolar o endereço de e-mail do restante dos dados do usuário. Essa é uma instância em que o método split pode ser útil. Afinal, se olharmos para o modelo de dados do usuário, percebemos que extrair o endereço de e-mail do usuário do resto é tão simples quanto chamar o método split para dividir a string. Em seguida, o endereço de e-mail estará no último elemento da matriz resultante. Aqui está um exemplo de um método que pega uma string contendo dados do usuário e retorna o endereço de e-mail do usuário. Para simplificar, digamos que a string de dados esteja sempre no formato que queremos:
public class Main {
public static void main(String[] args) {
String userInfo = "135|bender|bender@gmail.com";
System.out.println(getUserEmail(userInfo));
// Output: bender@gmail.com
}
static String getUserEmail(String userInfo) {
String[] data = userInfo.split("\\|");
return data[2]; // or data[data.length - 1]
}
}
Observe o delimitador: "\\|" . Em expressões regulares, "|" é um caractere especial com um significado especial, portanto, se quisermos usá-lo como um caractere comum (ou seja, o que queremos encontrar na string original), precisamos escapar do caractere com duas barras invertidas. Considere outro exemplo. Digamos que temos informações de pedidos estruturadas assim:
item_number_1,item_name_1,item_price_1;item_number_2,item_name_2,item_price_2;...;item_number_n,item_name_n,item_price_n
Ou podemos até adotar alguns valores específicos:
1,pepinos,2,39;2,tomates,1,89;3,bacon,4,99
Nossa tarefa é calcular o custo total do pedido. Aqui teremos que aplicar o método split várias vezes. O primeiro passo é dividir a string usando ";" como o delimitador para quebrá-lo em suas partes componentes. Em seguida, cada substring resultante conterá informações sobre um produto separado, que podemos processar posteriormente. A seguir, para cada produto, iremos separar as informações correspondentes usando o símbolo ",". Pegaremos um elemento com um índice específico (aquele em que o preço do produto é armazenado) da matriz de strings resultante, o converteremos para a forma numérica e calcularemos o custo total do pedido. Vamos escrever um método que fará todos esses cálculos:
public class Main {
public static void main(String[] args) {
String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
System.out.println(getTotalOrderAmount(orderInfo));
// Output: 9.27
}
static double getTotalOrderAmount(String orderInfo) {
double totalAmount = 0d;
final String[] items = orderInfo.split(";");
for (String item : items) {
final String[] itemInfo = item.split(",");
totalAmount += Double.parseDouble(itemInfo[2]);
}
return totalAmount;
}
}
Veja se você consegue descobrir como esse método funciona por conta própria. Com base nesses exemplos, podemos dizer que o método split é utilizado quando temos algum dado formatado como string, e precisamos extrair dele algumas informações mais específicas.
Resumo
Examinamos o método split da classe String . É exatamente o que você precisa quando precisa dividir uma string em suas partes componentes com a ajuda de um delimitador especial. O método retorna uma matriz de strings (as substrings que compõem a string original). Ele aceita uma expressão regular cujas correspondências representam o(s) caractere(s) delimitador(es). Examinamos várias sutilezas desse método:- um delimitador inicial;
- seu irmão sobrecarregado com dois parâmetros.