Método de división en Java: dividir una cadena en partes

Hablemos del método String split : qué hace y por qué es necesario. Es fácil adivinar que divide la cuerda, pero ¿cómo funciona en la práctica? Echemos un vistazo más de cerca a cómo funciona el método y analicemos algunos detalles no obvios y, al mismo tiempo, descubramos cuántos métodos divididos hay realmente en la clase String . ¡Vamos!

Definición y firma de Java String.split

El método split en Java divide una cadena en subcadenas utilizando un delimitador que se especifica mediante una expresión regular. Firmemos el método y comencemos nuestra inmersión:

String[] split(String regex)

De la firma se desprenden dos cosas claramente:

1. El método devuelve una matriz de cadenas.
2. El método toma una cadena de expresiones regulares como parámetro.

Veamos cada cosa por separado en términos de la definición dada anteriormente.

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

   La definición contiene las siguientes palabras: "El método de división en Java divide una cadena en subcadenas". El método recopila estas subcadenas en una matriz y representan su valor de retorno.

2. El método toma una cadena de expresiones regulares como parámetro.

   Nuevamente, recuerde la definición: "divide una cadena en subcadenas usando un delimitador que se especifica mediante una expresión regular". El parámetro regex aceptado es un patrón de expresión regular que se aplica a la cadena de origen y coincide con el carácter delimitador (o combinación de caracteres) en la cadena de origen.

Dividir en la práctica

Ahora pongámonos manos a la obra. Imaginemos que tenemos una cadena con palabras. Por ejemplo, así: Necesitamos dividir la cuerda en palabras. Vemos que en esta línea las palabras están separadas entre sí por espacios. El espacio es un candidato ideal para el papel de separador en este caso. Así es como se ve el 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);
        }
    }
}

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 línea, el delimitador es una coma, por lo que la línea se divide de tal manera que algunas palabras tienen espacios iniciales. En la última línea, utilizamos una coma y un espacio como delimitador. Por lo tanto, la matriz resultante no contenía líneas con espacios iniciales. Este es sólo un pequeño detalle que demuestra lo importante que es seleccionar cuidadosamente el separador correcto.

Delimitador principal

Hay un matiz más importante. Si la cadena de origen comienza con un delimitador, el primer elemento de la matriz resultante será la cadena vacía. En un ejemplo, se vería así: Cadena fuente: "Me encanta Java" Delimitador: " " Matriz resultante: { "" , "I" , "love" , "Java" } Pero si la cadena fuente termina con un delimitador y no comienza, el resultado será diferente: Cadena fuente: "Me encanta Java" Separador: " " Matriz resultante: { "I" , "love" , "Java" } Veamos en el código las variaciones del método de división . con un carácter separador al final y/o al principio de la cadena de origen:

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í: Tenga en cuenta nuevamente que cuando el primer carácter de la cadena de origen es un carácter delimitador, la matriz resultante tendrá la cadena vacía como primer elemento.

Compañero sobrecargado

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

String[] split(String regex, int limit)

Este método tiene un parámetro de límite adicional : determina la cantidad de veces que se aplicará el patrón de expresiones regulares a la cadena de origen. A continuación se encuentran las explicaciones:

límite > 0

Se aplica el límite -1 veces . En este caso, la longitud de la matriz no excederá el valor límite . El último elemento de la matriz será la parte de la cadena que sigue al último delimitador encontrado. Ejemplo:

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Salida:
         [Me encanta Java]
         [Me encanta Java]
        */
    }

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

límite < 0

El patrón de búsqueda delimitador se aplica a la cadena tantas veces como sea posible. La longitud de la matriz resultante puede ser cualquiera. Ejemplo:

