Cómo dividir una cadena en Java

En este artículo, veremos cómo podemos dividir una cadena en Java. También exploraremos diferentes ejemplos y problemas comunes con el uso del método split().

Introducción

A menudo, nos enfrentamos a una situación en la que necesitamos dividir una cadena en algún carácter o subcadena específico, para obtener información útil de ella.

Por ejemplo, podríamos querer dividir un número de teléfono en el código de país o datos importados de un archivo CSV.

En este artículo, cubriremos cómo dividir una cadena en Java.

El método split() (sin límite)

Este método toma un parámetro String, en formato de expresión regular (regex). Este método divide la cadena en torno a las coincidencias de la expresión regular dada.

La sintaxis de este método es:

1
String[] split(String regex, int limit)

Donde el parámetro regex representa el delimitador, es decir, en función de lo que dividiremos nuestra cadena. Tenga en cuenta que este parámetro no necesita ser nada complicado, Java simplemente brinda la opción de usar expresiones regulares.

Por ejemplo, veamos cómo podemos dividir este String en dos nombres separados:

1
2
String myString = "Jane-Doe";
String[] splitString = myString.split("-");

Simplemente podemos usar un carácter/subcadena en lugar de una expresión regular real. Por supuesto, hay ciertos caracteres especiales en expresiones regulares que debemos tener en cuenta y escapar de ellos en caso de que queramos su valor literal.

Una vez que se divide la cadena, el resultado se devuelve como una matriz de cadenas. Las cadenas en la matriz devuelta aparecen en el mismo orden que en la cadena original.

Los resultados se empaquetan en la matriz String. Para recuperar los nombres separados, podemos acceder a cada elemento:

1
2
System.out.println(splitString[0]);
System.out.println(splitString[1]);

Esto resulta en:

1
2
Jane
Doe

Tenga en cuenta que este método dividirá la cadena en todas las apariciones del delimitador. Por ejemplo, podemos tener una entrada con formato CSV:

1
2
3
4
5
6
String myString = "Jane,21,Employed,Software Engineer";
String[] splitString = myString.split(",");

for (String s : splitString) {
    System.out.println(s);
}

Esto resulta en:

1
2
3
4
Jane
21
Employed
Software Engineer

Método Java split() (con un límite)

Aquí, el método toma dos parámetros, uno es el ‘regex’ discutido anteriormente, y el otro es un valor entero, que denota el ’límite’. El parámetro limit se usa para decidir cuántas veces queremos dividir la cadena.

El parámetro límite puede adoptar una de tres formas, es decir, puede ser mayor que, menor que o superior a cero. Veamos qué representa cada una de estas situaciones:

  • Un límite positivo - La Cadena se dividirá hasta un máximo de límite - 1 veces. Más allá de esto, el resto de la cadena se devolverá como el último elemento de la matriz, tal como está, sin dividirse. La longitud de la matriz devuelta siempre será menor o igual que límite.
  • Un ’límite’ negativo - La ‘Cadena’ se divide en el delimitador tantas veces como sea posible, ignorando el conjunto de valores negativos en particular. Las subcadenas en la matriz incluyen los espacios finales en la cadena original, si los hay.
  • Cuando el ’límite’ se establece en ‘0’ - La ‘Cadena’ se divide de nuevo tantas veces como sea posible, y no hay límite en la longitud de la matriz resultante. Funciona igual que llamar al método split(), con expresiones regulares como el único argumento, como se vio anteriormente. En este caso, no se devuelven los espacios finales.

Valor límite positivo

Echemos un vistazo a algunos ejemplos del uso de diferentes límites. En primer lugar, un valor límite positivo:

1
2
3
4
5
6
String myString = "there,,are,more,than,three,commas,,,";
String [] splitStrings = myString.split(",", 4);

for(String string : splitStrings){
    System.out.println(String.format(" \" %s \"", string));
}

Con un límite de 4, la Cadena se dividirá como máximo tres (límite - 1) veces. Lo que nos da una matriz con cuatro elementos (0..3), siendo el último elemento todo después de la tercera división:

1
2
3
4
"there"
""
"are"
"more,than,three,commas,,,"

Si usamos un límite negativo en esta misma Cadena:

1
2
3
4
5
6
String myString = "there,,are,more,than,three,commas,,,";
String [] splitStrings = myString.split(",", -1);

for(String string : splitStrings){
    System.out.println(String.format(" \" %s \"", string));
}

La ‘Cadena’ se dividirá tantas veces como sea posible, y las cadenas vacías finales se agregarán a la matriz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
"there"
""
"are"
"more"
"than"
"three"
"commas"
""
""
""

El valor negativo real que usamos no se tiene en cuenta, obtendríamos el mismo resultado si usáramos -150.

Si establecemos el límite en 0, la cadena se dividiría de nuevo tantas veces como sea posible, pero la matriz resultante no contendría los espacios vacíos finales:

1
2
3
4
5
6
7
8
String myString = "there,,are,more,than,three,commas,,,";

// Equivalent to calling the split() method with only the regex parameter
String [] splitStrings = myString.split(",", 0);

for(String string : splitStrings){
    System.out.println(String.format(" \" %s \"", string));
}

Esto nos daría:

1
2
3
4
5
6
7
"there"
""
"are"
"more"
"than"
"three"
"commas"

Nota sobre caracteres especiales

Como mencionamos anteriormente, el parámetro regex pasado como delimitador en el método split() es una expresión regular. Tenemos que asegurarnos de escapar de los caracteres especiales si queremos usar su valor literal como delimitador. Por ejemplo, el carácter * significa "una o más instancias de los siguientes caracteres".

Hay 12 caracteres de este tipo en expresiones regulares. Estos son: \, ^, $, ., |, ?, *, +, (, ), [, { . Puedes ver su significado en expresiones regulares [aquí](https://www.regular-expressions.info/characters.html#:~:text=In%20the%20regex%20flavors%20discussed,%2C%20the%20closing%20parenthesis %20)%2C%20the).

Si queremos dividir una String en uno de estos caracteres, se debe tener especial cuidado para escapar estos caracteres en los parámetros del método. Una forma en que podemos usar esto es usar una barra invertida \. Por ejemplo:

1
string.split("\\|");

Divide la variable string en el carácter |. Usamos dos barras invertidas aquí ya que primero necesitamos escapar del significado de Java de la barra invertida, por lo que la barra invertida se puede aplicar al carácter |.

En lugar de esto, podemos usar un conjunto de caracteres regex. Esto se refiere a poner los caracteres especiales que se van a escapar entre corchetes. De esta forma, los caracteres especiales se tratan como caracteres normales. Por ejemplo, podríamos usar un | como delimitador diciendo:

1
string.split("[|]");

Otra forma de escapar de los caracteres especiales es usar Pattern.quote():

1
string.split(Pattern.quote("|"));

Conclusión

El método split() de la clase Java String es una herramienta muy útil y de uso frecuente. La mayoría de los datos, especialmente los obtenidos a partir de la lectura de archivos, requerirían una cierta cantidad de procesamiento previo, como dividir la cadena, para obtener información significativa de ellos.

En este artículo, hemos repasado cómo dividir cadenas en Java.

Licensed under CC BY-NC-SA 4.0