¿Alguna vez te has encontrado con una línea de texto que contiene varios datos mezclados, como Patatas, 10 o Juan:25:Sevilla? Como programadores, necesitamos «trocear» esa información para poder trabajar con cada dato por separado.

En Java, la herramienta estrella para esto es el método split(). Hoy veremos cómo funciona y por qué siempre deberías usarlo junto a su mejor amigo: el método trim().

En esta entrada aprenderás:

• Qué es y para qué sirve split()
• Cómo se usa paso a paso
• Ejemplos sencillos y realistas
• Errores comunes y buenas prácticas

¿Qué es el método split() en Java?

El método split() pertenece a la clase String. Sirve para dividir una cadena de texto en varias partes, usando un separador que nosotros indiquemos.

El resultado es siempre un array de String.

Sintaxis básica

String[] partes = texto.split(separador);

• texto → la cadena original
• separador → el carácter o patrón que indica dónde cortar
• partes → array con los fragmentos obtenidos

Ejemplo sencillo: separar palabras

String frase = "Hola mundo Java";
String[] palabras = frase.split(" ");

System.out.println(palabras[0]); // Hola
System.out.println(palabras[1]); // mundo
System.out.println(palabras[2]); // Java

Aquí estamos usando el espacio como separador.

Ejemplo típico: datos separados por comas

Imagina que recibes una línea de texto con el nombre de un producto y su cantidad, separados por una coma:

Patatas,10

Podemos dividirla así:

String linea = "Patatas, 10";

// 1. Dividimos la línea por la coma
String[] datos = linea.split(",");

// 2. Extraemos los datos del array
String nombre = datos[0]; // "Patatas"
int cantidad = Integer.parseInt(datos[1].trim()); // Convertimos " 10" en 10

Resultado:

• datos[0] → «Patatas»
• datos[1] → «10»

¡Ojo al dato! Fíjate en el uso de .trim(). Cuando hacemos un split por una coma, si el usuario escribió un espacio después (como en "Patatas, 10"), el segundo elemento será " 10". El método trim() elimina esos espacios invisibles que suelen dar errores al convertir a número.

Ejemplo real en un bucle (caso práctico)

Este es un ejemplo muy habitual cuando leemos datos por teclado hasta que el usuario escriba FIN:

while (!(linea = scanner.nextLine()).equalsIgnoreCase("FIN")) {
    // Ejemplo de línea: Patatas, 10
    String[] datos = linea.split(",");
    Producto producto = new Producto(
        datos[0],
        Integer.parseInt(datos[1].trim())
    );
    lista.add(producto);
}

¿Qué está pasando aquí?

1. Se lee una línea completa
2. Se divide usando la coma ,
3. Se obtienen dos datos:
   • Nombre del producto
   • Cantidad
4. Se crea un objeto Producto
5. Se añade a una lista

El método split() permite convertir texto plano en datos estructurados.

Uso de trim() junto con split()

Un error muy común es olvidar los espacios:

Patatas, 10

Si hacemos:

String[] datos = linea.split(",");
int cantidad = Integer.parseInt(datos[1]); // ERROR

Fallará porque datos[1] contiene " 10".

Solución correcta

int cantidad = Integer.parseInt(datos[1].trim());

trim() elimina los espacios al principio y al final del texto.

Separadores habituales con split()

Dependiendo del formato de tus datos, el delimitador cambiará. Aquí tienes una tabla rápida:

Ejemplo con dos puntos:

String texto = "usuario:admin";
String[] partes = texto.split(":");

Importante: split() usa expresiones regulares

Algunos caracteres tienen significado especial, por ejemplo:

• .
• |
• *

Para separarlos, hay que escaparlos:

String texto = "192.168.1.1";
String[] partes = texto.split("\\.");

split() y las expresiones regulares: cuidado con los espacios

El método split() no separa por textos simples, sino que utiliza expresiones regulares (regex). Esto nos da mucha potencia, pero también puede provocar errores si no lo tenemos en cuenta.

El problema típico: espacios antes o después del separador

Imagina que el usuario escribe cualquiera de estas líneas:

Patatas,10
Patatas, 10
Patatas ,10
Patatas , 10

Si usamos:

String[] datos = linea.split(",");

La separación funcionará, pero algunos elementos pueden contener espacios extra, lo que obliga a usar trim().

Solución elegante usando expresiones regulares

Podemos indicar que puede haber cero o más espacios antes y después de la coma:

String[] datos = linea.split("\s*,\s*");

Explicación rápida:

• \s* → cero o más espacios en blanco
• , → la coma como separador

Así, todas las líneas anteriores se procesan correctamente sin necesidad de usar trim().

Buenas prácticas para tus exámenes de DAM

Para que tu código sea robusto y no «explote» (lance una excepción), sigue estos consejos de pensamiento computacional:

1. Limpia antes de trocear: Si la línea viene sucia, puedes hacer linea.trim().split(",") o usar expresiones regulares linea.split("\s*,\s*").
2. Verifica la longitud: Antes de acceder a datos[1], asegúrate de que el array tiene ese tamaño con if (datos.length >= 2).
3. Cuidado con los formatos: Si esperas un número, el split siempre te devolverá un String. No olvides el Integer.parseInt().

❌ Suponer que siempre hay datos suficientes

String[] datos = linea.split(",");
System.out.println(datos[1]); // Puede fallar

✔️ Mejor comprobar:

if (datos.length == 2) {
    // usar datos
}

¿Cuándo usar split()?

Usa split() cuando:

• Lees datos por teclado
• Procesas archivos CSV
• Trabajas con ficheros de texto
• Necesitas convertir una línea en varios datos

Es una herramienta clave en Programación de 1º DAM.

Resumen

• split() divide una cadena en partes
• Devuelve un array de String
• Es fundamental para trabajar con datos de texto
• Suele combinarse con trim() y conversiones de tipo

Dominar split() te permitirá manejar datos reales de forma eficaz en Java.

👉 En próximas entradas veremos cómo leer datos desde archivos CSV completos y validarlos correctamente.