public class Main {
    public static void main(String[] args) {
        // Observe el espacio al final de la línea
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Salida:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Tenga en cuenta que el último elemento de la matriz es
        una cadena vacía, que resulta de un espacio
        al final de la cadena original.
        */
    }

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

límite 0

Al igual que con límite < 0, el patrón delimitador se aplica a la cadena tantas veces como sea posible. La matriz resultante puede tener cualquier longitud. Si los últimos elementos son iguales a la cadena vacía, serán descartados en la matriz final. Ejemplo:

public class Main {
    public static void main(String[] args) {
        // Observe el espacio al final de la línea
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Salida:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Tenga en cuenta la ausencia de cadenas vacías al final de las matrices
        */
    }

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

Si observamos la implementación del método split con un argumento, vemos que este método llama a su hermano sobrecargado con un segundo argumento de cero:

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

Varios ejemplos

En la práctica laboral, a veces sucede que tenemos una línea compilada según ciertas reglas. Esta línea puede “entrar” a nuestro programa desde cualquier lugar:

• de un servicio de terceros;
• de una solicitud a nuestro servidor;
• del archivo de configuración;
• etc.

Generalmente en tal situación el programador conoce las “reglas del juego”. Digamos que el programador sabe que tiene información sobre el usuario, que se almacena según este patrón: Por ejemplo, tomemos valores específicos: Y ahora el programador se enfrenta a la tarea: escribir un método que envíe un correo electrónico al usuario. Tiene a su disposición información sobre el usuario, registrada en el formato anterior. Bueno, la subtarea que seguiremos analizando es aislar la dirección de correo electrónico de la información general del usuario. Este es un ejemplo en el que el método de división puede resultar útil. Después de todo, si miramos la plantilla, entendemos que para extraer la dirección de correo electrónico del usuario de toda la información, solo necesitamos dividir la línea usando el método de división . Entonces la dirección de correo electrónico estará en el último elemento de la matriz resultante. Pongamos un ejemplo de un método de este tipo, que toma una cadena que contiene información sobre el usuario y devuelve el correo electrónico del usuario. Para simplificar, supongamos que esta cadena siempre coincide con el formato que necesitamos:

public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Salida: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // o datos[datos.longitud - 1]
    }
}

Tenga en cuenta el separador: "\\|" . Ya que en expresiones regulares “|” - este es un carácter especial al que está ligada cierta lógica; para usarlo como uno normal (el que queremos encontrar en la cadena fuente), necesitamos escapar de este carácter usando dos barras invertidas. Veamos otro ejemplo. Digamos que tenemos información sobre un pedido, que está escrita aproximadamente en este formato: O tomemos valores específicos: Nos enfrentamos a la tarea de calcular el coste total del pedido. Aquí tendremos que utilizar el método de división varias veces. El primer paso es dividir la cadena a través del símbolo ";" en sus partes componentes. Luego, en cada una de esas partes tendremos información sobre un producto individual, que podremos procesar en el futuro. Y luego, dentro de cada producto, separaremos la información usando el símbolo "," y tomaremos de la matriz resultante un elemento con un índice determinado (en el que se almacena el precio), lo convertiremos a forma numérica y compilaremos el costo final. De la orden. Escribamos un método que calcule todo esto:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1, pepinos, 20,05; 2, tomates, 123,45; 3, liebres, 0,50";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Salida: 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;
    }
}

Intente descubrir usted mismo cómo funciona este método. Con base en estos ejemplos, podemos decir que el método de división se utiliza cuando tenemos alguna información en forma de cadena, de la cual necesitamos extraer alguna información más específica.

Resultados

Observamos el método de división de la clase String . Es necesario dividir una cadena en sus componentes utilizando un delimitador especial. El método devuelve una matriz de cadenas (los componentes de una cadena). Acepta una expresión regular que encuentra los caracteres delimitadores. Analizamos las diversas sutilezas de este método:

• carácter delimitador principal;
• hermano sobrecargado con dos argumentos.

También intentamos simular algunas situaciones de la "vida real" en las que utilizamos el método de división para resolver problemas, aunque ficticios, pero bastante realistas.