Método Split em Java: divida uma string em partes

Vamos falar sobre o método String split : o que ele faz e por que é necessário. É fácil adivinhar que isso divide a corda, mas como isso funciona na prática? Vamos dar uma olhada mais de perto em como o método funciona e discutir alguns detalhes não óbvios e, ao mesmo tempo, descobrir quantos métodos de divisão realmente existem na classe String . Vamos!

Definição e assinatura para Java String.split

O método split em Java divide uma string em substrings usando um delimitador especificado por meio de uma expressão regular. Vamos dar 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 usa uma string regex como parâmetro.

Vejamos cada coisa separadamente em termos da definição dada acima.

1. O método retorna um array de strings.

   A definição contém as seguintes palavras: “O método split em Java divide uma string em substrings”. Essas substrings são coletadas pelo método em um array e representam seu valor de retorno.

2. O método usa uma string regex como parâmetro.

   Novamente, lembre-se da definição: “divide uma string em substrings usando um delimitador especificado por meio de uma expressão regular”. O parâmetro regex aceito é um padrão de expressão regular aplicado à sequência de origem e corresponde ao caractere delimitador (ou combinação de caracteres) na sequência de origem.

Dividir na prática

Agora vamos ao que interessa. Vamos imaginar que temos uma string com palavras. Por exemplo, assim: Precisamos quebrar a string em palavras. Vemos que nesta linha as palavras estão separadas umas das outras por espaços. O espaço é um candidato ideal para a função de separador neste caso. Esta é a aparência do código para resolver este problema:

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 principal serão as seguintes linhas: Vejamos mais alguns exemplos de como o método split funcionaria : Observe as diferenças entre as duas últimas linhas da tabela acima. Na penúltima linha, o delimitador é uma vírgula, portanto a linha é dividida de forma que algumas palavras tenham espaços iniciais. Na última linha, usamos uma vírgula e um caractere de espaço como delimitador. Portanto, a matriz resultante não continha nenhuma linha com espaços à esquerda. Este é apenas um pequeno detalhe que demonstra como é importante selecionar cuidadosamente o separador correto.

Delimitador inicial

Há mais uma nuance importante. Se a string de origem começar com um delimitador, o primeiro elemento da matriz resultante será a string vazia. Em um exemplo, ficaria assim: String de origem: "I love Java" Delimitador: " " Matriz resultante: { "" , "I" , "love" , "Java" } Mas se a string de origem terminar com um delimitador e não começa, o resultado será diferente: String de origem: "I love Java" Separador: " " Array resultante: { "I" , "love" , "Java" } Observamos no código as variações do método split com um caractere separador no final e/ou início da string de origem:

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: Observe novamente que quando o primeiro caractere na string de origem é um caractere delimitador, a matriz resultante terá a string vazia como seu primeiro elemento.

Companheiro sobrecarregado

A classe String possui outro método split com esta assinatura:

String[] split(String regex, int limit)

Este método possui um parâmetro de limite adicional : ele determina o número de vezes que o padrão regex será aplicado à string de origem. Abaixo estão as explicações:

limite > 0

limite -1 vezes é aplicado . Neste caso, o comprimento da matriz não excederá o valor limite . O último elemento do array será a parte da string após o último delimitador 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

O padrão de pesquisa do delimitador é aplicado à string tantas vezes quanto possível. O comprimento da matriz resultante pode ser qualquer. Exemplo:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        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, ]

        Note that the last element of the array is
        an empty string, resulting from the space
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limite 0

Tal como acontece com limit < 0, o padrão delimitador é aplicado à string tantas vezes quanto possível. A matriz resultante pode ter qualquer comprimento. Se os últimos elementos forem iguais à string vazia, eles serão descartados no array final. Exemplo:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        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 do método split com um argumento, veremos que esse método chama seu irmão sobrecarregado com um segundo argumento zero:

public String[] split(String regex) {
    return split(regex, 0);
}

Vários exemplos

Na prática de trabalho, às vezes acontece que temos uma linha compilada de acordo com certas regras. Esta linha pode “entrar” em nosso programa de qualquer lugar:

• de um serviço de terceiros;
• de uma solicitação ao nosso servidor;
• do arquivo de configuração;
• etc.

Normalmente, em tal situação, o programador conhece as “regras do jogo”. Digamos que o programador saiba que possui informações sobre o usuário, que são armazenadas de acordo com este padrão: Por exemplo, vamos pegar valores específicos: E agora o programador se depara com a tarefa: escrever um método que envie um email ao usuário. À sua disposição estão informações sobre o usuário, registradas no formato acima. Pois bem, a subtarefa que continuaremos analisando é isolar o endereço de e-mail das informações gerais sobre o usuário. Este é um exemplo em que o método split pode ser útil. Afinal, se olharmos o template, entendemos que para extrair o endereço de e-mail do usuário de todas as informações, basta dividir a linha pelo método split . Então o endereço de e-mail estará no último elemento da matriz resultante. Vamos dar um exemplo desse método, que pega uma string contendo informações sobre o usuário e retorna o e-mail do usuário. Para simplificar, vamos supor que essa string sempre corresponda ao formato que precisamos:

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 separador: "\\|" . Já que em expressões regulares “|” - este é um caractere especial ao qual uma certa lógica está vinculada; para usá-lo como um caractere normal (aquele que queremos encontrar na string de origem), precisamos escapar desse caractere usando duas barras invertidas. Vejamos outro exemplo. Digamos que temos informações sobre um pedido escrito aproximadamente neste formato: Ou vamos pegar valores específicos: Estamos diante da tarefa de calcular o custo total do pedido. Aqui teremos que usar o método split várias vezes. O primeiro passo é dividir a string através do símbolo “;” em suas partes componentes. Então, em cada parte teremos informações sobre um produto individual, que poderemos processar no futuro. E então, dentro de cada produto, vamos separar as informações usando o símbolo "," e pegar do array resultante um elemento com um determinado índice (no qual o preço está armazenado), convertê-lo para uma forma numérica e compilar o custo final da ordem. Vamos escrever um método que irá calcular tudo isso:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1, cucumbers, 20.05; 2, tomatoes, 123.45; 3, hares, 0.50";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 144.0
    }

    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;
    }
}

Tente descobrir por si mesmo como esse método funciona. Com base nesses exemplos, podemos dizer que o método split é utilizado quando temos alguma informação em forma de string, da qual precisamos extrair algumas informações mais específicas.

Resultados

Vimos o método split da classe String . É necessário dividir uma string em suas partes componentes usando um delimitador especial. O método retorna uma matriz de strings (os componentes de uma string). Aceita uma expressão regular que encontra os caracteres delimitadores. Vimos as várias sutilezas deste método:

• caractere delimitador inicial;
• irmão sobrecarregado com dois argumentos.

Também tentamos simular algumas situações da “vida real” em que utilizamos o método split para resolver problemas ainda que fictícios, mas bastante realistas.