# Prácticos usos de string split() en Java

El método string split() en Java se utiliza para dividir strings en distintas partes. Para ello se recurre a un parámetro que funciona como separador. También puede usarse un parámetro para regular el número de substrings. Cabe considerar algunas características especiales al usar el método.

## ¿En qué consiste el método de Java string split()?

Un [string de Java](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-strings/) encadena múltiples letras, cifras o caracteres especiales. Existe como objeto en la clase java.lang y se crea y edita con la clase string. Este [lenguaje de programación](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/lenguajes-de-programacion-web/) permite separar los strings en diferentes partes. El método de Java string split() se utiliza si solo quieres **extraer ciertas áreas de todo el string** o descomponerlo en **elementos individuales**. Te enseñamos las distintas opciones que ofrece este método.

Si incrustas un string split() en Java, te devolverá un array de múltiples strings. Este se convierte en el valor de retorno.

## Sintaxis y funcionamiento del método de Java string split()

La sintaxis del método string split() de Java es de base muy simple, pero puede ampliarse con parámetros opcionales. La versión principal es la siguiente:

```java
String[] split(String regex)
```

Aquí se observa que lo que Java **devuelve es en forma de un array**. `String` es el objeto cadena. `regex` es un parámetro de entrada que se utiliza para indicar dónde debe dividirse el string. Aunque no es obligatorio usar este parámetro, sí es recomendable utilizarlo. Con el parámetro opcional `limit`, la sintaxis es la siguiente:

```java
String[] split(String regex, int limit)
```

`limit` indica en cuántos componentes se divide el string. El valor es un número entero: si es negativo o igual a 0, devolverá todas las subcadenas. Si eliges un valor positivo, solo se mostrará el número correspondiente de subcadenas.

## Ejemplo del método separando con espacios

Para entender cómo funciona string split() en Java, lo mejor es utilizar un ejemplo práctico. Hemos creado un string con cuatro palabras “Esto es un ejemplo”. Puedes dividir este string utilizando el método string split(). Lo más lógico es separar las palabras entre los delimitadores creados por los **espacios que hay entre las palabras**. Puedes separar el string con el siguiente código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Esto es un ejemplo";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Ahora se iniciará una variable de string x. A continuación, Java aplicará el método string split() a x. El parámetro `regex` busca espacios en la cadena y la divide por ahí. El resultado se almacena en una matriz llamada “output”. Estas subcadenas se enumeran con el bucle `for`. Gracias al [comando Java](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/comandos-java/) `System.out.println` obtendrás el siguiente resultado.

```java
Esto
es
un
ejemplo
```

## La coma como separador con y sin espacios

También puedes usar este método para **subdividir listados** que han sido separados por comas y almacenados como un string. Para ello hay que recurrir a un pequeño truco que dirá cómo deben implementarse las indicaciones que le das. Imagina una lista con los días de la semana, cada uno separado por una coma. Las comas son un buen parámetro para `regex`. Si las utilizas, el código tendrá este aspecto:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo";
		String[] output = x.split(",");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

El resultado en este caso no será el ideal:

```java
lunes
 martes
 miércoles
 jueves
 viernes
 sábado
 domingo
```

Así se obtiene una lista clara pero todos los valores a partir de “martes” tienen un espacio al inicio. Como la división se aplica siempre tras la coma de rigor, string split() en Java incluye este espacio en al principio de la subcadena. Para evitar este problema, simplemente modifica el método con un **espacio adicional como separador**. Este sería el código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo";
		String[] output = x.split(", ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Ahora se ve mucho más ordenador:

```java
lunes
martes
miércoles
jueves
viernes
sábado
domingo
```

## Separar cadenas de dígitos

Este método también permite separar largas cadenas de dígitos. Como ejemplo, imaginemos una clave larga dividida por puntos y dos puntos. Si quieres separar los dígitos que vienen **tras los dos puntos**, debes usar este código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "194.518.552.1.17:6339";
		String[] output = x.split(":");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

El programa devolverá lo siguiente:

```java
194.518.552.1.17
6339
```

## El método String split() de Java con el parámetro limit

Tal y como se ha mencionado, string split() también puede combinarse con el parámetro `limit`. Este restringe el número de componentes que crea string split(). Hay tres opciones de valores: valor menor a 0, igual a 0 o mayor a 0.

### limit menor a 0

Si eliges un valor menor a cero con limit, la expresión regular **se aplicará a toda la cadena de caracteres sin restricciones**. El conjunto resultante puede ser de cualquier longitud. El código será el siguiente:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", -3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Tras el último concepto, “domingo”, hay un espacio, por lo que el array termina con un string vacío. El resultado es el siguiente:

```java
lunes
martes
miércoles
jueves
viernes
sábado
domingo
```

### limit 0

Si el valor del parámetro `limit` es 0, la expresión regular también se utiliza **con la mayor frecuencia posible**. La longitud del array no está limitada. Sin embargo, si el último elemento es un string vacío, el array final no lo tiene en cuenta.

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", 0);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

El resultado es el mismo pero se descarta el último string:

```java
martes
miércoles
jueves
viernes
sábado
domingo
```

### limit mayor a 0

Si `limit` tiene un valor mayor a 0, obviamente habrá diferencias. Este número determinará cuántas subcadenas devuelve Java. Para el ejemplo que nos ocupa, el código es el siguiente:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", 3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Este resultado difiere de los dos anteriores a simple vista:

```java
lunes
martes
miércoles, jueves, viernes, sábado, domingo
```


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-string-split/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-string-split/) for AI/LLM consumption.