Método Java String.split()

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!

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:

1. O método retorna um array de strings.
2. O método tem um parâmetro de entrada de string chamado regex .

Vamos analisar cada um deles separadamente conforme detalhamos a descrição dada acima.

1. 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.

2. 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.

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: 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: Vejamos mais alguns exemplos de como funcionaria o método split : 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.

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: 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.

Nessas situações, o programador costuma conhecer as "regras do jogo". Digamos que um programador saiba que está lidando com informações do usuário armazenadas de acordo com este padrão: Vamos pegar alguns valores específicos como exemplo: 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: Ou podemos até adotar alguns valores específicos: 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.

Também tentamos modelar algumas situações da vida real onde usamos o método split para resolver problemas hipotéticos, mas bastante realistas.