Componentes clave
Clases Métodos
java.lang.String String[ ]split(String expReg)
En ocasiones, querrá descomponer una cadena en un conjunto de subcadenas, con base en algún criterio. Por ejemplo, dada una dirección de correo electrónico, tal vez quiera obtener dos subcadenas. La primera es el nombre del destinatario; la segundo es el URL. En este caso, el separador es @. En el pasado, habría hecho una búsqueda manual de @ empleando un método como indexOf( ) y luego substring( ) para recuperar cada parte de la dirección. Sin embargo, a partir de Java 1.4 quedó disponible una opción más conveniente: split( ).
El método split( ) emplea una expresión regular para proporcionar una manera muy conveniente de descomponer una cadena en un conjunto de subcadenas en un solo paso. Debido a que los caracteres que forman los delimitadores entre subcadenas están especifi cados por un patrón, puede usar split( ) para manejar algunos problemas complicados de descomposición. Por ejemplo, el uso de split( ) es fácil para obtener una lista de las palabras contenidas dentro de una cadena. Simplemente especifi que una expresión regular que busque todos los caracteres que no son de palabra. Muchos otros tipos de divisiones también son fáciles. Por ejemplo, para dividir una cadena que contiene una lista de valores separados por comas, como 10, 20, 30, etc., simplemente especifi que una coma como expresión delimitante. Sin importar cómo lo use, split( ) es uno de los métodos basados en expresiones regulares más importantes de String. Una vez que lo domine, le sorprenderá la frecuencia con que habrá de usarlo.
Paso a paso
La división de una cadena en partes incluye estos dos pasos:
1. Cree una expresión regular que defi ne el delimitador que se usará para dividir la cadena. 2. Llame a split( ) en la cadena, pasándola en la expresión regular. Se regresa una matriz de
Análisis
El método split( ) defi nido por String descompone la cadena que se invoca. El sitio donde termina una subcadena y empieza la siguiente se determina con una expresión regular. Por tanto, la
expresión regular especifi ca los delimitadores que terminan una subcadena. (La primera subcadena está delimitada por el principio de la cadena. La subcadena fi nal está delimitada por el fi nal de la cadena.) Hay dos formas de split( ). Aquí se muestra la usada en la solución:
String[ ]split(String expReg)
La expresión delimitante está especifi cada por expReg. El método devuelve una matriz que contiene las piezas de la cadena. Si no hay coincidencias con expReg entonces se devuelve toda la cadena. El método split( ) lanzará una PatternSyntaxException si expReg no contiene una expresión regular válida.
Cuando se construye una expresión regular para usar en split( ) tenga presente que está defi niendo el patrón que separa una subcadena de otra. No está especifi cando un patrón que buscará coincidencias con las piezas que quiere. Por ejemplo, dada la cadena
Se trata de una prueba.
para dividir esta cadena en palabras que están separadas por espacios, pase la siguiente expresión regular a expReg.
"\\s+"
Esto da como resultado una matriz que contiene las siguientes subcadenas: Se
trata de una prueba.
La subcadena fi nal "prueba". incluye el punto porque sólo los espacios coinciden con la expresión regular. Sin embargo, como se explicó, la última subcadena termina con el fi nal de la cadena de entrada, y no necesita terminar en una coincidencia con la expresión regular.
Ejemplo
En el siguiente ejemplo se muestran varios ejemplos que dividen una cadena en partes basada en varias expresiones regulares.
// Usa split( ) para extraer una subcadena de una cadena. class DemoDiv {
static void showSplit(String[ ] cads) { for(String cad : cads)
System.out.print(cad + "|"); System.out.println("\n"); }
// Demuestra split( ).
public static void main(String args[ ]) { String resultado[ ];
String cadPrueba = "Se trata de una prueba."; System.out.println("Cadena original: " + cadPrueba); resultado = cadPrueba.split("\\s+");
System.out.print("Dividida en espacios: "); showSplit(resultado);
// Divide en límites de palabras. cadPrueba = "Uno, dos y tres.";
System.out.println("Cadena original: " + cadPrueba); resultado = cadPrueba.split("\\W+");
System.out.print("Dividida en l\u00a1mites de palabras: "); showSplit(resultado);
// Divide alguna cadena en comas y cero o más espacios. System.out.println("Cadena original: " + cadPrueba); resultado = cadPrueba.split(",\\s*");
System.out.print("Dividida en comas: "); showSplit(resultado);
// Divide en límites de palabras, pero permite // puntos y @ insertados.
cadPrueba = "Jerry Jerry@HerbSchildt.com";
System.out.println("Cadena original: " + cadPrueba); resultado = cadPrueba.split("[\\W && [^.@]]+");
System.out.print("Permite que . y @ sean parte de una palabra: "); showSplit(resultado);
// Divide en signos de puntuación y cero o más espacios al final. cadPrueba = "Se! trata, de. una:; prueba?";
System.out.println("Cadena original: " + cadPrueba); resultado = cadPrueba.split("[.,!?:;]+\\s*");
System.out.print("Dividida en signos de puntuaci\u00a2n: "); showSplit(resultado);
} }
A continuación se muestra la salida:
Cadena original: Se trata de una prueba. Dividida en espacios: Se|trata|de|una|prueba.| Cadena original: Uno, dos y tres.
Dividida en límites de palabras: Uno|dos|y|tres| Cadena original: Uno, dos y tres.
Dividida en comas: Uno|dos y tres.|
Cadena original: Jerry Jerry@HerbSchildt.com
Permite que y @ sean parte de una palabra: Jerry|Jerry@HerbSchildt.com| Cadena original: Se! trata, de. una:; prueba?
Opciones
Aunque el método split( ) es muy poderoso, le falta un poco de fl exibilidad. Por ejemplo, es difícil usar split( ) para descomponer una cadena basada en delimitadores que cambien en relación con el contexto. Aunque es posible idear expresiones regulares muy complejas que puedan manejar operaciones de búsqueda de coincidencias muy sofi sticadas, éste no es siempre el mejor método. Más aún, habrá ocasiones en que quiera dividir en fi chas por completo una cadena, en que se obtengan todas las partes de la cadena (incluidos delimitadores). En estas situaciones, puede usar las clases Pattern y Matcher proporcionadas por la API de expresiones regulares de Java para obtener un control más conveniente, detallado. Este método se muestra en Divida en fi chas una cadena empleando la API de expresiones regulares.
Puede limitar el número de coincidencias que encontrará split( ), y por tanto el número de subcadenas que se devolverán, empleando esta forma de split( ):
String[ ]split(String expReg, int num)
Aquí, expReg especifi ca la expresión delimitante. El número de veces que se buscará coincidencias se pasa en num. Se lanzará PatternSyntaxException si expReg no contiene una expresión regular válida.