Componentes clave
Clases Métodos
java.lang.String String[ ]split(String expReg) String trim( )
Un uso especialmente bueno de split( ) se encuentra en la recuperación de pares clave/valor de una cadena. Los pares clave/valor son muy comunes en programación, sobre todo la basada en Web. Por esto, Java les proporciona un soporte importante. Por ejemplo, la clase Properties y las varias implementaciones de la interfaz Map operan con pares de claves y valores. Por desgracia, no siempre se dan los pares clave/valor en un forma conveniente para usarla como HashMap, por ejemplo. A menudo, se reciben en forma de cadena y nos queda el trabajo de extraerlos. La solución que se muestra aquí ilustra un método para realizar esta tarea común.
Los pares clave/valor se representan en una cadena de varias maneras. En la solución que se muestra aquí, se supone la siguiente organización:
clave = valor, clave = valor, clave = valor,...
Cada par clave/valor está separado del siguiente por una coma. Cada clave está vinculada con su valor por un signo de igual. Se permiten espacios, pero no son necesarios. La técnica mostrada aquí puede adaptarse fácilmente para manejar otros formatos.
Paso a paso
La extracción de pares clave/valor de una cadena incluye tres pasos:
1. Elimine cualquier espacio en blanco al principio o al fi nal de la cadena que contiene los pares clave/valor al llamar a trim( ).
2. Divida la cadena que contiene los pares clave/valor en subcadenas individuales que contienen una sola clave y un valor al usar una coma (con espacios en blanco opcionales) como delimitador en una llamada a split( ). He aquí una manera de especifi car la expresión delimitadora: \s*,\s*. Cada elemento de la matriz resultante contiene un par clave/valor. 3. Divida cada subcadena individual de clave/valor en su clave y valor al llamar a split( ) con
= como delimitador. Permita, pero no imponga, espacios en blanco. He aquí una manera de especifi car el delimitador: \s*=\s*. La matriz resultante contiene una clave individual y su valor.
Análisis
La operación de split( ) se describe en la solución anterior.
Para eliminar los espacios al principio y el fi nal de la cadena de entrada, se usa el método trim( ) de String. Aquí se muestra:
String trim( )
Elimina los espacios al principio y al fi nal de la cadena que se invoca y devuelve el resultado. La manera en que la cadena de entrada se forma determina la manera en que se construyen las expresiones delimitadoras. Como se explicó, esta solución supone un formato muy común. Sin embargo, si su cadena de entrada difi ere, entonces debe ajustar de manera apropiada los delimitadores.
Ejemplo
En el siguiente ejemplo se crea un método de propósito general llamado obtenerParesCV( ) que reduce una cadena que contiene uno o más pares clave/valor en las partes que lo integran. Cada par clave/valor está almacenado en un objeto de tipo parCV, que es defi nido por el programa. obtenerParesCV( ) devuelve una matriz de parCV.
El método obtenerParesCV( ) le permite especifi car las expresiones regulares que defi nen los delimitadores que separan cada par clave/valor del siguiente, y que separan una clave individual de su valor. Por tanto, puede usarse obtenerParesCV( ) para dividir una amplia variedad de formatos clave/valor. Si la cadena de entrada no está en un formato esperado, obtenerParesCV( ) lanza una ExcepcionDivCV que es una excepción defi nida por el programa. Si cualquier expresión delimitadora no es válida, se lanza una PatternSyntaxException.
// Usa split( ) para extraer pares clave/valor de una cadena. import java.util.regex.PatternSyntaxException;
// Una clase que mantiene pares clave/valor como Strings. class ParCV {
String clave; String valor;
ParCV(String c, String v) { clave = c;
valor = v; }
}
// una clase de excepción para errores de obtenerParesCV( ). class ExcepcionDivCV extends Exception {
// Llenar los detalles necesarios. }
// Esta clase encapsula el método estático obtenerParesCV( ). class DividirCV {
// Este método extrae los pares clave/valor almacenados // en una cadena y devuelve una matriz que contiene // cada clave y valor encapsulado en un objeto ParCV. //
// Se pasa a la cadena que contiene los pares clave/valor // y dos expresiones regulares que describen los delimitadores // usados para extraer los pares clave/valor. El parámetro parSep // especifica el patrón que separa un par clave/valor
// del siguiente dentro de la cadena. El parámetro sepCV // especifica el patrón que separa una clave de un valor. //
// Lanza una PatternSyntaxException si una expresión // separadora no es válida y una ExcepcionDivCV si // la cadena entrante no contiene pares clave/valor // en el formato esperado.
public static ParCV[ ] obtenerParesCV(String cad, String parSep, String sepCV) throws PatternSyntaxException, ExcepcionDivCV {
// Primero, recorta la cadena entrante para eliminar espacios // al principio y al final.
cad = cad.trim( );
// Luego, divide la cadena entrante en cadenas individuales // y cada una contiene un par clave/valor. La expresión // en parSep determina la secuencia de caracteres que // separa un par clave/valor del siguiente.
String[ ] cadsCV = cad.split(parSep);
// Ahora, construye una matriz ParCV que contendrá // cada clave y valor como cadenas individuales. ParCV[ ] pscv = new ParCV[cadsCV.length];
// Extrae cada clave y valor. String[ ] tmp;
for(int i = 0; i < cadsCV.length; i++) { tmp = cadsCV[i].split(sepCV); //
// Si una matriz devuelta por split( ) tiene más // o menos de 2 elementos, entonces la cadena de // entrada contiene algo más que pares
// clave/valor, o se encuentra en un formato no // válido. En este caso, se lanza una excepción. if(tmp.length != 2) throw new ExcepcionDivCV( );
// De otra manera, se almacena el siguiente par clave/valor. pscv[i] = new ParCV(tmp[0], tmp[1]);
} return pscv; } } // Demuestra obtenerParesCV( ). class DemoParCV {
public static void main(String args[ ]) { String cadPrueba =
"Nombre = Juan, Edad = 27, NumID = 1432, Sueldo = 37.25"; System.out.println("Cadena clave/valor: " + cadPrueba); // Obtiene una matriz que contiene las claves y los valores. ParCV parescv[ ];
try {
// Esta llamada a obtenerParesCV( ) especifica que los // pares clave/valor están separados por una coma (y // cualquier cantidad de espacios) y que una clave // está separada de su valor por un = (y cualquier // cantidad de espacios).
parescv =
DividirCV.obtenerParesCV(cadPrueba, "\\s*,\\s*", "\\s*=\\s*"); } catch(PatternSyntaxException exc) {
System.out.println("Expresi\u00a2n no v\u00a0lida de separador."); return;
} catch(ExcepcionDivCV exc) {
System.out.println("Error al obtener claves y valores."); return;
}
// Despliega cada clave y su valor. for(ParCV pcv : parescv)
System.out.println("Clave: " + pcv.clave + "\tValor: " + pcv.valor); }
Aquí se muestra la salida:
Cadena clave/valor: Nombre = Juan, Edad = 27, NumID = 1432, Sueldo = 37.25 Clave: Nombre Valor: Juan
Clave: Edad Valor: 27 Clave: NumID Valor: 1432 Clave: Sueldo Valor: 37.25
Opciones
Aunque el uso de split( ) suele ser el método más fácil, por mucho, puede extraer pares clave/valor al emplear una combinación de otros métodos de String, como indexOf( ) y substring( ). Este tipo de implementación puede ser apropiado cuando la cadena que contiene los pares clave/valor no usa un formato uniforme.
La extracción de pares clave/valor es un caso especial de un concepto más general: división en fi chas. En algunos casos, sería más fácil (o más conveniente) dividir en fi chas el fl ujo de entrada en todas sus partes constituyentes y luego determinar qué constituye un par clave/valor empleando otra lógica de programa. Este tipo de método sería especialmente útil en la cadena de entrada que contiene más que sólo pares clave/valor. Consulte Divida en fi chas una cadena empleando la API de expresiones regulares, para conocer más detalles acerca de la división en fi chas.