Método Java String.split()

Hablemos del método String.split de Java : qué hace y por qué es necesario. No es difícil adivinar que divide una cadena de Java, pero ¿cómo funciona esto en la práctica? Profundicemos en el funcionamiento del método y discutamos algunos detalles no obvios. Al mismo tiempo, aprenderemos cuántos métodos de división tiene realmente String . ¡Vamos!

Descripción y firma para String.split de Java

En Java, el método split divide una cadena en subcadenas utilizando un delimitador definido mediante una expresión regular. Presentemos la firma del método y comencemos nuestra inmersión:

String[] split(String regex)

De la firma quedan claras dos cosas:

1. El método devuelve una matriz de cadenas.
2. El método tiene un parámetro de entrada de cadena llamado regex .

Analicemos cada uno de estos por separado a medida que desglosamos la descripción dada anteriormente.

1. El método devuelve una matriz de cadenas.

   La declaración contiene las siguientes palabras: "En Java, el método split divide una cadena en subcadenas". El método recopila estas subcadenas en una matriz que se convierte en el valor de retorno.

2. El método tiene un parámetro de entrada de cadena llamado regex .

   Nuevamente, recuerda la descripción: "divide una cadena en subcadenas usando un delimitador definido usando una expresión regular". El parámetro de entrada regex es una expresión regular que se aplica a la cadena original. Cuando el carácter o la combinación de caracteres coinciden, se tratan como un delimitador.

La división de Java en la práctica

Ahora acerquémonos al punto. Imaginemos que tenemos una cadena de palabras. Por ejemplo, así: Necesitamos dividir la cadena en palabras. Vemos que las palabras de esta cadena están separadas entre sí por espacios. En este caso, un carácter de espacio es el candidato perfecto para nuestro delimitador. El código para resolver nuestra tarea se vería así:

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

La salida del método principal serán las siguientes líneas: Veamos algunos ejemplos más de cómo funcionaría el método de división : Observe las diferencias entre las dos últimas filas de la tabla anterior. En la penúltima fila, se usa una coma como delimitador. Como resultado, cuando se divide la cadena, algunas de las palabras tienen espacios iniciales. En la última fila, usamos una coma y un espacio como delimitador. Es por eso que no hubo subcadenas con espacios iniciales en la matriz resultante. Este es solo un detalle sutil que demuestra lo importante que es elegir cuidadosamente el delimitador correcto.

delimitador principal

Este es otro matiz importante. Si la cadena original comienza con el delimitador, el primer elemento de la matriz resultante será una cadena vacía. Por ejemplo, se vería así: Cadena original: " Me encanta Java" Delimitador: " " Matriz resultante: { "", "I", "love", "Java" } Pero si la cadena original termina con un delimitador en lugar que comenzar con uno, entonces el resultado será diferente: Cadena original: "Me encanta Java" Delimitador: " " Matriz resultante: { "Yo", "amo", "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));
    }
}

La salida del método principal será así: Nuevamente preste atención al hecho de que cuando el primer carácter de la cadena original es un carácter delimitador, el resultado es que el primer elemento de la matriz será una cadena vacía.

hermano sobrecargado

La clase String tiene otro método de división con la siguiente firma:

String[] split(String regex, int limit)

Este método tiene un parámetro de límite adicional : determina cuántas veces se aplicará el patrón de expresiones regulares a la cadena original. Vea las explicaciones a continuación:

límite > 0

El patrón se aplica límite -1 veces. Además, la longitud de la matriz devuelta no excederá el valor del parámetro de límite . El último elemento de la matriz será la parte de la cadena que sigue al último lugar donde se encontró el delimitador. Ejemplo:

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

límite < 0

La expresión regular delimitadora se aplica a la cadena tantas veces como sea posible. La matriz resultante puede tener cualquier longitud. Ejemplo:

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

límite = 0

Al igual que en el caso en que limit < 0, el patrón delimitador se aplica a la cadena tantas veces como sea posible. La matriz final puede tener cualquier longitud. Si los últimos elementos son cadenas vacías, se descartan de la matriz final. Ejemplo:

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

Si echamos un vistazo a la implementación de la versión de un parámetro del método split , podemos ver que es como su hermano sobrecargado, pero con el segundo argumento establecido en cero:

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

Varios ejemplos

En la práctica del mundo real, a veces sucede que tenemos cadenas que se generan de acuerdo con ciertas reglas. Tal cadena podría entrar en nuestro programa desde cualquier lugar:

• de un servicio de terceros;
• de una solicitud enviada a nuestro servidor;
• desde un archivo de configuración;
• etcétera.

En estas situaciones, el programador suele conocer las "reglas del juego". Digamos que un programador sabe que está tratando con información de usuario almacenada de acuerdo con este patrón: Tomemos algunos valores específicos como ejemplo: Supongamos que la tarea del programador es escribir un método que envíe un correo electrónico al usuario. El programador tiene acceso a los datos del usuario, que se registran en el formato indicado anteriormente. La subtarea que ahora seguiremos analizando es cómo aislar la dirección de correo electrónico del resto de datos del usuario. Esta es una instancia en la que el método de división puede ser útil. Después de todo, si observamos la plantilla de datos del usuario, nos damos cuenta de que extraer la dirección de correo electrónico del usuario del resto es tan simple como llamar al método split para dividir la cadena. Luego, la dirección de correo electrónico estará en el último elemento de la matriz resultante. Este es un ejemplo de un método que toma una cadena que contiene datos del usuario y devuelve la dirección de correo electrónico del usuario. Para simplificar, digamos que la cadena de datos siempre está en el 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 el delimitador: "\\|" . En expresiones regulares, "|" es un carácter especial con un significado especial, por lo que si queremos usarlo como un carácter ordinario (es decir, lo que queremos encontrar en la cadena original), debemos escapar del carácter con dos barras invertidas. Considere otro ejemplo. Digamos que tenemos información de pedidos que está estructurada así: O incluso podemos adoptar algunos valores específicos: Nuestra tarea es calcular el costo total del pedido. Aquí tendremos que aplicar varias veces el método split . El primer paso es dividir la cadena usando ";" como delimitador para dividirlo en sus partes componentes. Luego, cada subcadena resultante contendrá información sobre un producto separado, que podemos procesar más adelante. Luego, para cada producto, dividiremos la información correspondiente usando el símbolo ",". Tomaremos un elemento con un índice específico (aquel donde se almacena el precio del producto) de la matriz de cadenas resultante, lo convertiremos a forma numérica y calcularemos el costo total del pedido. Escribamos un método que haga todos estos 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;
    }
}

Vea si puede averiguar cómo funciona este método por su cuenta. Con base en estos ejemplos, podemos decir que el método de división se usa cuando tenemos algunos datos formateados como una cadena y necesitamos extraer cierta información más específica de ellos.

Resumen

Examinamos el método split de la clase String . Es justo lo que necesita cuando tiene que dividir una cadena en sus componentes con la ayuda de un delimitador especial. El método devuelve una matriz de cadenas (las subcadenas que componen la cadena original). Acepta una expresión regular cuyas coincidencias representan los caracteres delimitadores. Examinamos varias sutilezas de este método:

• un delimitador principal;
• su hermano sobrecargado con dos parámetros.

También tratamos de modelar algunas situaciones de la vida real en las que usamos el método de división para resolver problemas hipotéticos, pero bastante realistas.