Java Soluciones De Programación 1n4l6b

void sort(T[ ] matriz, Comparator comp)

java.util.Comparator

int compare(T objA, T objB)

Ordenar es una tarea común en programación, y ordenar matrices de cadenas no es la excepción. Por ejemplo, tal vez quiera ordenar una lista de los artículos vendidos por una tienda en línea o una lista de nombres de clientes y direcciones de correo electrónico. Por fortuna, Java facilita el ordenamiento de matrices de cadenas porque proporciona el método de utilería sort( ), que está definido por la clase Arrays en java.util. En su forma predeterminada, sort( ) ordena cadenas en orden alfabético, sensible a mayúsculas y minúsculas, y esto es adecuado por muchas situaciones. Sin embargo, en ocasiones querrá ordenar una matriz de cadenas en orden alfabético inverso. Esto requiere un poco más de trabajo. Hay varias maneras de tratar el problema de ordenar a la inversa. Por ejemplo, una solución inocente consiste en ordenar la matriz y luego copiarla de atrás hacia delante en otra matriz. Además de carecer de elegancia, esta técnica también es ineficiente. Por fortuna, Java proporciona una manera simple, pero efectiva de ordenar a la inversa una matriz de cadenas. Este método usa un Comparator personalizado para especificar la manera en que debe aplicarse el orden y una versión de sort( ) que toma Comparator como argumento.

Paso a paso Para ordenar una matriz de cadenas a la inversa se requieren tres pasos: 1. Cree un Comparator que invierte la salida de una comparación entre dos cadenas. 2. Cree un objeto de ese Comparator. 3. Pase la matriz que se ordenará y el Comparator a una versión de java.util.Arrays.sort( ) que tome un comparador como argumento. Cuando sort( ) regrese, la matriz se ordenará a la inversa.

Análisis Comparator es una interfaz genérica que se declara como se muestra aquí: Comparator

Capítulo 2:

Trabajo con cadenas y expresiones regulares

15

El parámetro de tipo T especifica el tipo de datos que se habrá de comparar. En este caso, String se pasará a T. Comparator define los dos métodos siguientes: int compare(T objA, T objB) boolean equals(Object obj) De éstos, sólo compare( ) debe implementarse. El método equals( ) simplemente especifica una sobreescritura de equals( ) en Object. La implementación de equals( ) le permite determinar si dos Comparator son iguales. Sin embargo, esta capacidad no siempre es necesaria. Cuando no se necesita (como sucede en este capítulo), no es necesario sobreescribir la implementación de Object. El método en que estamos interesados es compare( ). Determina la manera en que se compara un objeto con otro. Por lo general, debe devolver menos de cero si objA es menor que objB, más que cero si objA es mayor que objB y cero si los dos objetos son iguales. Al implementar compare( ) de esta manera se logra que opere de acuerdo con el orden natural de los datos. En el caso de cadenas, esto significa orden alfabético. Sin embargo, tiene la libertad de implementar compare( ) para adecuarse a las necesidades de su tarea. Para ordenar a la inversa una matriz de cadenas, necesitará crear una versión de compare( ) que invierta la salida de la comparación. He aquí la manera de implementar un operador inverso para String. // Crea un Comparator que devuelve la salida // de una comparación de cadena inversa. class CompCadInv implements Comparator<String> { // Implementa el método compare( ) de modo que // invierte el orden de la comparación de la cadena. public int compare(String cadA, String cadB) { // Compara cadB con cadA, en lugar de cadA con cadB. return cadB.compareTo(cadA); } }

Revisemos de cerca CompCadInv. En primer lugar, observe que implementa Comparator. Esto significa que un objeto de tipo CompCadInv se puede usar en cualquier lugar que se necesite un Comparator. Asimismo, observe que implementa una versión específica de String de Comparator. Por tanto, CompCadInv no es, en sí, genérico. Sólo funciona con cadenas. Ahora, observe que el método compare( ) llama al método compareTo( ) de String para comparar dos cadenas. compareTo( ) es especificada por la interfaz Comparable, que está implementada por String (y muchas otras clases). Una clase que implementa Comparable garantiza que los objetos de esa clase pueden ordenarse. A continuación se muestra la forma general de compareTo( ), como la implementa String: int compareTo(String cad) Devuelve menos de cero si la cadena de invocación es menor que cad, más de cero si es mayor que cad y cero si son iguales. Una cadena es menor que otra si se encuentra antes en el orden alfabético y es mayor si se encuentra después.

16

Java: Soluciones de programación El método compare( ) de CompCadInv devuelve el resultado de la llamada a compareTo( ). Sin embargo, observe que compare( ) llama a compareTo( ) en orden inverso. Es decir, se llama a compareTo( ) en cadB mientras cadA se pasa como argumento. Para una comparación normal, cadA invocaría a compareTo( ), pasando cadB. Sin embargo, como cadB invoca a compareTo( ), se invierte el resultado de la comparación. Por tanto, se invierte el orden de las dos cadenas. Una vez que ha creado un comparador inverso, se crea un objeto de ese comparador y se pasa a esta versión de sort( ) definida por java.util.Arrays: static void sort(T[ ] matriz, Comparator comp) Observe la cláusula super. Asegura que la matriz pasada a sort( ) sea compatible con el tipo de Comparator. Después de la llamada a sort( ), la matriz estará en orden alfabético invertido.

Ejemplo En el siguiente ejemplo se invierte el orden de una matriz de cadenas. Para fines de demostración, también se les ordena de manera natural empleando la versión predeterminada de sort( ). // Ordena una matriz de cadenas en orden inverso. import java.util.*; // Crea un Comparator que devuelve la salida // de una comparación de cadena inversa. class CompCadInv implements Comparator<String> { // Implementa el método compare( ) de modo que // invierte el orden de la comparación de la cadena. public int compare(String cadA, String cadB) { // Compara cadB con cadA, en lugar de cadA con cadB. return cadB.compareTo(cadA); } } // Demuestra el comparador de cadena inverso. class OrdenCadInv { public static void main(String args[ ]) { // Crea una matriz simple de cadenas. String cads[ ] = { "perro", "caballo",

"cebra", "vaca", "gato" };

// Muestra el orden inicial. System.out.print("Orden inicial: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); // Ordena la matriz a la inversa. // Empieza por crear un comparador de cadena inversa. CompCadInv cci = new CompCadInv( );

Capítulo 2:


17

// Ahora, ordena las cadenas empleando el comparador inverso. Arrays.sort(cads, cci); // Muestra el orden inverso. System.out.print("Orden inverso: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); // Para comparación, ordena la cadena de manera natural. Arrays.sort(cads); // Muestra el orden natural. System.out.print("Orden natural: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); } }

A continuación se muestra la salida de este programa: Orden inicial: perro caballo cebra vaca gato Orden inverso: vaca perro gato cebra caballo Orden natural: caballo cebra gato perro vaca

Opciones Aunque esta solución ordena cadenas en orden alfabético inverso, la misma técnica básica puede generalizarse para otras situaciones. Por ejemplo, puede revertir el orden de otros tipos de datos al crear el Comparator apropiado. Simplemente adapta el método mostrado en el ejemplo. El método compareTo( ) definido por String es sensible a mayúsculas y minúsculas. Esto significa que ambos tipos de letra se ordenarán por separado. Tiene la opción de ordenar datos sin importar las diferencias entre mayúsculas y minúsculas al emplear compareToIgnoreCase( ). (Consulte Ignore las diferencias entre mayúsculas y minúsculas cuando ordene una matriz de cadenas). Puede ordenar cadenas con base en alguna subcadena específica. Por ejemplo, si cada cadena contiene un nombre y una dirección de correo electrónico, entonces puede crear un comparador que ordene a partir de la parte de la dirección de cada cadena. Una manera de realizar esto consiste en usar el método regionMatches( ). También puede ordenar por algún criterio diferente de una estricta relación alfabética. Por ejemplo, cadenas que representan tareas pendientes pueden ordenarse por prioridad.

18

Java: Soluciones de programación

Ignore las diferencias entre mayúsculas y minúsculas cuando ordene una matriz de cadenas Componentes clave Clases e interfaces

Métodos

java.lang.String

int compareToIgnoreCase(String cad)

java.util.Arrays

static void sort(T[ ] matriz, Comparator comp)


int compare(T objA, T objB)

En Java, el orden natural de las cadenas es sensible a mayúsculas y minúsculas. Esto significa que las letras mayúsculas están separadas y son diferentes de las minúsculas. Como resultado, cuando ordena una matriz de cadenas, podrían ocurrir algunas sorpresas que no son bienvenidas. Por ejemplo, si ordena una matriz String que contiene las siguientes palabras: alfa beta Gama Zeta El orden resultante será como se muestra aquí: Gama Zeta alfa beta Como verá, aunque Gama y Zeta normalmente se encontrarían después de alfa y beta, están al principio de la matriz ordenada. La razón es que, en Unicode, las mayúsculas están representadas por valores menores que los usados para las minúsculas. Por tanto, aunque Zeta se encontraría normalmente al final de la lista cuando se ordena alfabéticamente, se encuentra antes de alfa cuando son importantes las diferencias entre mayúsculas y minúsculas. ¡Esto puede llevar a órdenes que producen resultados técnicamente exactos, pero indeseables! NOTA Como algo interesante hay que mencionar que una mayúscula vale exactamente 32 menos que su equivalente en minúsculas. Por ejemplo, el valor de Unicode para la A es 65. Y para la a es 97. Por fortuna, es muy fácil ordenar una matriz de cadenas con base en el verdadero orden alfabético al crear un Comparator que ignore si una letra está en mayúsculas o minúsculas durante el proceso de ordenamiento. La técnica es similar a la descrita en Ordene una matriz de cadenas de manera inversa. Los detalles se describen a continuación.

Paso a paso Para ignorar las diferencias entre mayúsculas y minúsculas cuando ordene una matriz de cadenas se incluyen estos tres pasos: 1. Cree un Comparator que ignore las diferencias entre mayúsculas y minúsculas de dos cadenas. 2. Cree un objeto de ese Comparator.

Capítulo 2:


19

3. Pase la matriz que se ordenará y el Comparator a la versión de comparador de java.util. Arrays.sort( ). Cuando regrese sort( ), la matriz se ordenará sin importar las diferencias entre mayúsculas y minúsculas.

Análisis Para ignorar las diferencias entre mayúsculas y minúsculas cuando se ordena una matriz de cadenas, necesitará implementar un Comparator no sensible a mayúsculas y minúsculas para cadenas. Para ello, defina una versión de compare( ) que ignore las diferencias cuando compara objetos de String. Puede utilizar un método similar al usado para ordenar una matriz de cadenas en orden inverso, mostrado antes. (Consulte Ordene una matriz de cadenas de manera inversa para conocer detalles acerca de Comparator.) He aquí una manera de implementar un comparador para String que ignore las diferencias entre mayúsculas y minúsculas. // Crea un Comparator que devuelve el resultado // de una comparación no sensible a mayúsculas y minúsculas. class CompIgnMayMin implements Comparator<String> { // Implementa el método compare( ) para que ignore las // diferencias entre mayúsculas y minúsculas cuando compare cadenas. public int compare(String cadA, String cadB) { return cadA.compareToIgnoreCase(cadB); } }

Observe que compare( ) llama al método compareToIgnoreCase( ) de String para comparar dos cadenas. Este método ignora las diferencias entre mayúsculas y minúsculas cuando compara dos cadenas. A continuación se muestra la forma general de compareToIgnoreCase( ): int compareToIgnoreCase(String cad) Devuelve menos de cero si la cadena de invocación es menor que cad, más de cero si es mayor y cero si son iguales. El método compare( )devuelve el resultado de la llamada a compareToIgnoreCase( ). Por tanto, se ignoran las diferencias entre las dos cadenas que se están comparando. Una vez que ha creado un comparador no sensible a diferencias entre mayúsculas y minúsculas, se crea un objeto de ese comparador y se pasa a esta versión de sort( ) definida por java.util.Arrays: static void sort(T[ ] matriz, Comparator comp) Después de llamar a sort( ), la matriz estará en verdadero orden alfabético, con las diferencias entre mayúsculas y minúsculas ignoradas.

Ejemplo En el siguiente ejemplo se ignoran las diferencias entre mayúsculas y minúsculas cuando se ordena una matriz de cadenas. Para fines de demostración, también se ordenan utilizando el orden predeterminado. // Ordena una matriz de cadenas, ignora la diferencia // entre mayúsculas y minúsculas. import java.util.*;

20

Java: Soluciones de programación // Crea un Comparator que devuelve el resultado // de una comparación no sensible a mayúsculas y minúsculas. class CompIgnMayMin implements Comparator<String> { // Implementa el método compare( ) para que ignore las // diferencias entre mayúsculas y minúsculas cuando compare cadenas. public int compare(String cadA, String cadB) { return cadA.compareToIgnoreCase(cadB); } } // Demuestra el comparador de cadenas que es insensible a // diferencias entre mayúsculas y minúsculas. class OrdIgnMayMin { public static void main(String args[ ]) { // Crea una matriz simple de cadenas. String cads[ ] = { "alfa", "Gama", "Zeta", "beta", }; // Muestra el orden inicial. System.out.print("Orden inicial: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); // Ordena la matriz pero ignora las diferencias entre // mayúsculas y minúsculas. Crea un comparador de // cadenas que no es sensible a mayúsculas y minúsculas. CompIgnMayMin cimm = new CompIgnMayMin( ); // Ordena las cadenas usando el comparador. Arrays.sort(cads, cimm); // Muestra el orden no sensible a mayúsculas y minúsculas. System.out.print("Orden insensible a may\u00a3sculas y min\u00a3sculas: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); // Para comparación, ordena las cadenas en el orden predeterminado, // que es sensible a diferencias entre mayúsculas y minúsculas. Arrays.sort(cads); // Muestra el orden sensible a mayúsculas y minúsculas. System.out.print("Orden predeterminado, sensible a diferencias: "); for(String s : cads) System.out.print(s + " "); System.out.println("\n"); } }

A continuación se muestra la salida de este programa. Observe que el orden predeterminado coloca las mayúsculas antes que las minúsculas, lo que a menudo da un orden insatisfactorio. Empleando el comparador IgnoreCaseComp se corrige este problema.

Capítulo 2:


21

(N del T. Observe también la inclusión de la secuencia de escape \u00a3, que se utiliza para desplegar la "ú" en pantalla). Orden inicial: alfa Gama Zeta beta Orden insensible a mayúsculas y minúsculas: alfa beta Gama Zeta Orden predeterminado, sensible a diferencias en mayúsculas y minúsculas: Gama Zeta alfa beta

Opciones Aunque el método compareToIgnoreCase( ) funciona bien en muchos casos (como cuando se comparan cadenas en inglés), no funcionara para todos los idiomas. Para asegurar un pleno soporte internacional, debe usar el método compare( ) especificado por java.text.Collator. Se muestra a continuación: int compare(String cadA, String cadB) Devuelve menos de cero si la cadena de invocación es menor que cad, más de cero si es mayor y cero si son iguales. Usa el orden de intercalación estándar definido por el idioma local. Puede obtener un Collator para el idioma local al llamar a su método de fábrica getInstance( ). A continuación, se establece el nivel de fuerza del intercalador para que sólo se usen las diferencias primarias entre caracteres. Esto se hace al llamar a setStrenght( ), pasando Collator.PRIMARY como argumento. Empleando este método, es posible reescribir CompIgnMayMin de la siguiente manera: // Este Comparator usa un Collator para determinar // el orden lexicográfico apropiado, insensible a mayúsculas // y minúsculas de dos cadenas. class CompIgnMayMin implements Comparator<String> { Collator col; CompIgnMayMin( ) { // Obtiene un Collator para este idioma. col = Collator.getInstance( ); // Sólo tiene que considerar diferencias primarias. col.setStrength(Collator.PRIMARY); } // Usel el método compare( ) de Collator para comparar cadenas. public int compare(String cadA, String cadB) { return col.compare(cadA, cadB); } }

Si sustituye esta versión en el ejemplo, producirá los mismos resultados que antes. Sin embargo, ahora funcionará de una manera independiente del idioma local. NOTA

En algunas situaciones, cuando use Collator, tal vez le resulte útil la clase java.text.CollationKey.

22


Ignore las diferencias entre mayúsculas y minúsculas cuando busque o reemplace subcadenas Componentes clave Clases

Métodos

Java.lang.String

boolean matches(String expReg) String replaceAll(String expReg, String, cadReem)

String contiene varios métodos que le permiten buscar una subcadena específica en una cadena. Por ejemplo, puede usar contains( ), indexOf( ), lastIndexOf( ), startsWith( ) o endsWith( ), dependiendo de sus necesidades. Sin embargo, en todos éstos, la búsqueda se realiza de manera sensible a mayúsculas y minúsculas. Por tanto, si está buscando la subcadena "el" en la cadena "El cielo es azul", la búsqueda fallará. Esto representa un problema en muchas situaciones de búsqueda. Por fortuna, String le ofrece una manera fácil de realizar búsquedas de un modo insensible a mayúsculas y minúsculas mediante el uso del método matches( ) y expresiones regulares. El reemplazo de una subcadena de manera insensible a la diferencia entre mayúsculas y minúsculas se encuentra relacionado con la búsqueda bajo las mismas condiciones. String proporciona dos métodos que reemplazan una subcadena con otra. El primero es replace( ), que se usa para reemplazar un carácter con otro, o una subcadena con otra. Sin embargo, funciona de una manera sensible a la diferencia entre mayúsculas y minúsculas. Para realizar una búsqueda que no sea sensible, puede utilizar el método replaceAll( ). Reemplaza todas las apariciones de cadenas que coinciden con una expresión regular. Por tanto, puede usarse para realizar operaciones de búsqueda y reemplazo que ignoren las diferencias entre mayúsculas y minúsculas.

Paso a paso Para buscar o reemplazar una subcadena de una manera que no sea sensible a las diferencias entre mayúsculas y minúsculas, se requieren estos dos pasos: 1. Construya una expresión regular que especifique la secuencia de caracteres que está buscando. Anteceda la secuencia con la marca para ignorar diferencias entre mayúsculas y minúsculas (?!). Esto hace que se encuentren coincidencias independientemente de las mayúsculas y minúsculas. 2. Para buscar el patrón, llame a matches( ), especificando la expresión regular. Como opción, para reemplazar todas las apariciones de una subcadena con otra, llame a replaceAll( ), especificando la expresión regular y el reemplazo.

Análisis Es muy fácil crear una expresión regular que coincida con una subcadena específica, pero que ignore las diferencias entre mayúsculas y minúsculas. Sólo anteceda la secuencia de caracteres deseada con la marca para ignorar esas diferencias, (?i). Por ejemplo, para buscar la secuencia "esta" de manera insensible a mayúsculas y minúsculas, usaría este patrón: (?i)esta. Esto encontrará, por ejemplo, "esta", "Esta" y "ESTA". También encontrará "cesta", porque no existe

Capítulo 2:


23

el requisito de que se busque "esta" como una palabra separada. Para encontrar sólo palabras completas, usaría esta expresión: \b(?i)esta\b. Una vez que haya definido el patrón insensible a las diferencias entre mayúsculas y minúsculas, puede llamar a matches( ) para determinar si alguna secuencia de caracteres coincide con ese patrón. Aquí se muestra su forma general: boolean marches( )String expReg) Devuelve verdadero si se encuentra una secuencia que coincide con expReg en la cadena que se invoca y falso, de lo contrario. Por ejemplo, esta llamada a matches( ) devuelve verdadero: "Las aguas son profundas".matches("(?i)las.* ");

Debido a que la literal "las" está antecedida por (?i), coincidirá con "Las" en la cadena que se invoca. Las diferencias entre mayúsculas y minúsculas se ignoran. Sin el uso de (?i), la búsqueda fallaría debido a las diferencias entre "las" y "Las". El método matches( ) lanzará una excepción PatternSyntaxException si expReg no es válida. Puede reemplazar todas las apariciones de una subcadena con otra al llamar a replaceAll( ). Aquí se muestra su forma general: String replaceAll(String expReg, String, cadReem) Devuelve una nueva cadena en que todas las apariciones del patrón especificado por expReg en la cadena que se invoca se han reemplazado con cadReem. Si especifica la marca para ignorar diferencias entre mayúsculas y minúsculas cuando se construye la expReg, entonces se ignorarán esas diferencias. Por ejemplo, suponga que cad contiene la siguiente cadena (nótese que obviamos la inclusión de escapes para los caracteres con acento): ¿Qué día es hoy? ¿Es viernes? Entonces la siguiente llamada reemplaza todas las apariciones de "es" con "fue": cad.replaceAll("(?i)es", "fue");

La cadena resultante es: ¿Qué día fue hoy? ¿Fue viernes? El método replaceAll( ) también lanzará una PatternSyntaxException si expReg no es válida.

Ejemplo En el siguiente ejemplo se muestra cómo buscar y reemplazar de una manera que no sea sensible a las diferencias entre mayúsculas y minúsculas: // Ignora las diferencias entre mayúsculas y minúsculas cuando se // buscan subcadenas para reemplazo. class DemoIgnMayMin { public static void main(String args[ ]) { String cad = "Se trata de una PRUEBA."; System.out.println("Ignora may\u00a3sculas y min\u00a3sculas al buscar.\n" + "Buscando ‘prueba’ en: " + cad);

24

Java: Soluciones de programación // Usa matches( ) para encontrar cualquier versión de prueba. if(cad.matches("(?i).*prueba.*")) System.out.println("prueba se encuentra en la cadena."); System.out.println( ); cad = "alfa beta, Alfa beta, alFa beta, ALFA beta"; // Usa replaceAll( ) para ignorar las diferencias entre mayúsculas // y minúsculas cuando se reemplaza una subcadena con otra. // En este ejemplo, se reemplazan todas las versiones de alfa con zeta. System.out.println("Ignora may\u00a3sculas y min\u00a3sculas al reemplazar.\n" + "Reemplaza cualquier versi\u00a2n de ‘alfa’ " + "con ‘zeta’ en:\n" + " " + cad); String resultado = cad.replaceAll("(?i)alfa", "zeta"); System.out.println("Luego del reemplazo:\n" + " " + resultado); } }

Aquí se muestra la salida: Ignora mayúsculas y minúsculas al buscar. Buscando ‘prueba’ en: Se trata de una PRUEBA. prueba se encuentra en la cadena. Ignora mayúsculas y minúsculas al reemplazar. Reemplaza cualquier versión de ‘alfa’ con ‘zeta’ en: alfa beta, Alfa beta, alFa beta, ALFA beta Luego del reemplazo: zeta beta, zeta beta, zeta beta, zeta beta

Como un punto de interés hay que señalar que, debido a que las expresiones regulares se encuentran dentro del código de este ejemplo y se sabe que son válidas sintácticamente, no hay necesidad de capturar una PatternSyntaxException, porque no ocurrirá ninguna excepción. (Es el mismo caso de otros varios ejemplos de este capítulo). Sin embargo, en su propio código, tal vez necesite manejar este posible error. Esto resulta especialmente cierto si las expresiones regulares se construyen en tiempo de ejecución, como sucede a partir de la entrada del .

Opciones Aunque matches( ) ofrece el poder y la elegancia de usar una expresión regular, no es la única manera de buscar una cadena de manera insensible a las diferencias entre mayúsculas y minúsculas. En algunas situaciones tal vez pueda usar esta versión del método regionMatches( ): boolean regionMatches(boolean ignMayMin, int inicio, String cad2, int inicio2, int numCars) Si ignMayMin es verdadero, entonces la búsqueda ignora las diferencias entre mayúsculas y minúsculas. El punto inicial de la búsqueda en la cadena que se invoca se especifica con inicio. El punto de partida de la búsqueda en la segunda cadena se pasa en inicio2, la segunda cadena se especifica con cad2 y el número de caracteres para comparar se especifica con numCars. Por supuesto, regionMatches( ) sólo compara las partes especificadas de las dos cadenas, pero eso bastará para algunas necesidades.

Capítulo 2:


25

Otra manera de ignorar las diferencias entre mayúsculas y minúsculas cuando se busca una subcadena consiste en convertir primero ambas cadenas a minúsculas (o mayúsculas, según lo elija). Luego, llame a contains( ) para determinar si la cadena contiene la subcadena. En general, este método es menos atractivo que usar un patrón insensible a las diferencias entre mayúsculas y minúsculas con matches( ). Sin embargo, podría ser una buena elección si tiene otra razón para convertir las cadenas a sólo mayúsculas o sólo minúsculas. Por ejemplo, si la cadena que se buscará contiene una serie de comandos de base de datos, entonces normalizar las cadenas podría simplificar otras partes de su programa. Si sólo quiere reemplazar la primera aparición de un patrón, use replaceFirst( ) en lugar de replaceAll( ). Aquí se muestra cómo: String replaceFirst(String expReg, String cadReem) La primera secuencia en la cadena que se invoca y que coincida con regExp se reemplazará con cadReem. Se lanzará una PatternSyntaxException si expReg no es válida. También es posible usar la API de expresiones regulares de Java para realizar una búsqueda y reemplazo que no sea sensible a las diferencias entre mayúsculas y minúsculas.

Divida una cadena en partes empleando split( ) 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 especificados 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 especifique 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 especifique 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 define 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 cadenas que contiene las piezas.

26


Análisis El método split( ) definido 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 especifica los delimitadores que terminan una subcadena. (La primera subcadena está delimitada por el principio de la cadena. La subcadena final está delimitada por el final 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á especificada 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á definiendo el patrón que separa una subcadena de otra. No está especificando 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 final "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 final 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[ ]; // Divide en los espacios.

Capítulo 2:


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 [email protected]"; 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 [email protected] Permite que y @ sean parte de una palabra: Jerry| [email protected]| Cadena original: Se! trata, de. una:; prueba? Dividida en signos de puntuación: Se|trata|de|una|prueba|

27

28


Opciones Aunque el método split( ) es muy poderoso, le falta un poco de flexibilidad. 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 sofisticadas, éste no es siempre el mejor método. Más aún, habrá ocasiones en que quiera dividir en fichas 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 fichas 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 especifica 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.

Recupere pares clave/valor de una cadena 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.

Capítulo 2:


29

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 final 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 especificar 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 especificar 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 final 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 final 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 difiere, 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 definido por el programa. obtenerParesCV( ) devuelve una matriz de parCV. El método obtenerParesCV( ) le permite especificar las expresiones regulares que definen 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 definida 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;

30

Java: Soluciones de programación 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

Capítulo 2:


// 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); } }

31

32

Java: Soluciones de programación Aquí se muestra la salida: Cadena Clave: Clave: Clave: Clave:

clave/valor: Nombre = Juan, Edad = 27, NumID = 1432, Sueldo = 37.25 Nombre Valor: Juan Edad Valor: 27 NumID Valor: 1432 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 fichas. En algunos casos, sería más fácil (o más conveniente) dividir en fichas el flujo 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 fichas una cadena empleando la API de expresiones regulares, para conocer más detalles acerca de la división en fichas.

Compare y extraiga subcadenas empleando la API de expresiones regulares Componentes clave Clases

Métodos

java.util.regex.Pattern

Pattern.compile(String expReg) Matcher matcher(CharSequence cad)

java.util.regex.Matcher

boolean find( ) String group( )

Aunque el soporte de String a expresiones regulares es muy útil, no proporciona a todas las características soportadas por la API de expresiones regulares. Hay ocasiones en que necesitará usar directamente la API de expresiones regulares. En tales ocasiones querrá obtener una subcadena que busque coincidencias de un patrón general. Por ejemplo, suponga que tiene una cadena que contiene una lista de la información para ponerse en o con los empleados de una empresa, que incluye números telefónicos y direcciones de correo electrónico. Más aún, suponga que quiere extraer las direcciones de correo electrónico de esta cadena. ¿Cómo realiza esto? Aunque la API de Java ofrece varias maneras de resolver este problema, la más sencilla consiste en usar las clases Pattern y Matcher definidas por la API de expresiones regulares. En esta solución se muestra cómo completar esta tarea.

Paso a paso Para obtener una subcadena que busca coincidencias de una expresión regular se requieren los siguientes pasos:

Capítulo 2:


33

1. Cree una instancia de Pattern al llamar a su método de fábrica compile( ). Pase a compile( ) la expresión regular que describe el patrón que está buscando. 2. Cree un Matcher que contiene la cadena de entrada al llamar a matcher( ) en el objeto Pattern. 3. Llame a find( ) en Matcher para buscar una coincidencia. Devuelve verdadero si se encuentra la secuencia, y falso si no. 4. Si find( ) tiene éxito, llame a group( ) en Matcher para obtener la secuencia coincidente.

Análisis La clase Pattern no define constructores. En cambio, se crea un patrón al llamar el método de fábrica compile( ). Aquí se muestra la forma usada en esta solución: static Pattern compile(String expReg) Aquí, expReg es la expresión regular que quiere encontrar. El método compile( ) transforma expReg en un patrón que la clase Matcher puede usar para buscar coincidencias de patrones. Devuelve un objeto Pattern que contiene el patrón. Si expReg especifica una expresión no válida, se lanza una PatternSyntaxException. Una vez que haya creado un objeto de Pattern, lo usará para crear uno de Matcher. Matcher no tiene constructores. En cambio, se crea un objeto de Matcher al llamar al método de fábrica matcher( ) definido por Pattern. Aquí se muestra: Matcher matcher(CharSequence cad) Aquí, cad es la secuencia de caracteres contra la que se comparará el patrón. CharSequence es una interfaz que define un conjunto de caracteres de sólo lectura. Está implementado por la clase String, entre otras. Por tanto, puede pasar una cadena a matcher( ). Para determinar si una subsecuencia de la secuencia de entrada coincide con el patrón, se llama a find( ) en Matcher. Tiene dos versiones; la que usamos aquí es: boolean find( ) Devuelve verdadero si hay una secuencia coincidente y falso, de otra manera. A este método se le puede llamar varias veces, lo que le permite encontrar todas las secuencias coincidentes. Cada llamada a find( ) empieza donde se deja la anterior. Para obtener la cadena que contiene la coincidencia actual, se llama a group( ). La forma usada aquí es: String group( ) Se devuelve la cadena coincidente. Si no existe una coincidencia, entonces se lanza una IllegalStateException.

Ejemplo Con el siguiente programa se muestra un ejemplo que extrae direcciones de correo electrónico de la forma nombre@XYZ de una cadena que contiene información para ponerse en o con los empleados de una empresa imaginaria llamada XYZ. // Extrae una subcadena al buscar coincidencias de una expresión regular. import java.util.regex.*; class UsaExpReg { public static void main(String args[ ]) {

34

Java: Soluciones de programación // Crea una instancia de Pattern cuya expresión regular // coincide con direcciones de correo electrónico de // cualquier empleado de XYZ.com. Pattern pat = Pattern.compile("\\b\\w+@XYZ\\.com\\b"); // Crea un Matcher para el patrón. Matcher mat = pat.matcher("Informaci\u00a2n de o de la empresa\n" + "Juan 555–1111 [email protected]\n" + "Martha 555–2222 [email protected]\n" + "Daniel 555–3333 [email protected]"); // Encuentra y despliega todas las direcciones de correo electrónico. while(mat.find( )) System.out.println("Coincidencia: " + mat.group( )); } }

A continuación se muestra la salida: Coincidencia: [email protected] Coincidencia: [email protected] Coincidencia: [email protected]

Opciones Puede habilitar coincidencias insensibles a diferencias entre mayúsculas y minúsculas empleando esta forma de compile( ). static Pattern compile(String expReg, int opciones) Aquí, expReg es la expresión regular que describe el patrón y opciones contiene uno o más de los siguientes valores (definidos por Pattern): CASE_INSENSITIVE

CANON_EQ

COMMENTS

DOTALL

LITERAL

MULTILINE

UNICODE_CASE

UNIX_LINES

Excepto por CANON_EQ, estas opciones tienen el mismo efecto que las marcas correspondientes de expresiones regulares, como (?i), descritas antes en este capítulo. (No hay una marca correspondiente de expresión regular para CANON_EQ.) Para coincidencias insensibles a diferencias entre mayúsculas y minúsculas, pase CASE_INSENSITIVE a opciones. Puede obtener el índice de la coincidencia correspondiente dentro de la cadena de entrada al llamar a start( ). El índice uno pasado al final de la coincidencia actual se obtiene al llamar a end( ). Aquí se muestran estos métodos: int start( ) int end( ) Ambos lanzan una IllegalStateException si no se ha tenido ninguna coincidencia. Esta información es útil si quiere eliminar la coincidencia de la cadena, por ejemplo. Dividir en fichas una cadena es una tarea de programación que casi cualquier programador enfrentará en un momento u otro. Dividir en fichas es el proceso de reducir una cadena a sus partes individuales, que se denominan fichas. Por tanto una ficha representa el elemento indivisible más pequeño que puede extraerse de una cadena y que tiene algún significado.

Capítulo 2:


35

Divida en fichas una cadena empleando la API de expresiones regulares Componentes clave Clases

Métodos

java.util.regex.Pattern

Pattern.compile(String expReg) Matcher matcher(CharSequence cad)

java.util.regex.Matcher

boolean find( ) String group( ) Matcher usePattern(Pattern, patron)

Por supuesto, lo que constituye una ficha depende del tipo de entrada que se está procesando, y del propósito. Por ejemplo, cuando se divide en fichas una cadena que contiene texto, las partes individuales son palabras, signos de puntuación y números. Cuando se dividen los elementos de un programa, las partes incluyen palabras clave, identificadores, operadores, separadores, etc. Cuando se divide un flujo de datos que contiene información de bolsa de valores, las fichas podrían ser el nombre de la empresa, su precio actual y se relación P/E. El punto clave es que habrá de cambiar lo que constituye una ficha, dependiendo de la circunstancia. Es posible dividir una cadena en fichas con dos métodos básicos. El primero se basa en definir los delimitadores que separan una ficha de la otra. Este método suele ser útil cuando se divide en fichas un flujo de datos que usa un formato fijo. Por ejemplo, los datos accionarios en tiempo real podrían estar disponibles en la siguiente forma: nombre, precio, relación P/E | nombre, precio, relación P/E | ... Aquí, los datos están en un formato fijo en que cada fragmento de información de la compañía está separado del siguiente por una barra vertical, y los valores asociados con cada empresa están separados de los demás por comas. En este caso, pude usar el método aplit( ) definido por String para reducir esa cadena en sus fichas individuales al especificar ",|" como el conjunto de delimitadores. Sin embargo, no siempre es apropiado o conveniente un método basado en un delimitador. En algunos casos lo que constituye un delimitador variará de un caso a otro dentro de la misma cadena. Los programas de cómputo son un ejemplo importante de esto. Por ejemplo, dado este fragmento hecho = long <= (12/puerto23);

¿Cuál conjunto de delimitadores dividirá esta cadena en sus fichas individuales? Evidentemente, no puede usar espacios en blanco, porque 12 no está separado de /, aunque ambos constituyen fichas individuales. Además, el identificador puerto23 contiene letras y dígitos, de modo que no es válido especificar dígitos como delimitadores. Más aún, los operadores =, <= y / deben devolverse como fichas, lo que significa que no pueden usarse como delimitadores. En general, lo que separa a una ficha de otra se basa en la sintaxis y la semántica del programa, no en un formato fijo. Cuando se enfrenta este tipo de situación de división en fichas, debe usarse el segundo método. En lugar de dividir en fichas con base en delimitadores, el segundo método extrae cada ficha con base en el patrón con el que coincide. Por ejemplo, cuando se divide un programa, un identificador típico buscará coincidencias de un patrón que empieza con una letra o un carácter de

36

Java: Soluciones de programación subrayado y es seguido por otras letras, dígitos o líneas de subrayado. Un comentario coincidirá con un patrón que inicia con // y termina con el final de línea, o que empieza con /* y termina con */. Un operador coincidirá con un patrón de operador, que puede definirse para que incluya operadores de un solo carácter (como +) y de varios caracteres (como +=). La ventaja de esta técnica es que no es necesario que las fichas se presenten en algún orden predefinido ni estén separadas por un conjunto fijo de delimitadores. En cambio, las fichas se identifican con el patrón con el que coinciden. Este es el método que se usará en esta solución. Como verá, es flexible y muy adaptable. La división en fichas es una tarea tan importante que Java le proporciona amplio soporte integrado. Por ejemplo, proporciona tres clases especialmente diseñadas para este fin: StreamTokenizer, Scanner y la obsoleta StringTokenizer. Más aún (como ya se mencionó), la clase String contiene el método split( ), que también puede usarse para división en fichas en ciertas situaciones simples. Aunque estas clases son útiles en sí mismas, son más útiles para la división en fichas de una cadena que está definida a partir de delimitadores. Para dividir en fichas con base en patrones, por lo general encontrará que la API de expresiones regulares de Java es una mejor opción. Éste es el método empleado por la solución de esta sección. Al usar la API de expresiones regulares, obtendrá control directo y detallado de los procesos de división en fichas. Además, la implementación de un divisor mediante el empleo de las clases Pattern y Matcher proporciona una solución elegante que es clara y fácil de comprender.

Paso a paso Para dividir en fichas una cadena basada en patrones mediante el uso de la API de expresiones regulares, se requieren los siguientes pasos: 1. Cree un conjunto regular de expresiones que defina los patrones que utilizará para la búsqueda. Cada tipo de ficha que quiera obtener debe representarse con un patrón. Para permitir que el motor de expresiones regulares recorra progresivamente la cadena, empiece cada patrón con el especificador de límite \G. Esto requiere que la siguiente coincidencia empiece en el punto en que terminó la anterior. 2. Compile los patrones en los objetos de Pattern empleando Pattern.compile( ). 3. Cree un Matcher que contenga la cadena que habrá de dividirse en fichas. 4. Obtenga la siguiente ficha al adaptar el siguiente algoritmo: mientras(patrones fijos a probarse) { Especifique el patrón que se buscará al llamar a usePattern( ) en el Matcher. Busque el patrón al llamar a find( ) en el Matcher Si se encuentra una coincidencia, se obtiene una ficha De otra manera, se prueba el siguiente patrón. } A menudo, las patrones deben probarse en un orden específico. Por tanto, cuando implemente este algoritmo, debe probar cada patrón en el orden correcto. 5. Una vez que se haya encontrado una ficha, obténgala al llamar a group( ) en el Matcher. 6. Repita los pasos 4 y 5 hasta que se alcance el final de la cadena.

Capítulo 2:


37

Análisis El procedimiento básico con el fin de crear un Pattern y un Matcher y para usar find( ) y group( ) a fin de buscar una cadena se describió en la solución anterior (Compare y extraiga subcadenas empleando la API de expresiones regulares), y ese análisis no se repetirá aquí. En cambio, nos concentraremos en los dos elementos clave que permiten que una cadena se divida en fichas. El primero es la definición del conjunto de patrones que describe a las fichas. El segundo es usePattern( ), que cambia el patrón que se busca. La clave para usar la API de expresiones regulares con el fin de dividir en fichas una cadena es el comparador de límite \G. Al empezar el patrón con éste, cada coincidencia deben empezar precisamente donde se dejó la anterior. (En la primera coincidencia, \G coincidirá con el principio de la cadena). Empleando este mecanismo, puede llamarse varias veces al método find( ) en un Matcher. Cada coincidencia posterior empezará donde terminó la anterior. Esto permite que el motor de expresiones regulares recorra la cadena, sin que omita alguna ficha en el proceso. He aquí algunos ejemplos de expresiones regulares que coinciden con palabras, signos de puntuación, espacios en blanco y números. Coincidencias

Patrón

Palabras

\G\p{Alpha}+

Signos de puntuación

\G\p{Punct}

Espacio en blanco

\G\s+

Números

\G\d+\.?\d*

En cada caso, la ficha que habrá de buscarse debe empezar inmediatamente después de la coincidencia anterior. Por ejemplo, dada esta cadena Salta una, no 2, veces Primero, "Salta" coincide con el patrón de palabra. El siguiente patrón que se encontrará es el espacio en blanco, porque es el único patrón que puede seguir a la coincidencia anterior. A continuación, "una", es encontrada por el patrón de palabra, una vez más porque es el único patrón que puede seguir a la coincidencia anterior. El patrón de signo de puntuación coincidirá después con la coma, el patrón de palabra coincidirá con "no", el patrón de número con "2", etc. Un punto clave es que debido a que cada patrón debe empezar al final del anterior, no se omitirá ninguna ficha cuando el motor de expresiones regulares trate de encontrar una coincidencia. Por ejemplo, después de que se ha encontrado "Salta", fallará un intento de encontrar un número porque "2" no se encuentra inmediatamente después de esta coincidencia. Con el fin de habilitar un Matcher para que use diferentes patrones, usará el método usePattern( ). Este método cambia el patrón sin restablecer todo el Matcher. Aquí se muestra: Matcher usePattern(Pattern expReg) El patrón que habrá de usarse es especificado por expReg. Cuando se trata de obtener la siguiente ficha, el orden en que se prueban los patrones es importante. Por ejemplo, considere estos dos patrones: \G[<>=!] \G((<=)|(>=)|(==)(!=))

38

Java: Soluciones de programación El primer patrón coincide con los operadores de un solo carácter <, >, = y !; el segundo con <=, >=, == y !=, que son los operadores de dos caracteres. Para dividir correctamente en fichas una cadena que contiene ambos tipos de operadores, debe primero buscar los operadores de dos caracteres y luego los de uno. Si invierte este orden, cuando se encuentre <= se recuperarán < y = como dos fichas individuales, en lugar de una sola.

Ejemplo En el siguiente programa se pone en práctica el análisis anterior. Divide en fichas una cadena en sus componentes textuales: palabras, números o signos de puntuación. Aunque se trata de un ejemplo simple, ilustra las técnicas básicas empleadas para dividir en fichas cualquier tipo de entrada. // Un divisor simple para texto. import java.util.regex.*; class DivisorSimpleDeTexto { // Crea patrones que coinciden con texto simple. static Pattern fin = Pattern.compile("\\G\\z"); static Pattern palabra = Pattern.compile("\\G\\w+"); static Pattern punt = Pattern.compile("\\G\\p{Punct}"); static Pattern espacio = Pattern.compile("\\G\\s"); static Pattern numero = Pattern.compile("\\G\\d+\\.?\\d*"); // Este método devuelve la siguiente ficha recuperada del // Matcher pasado a mat. static String obtenerFichaTexto(Matcher mat) { // Primero, omite los espacios iniciales. mat.usePattern(espacio); mat.find( ); // // // // // //

Luego, obtiene la siguiente ficha de la cadena al tratar de encontrar cada patrón. Se devuelve la ficha encontrada por el primer patrón coincidente. Es importante el orden en que se prueban los patrones. Si se revisa una palabra antes que un número, podrían cambiar los resultados.

// Primero, se busca un número. mat.usePattern(numero); if(mat.find( )) return mat.group( ); // Si no hay un número, se busca una palabra. mat.usePattern(palabra); if(mat.find( )) return mat.group( ); // Si no hay una palabra, se busca un signo de puntuación. mat.usePattern(punt); if(mat.find( )) return mat.group( ); // Por último, se busca el final de la cadena. mat.usePattern(fin); if(mat.find( )) return "";

Capítulo 2:


// No se reconoce una ficha. return null; // ficha no válida } // Demuestra la división en fichas. public static void main(String args[ ]) { String ficha; // Crea un Matcher. Matcher mat = fin.matcher("La primera herramienta es un martillo," + " con un costo de $132.99."); // Despliega las fichas de la cadena. do { ficha = obtenerFichaTexto(mat); if(ficha == null) { System.out.println("Ficha no v\u00a0lida"); break; } if(ficha.length( ) != 0) System.out.println("Ficha: " + ficha); else System.out.println("Final de la cadena"); } while(ficha.length( ) != 0); } }

Este programa produce la siguiente salida: Ficha: La Ficha: primera Ficha: herramienta Ficha: es Ficha: un Ficha: martillo Ficha: , Ficha: con Ficha: un Ficha: costo Ficha: de Ficha: $ Ficha: 132.99 Ficha: . Final de la cadena

DivisorSimpleDeTexto empieza por definir varios patrones que pueden usarse para dividir en fichas texto en español (sin acentos), números o signos de puntuación. Tome nota de que cada patrón empieza con \G. Esto impone que cada patrón empiece donde se quedó la coincidencia anterior. Además, tome nota de que el patrón de palabra se especifica empleando \w. Por tanto, puede coincidir con letras y dígitos. En un momento verá por qué esto es importante.

39

40

Java: Soluciones de programación A continuación está el método obtenerFichaTexto( ). Aquí es donde tiene lugar la división en fichas. Al parámetro mat de obtenerFichaTexto( ) se le pasa un Matcher que contiene la cadena que habrá de dividirse. Empleando este Matcher, se trata de encontrar la siguiente ficha de la cadena. Se hace esto al omitir primero los espacios en blanco iniciales. Luego, se prueba cada uno de los siguientes patrones en secuencia. Esto se hace al establecer primero el patrón empleado por mat al llamar a usePattern( ). Luego se llama a find( ) en mat. Recuerde que find( ) devuelve verdadero cuando encuentra una coincidencia, y falso si no la halla. Por tanto, si el primer patrón falla, se prueba el siguiente, etc. Se devuelve la ficha encontrada por el primer patrón. Si se encuentra el final de la cadena, entonces se devuelve una cadena de longitud cero. Si no se encuentran coincidencias, entonces se encontró alguna secuencia de caracteres que no es parte normal del texto en español, sin acentos, y se devuelve null. Resulta importante comprender que el orden en que se prueban los patrones puede afectar la manera en que se encuentran las fichas. En este ejemplo, el divisor prueba primero si hay coincidencias con el patrón de número antes de que prueba con palabras. Esto es necesario porque, para este ejemplo, se usó el patrón \w para definir el patrón palabra. Como sabe, la clase \w busca letras y dígitos. Por tanto, en el ejemplo, si busca palabras antes que números, entonces el número 132.99 se dividirá incorrectamente en tres fichas: 132 (palabra), un punto (puntuación) y 99 (palabra). Por eso es necesario que la primera búsqueda sea de números. Por supuesto, en este ejemplo sería posible definir el patrón palabra para que excluya dígitos y evite esto, pero estás soluciones fáciles no siempre están disponibles. Por lo general, necesitará seleccionar cuidadosamente el orden en que se prueban los patrones. Otro tema importante es que, para mayor claridad, obtenerFichaTexto( ) llama a usePattern( ) y find( ) en dos instrucciones separadas. Por ejemplo: mat.usePattern(numero); if(mat.find( )) return mat.group( );

Sin embargo, esta secuencia puede escribirse así, de manera más compacta: if (mat.usePattern(numero).find( )) return mat.group( );

Esto funciona porque usePattern( ) devuelve el Matcher con el que opera. Esta forma más compacta es común en código profesional.

Ejemplo adicional Aunque en el ejemplo anterior se muestra el mecanismo básico para la división en fichas de una cadena, no ilustra la verdadera capacidad y flexibilidad del método. Por esto, se incluye un ejemplo sustancialmente más complejo que crea un divisor de propósito general. Este divisor puede adaptarse para dividir en fichas casi cualquier tipo de cadena de entrada basada en casi cualquier tipo de ficha. El divisor de propósito general está contenido por completo dentro de una clase llamada DivisorFichas, que define varios patrones integrados. Cuatro son patrones de propósito general, que dividen una cadena en palabras, números, signos de puntuación y espacios en blanco, que son similares a los usados en el ejemplo anterior. El segundo conjunto define fichas que representan un subconjunto del lenguaje Java. (Puede agregar otros patrones, si lo desea). Se incluye una enumeración que representa el tipo de cada ficha. El tipo describe el patrón básico con el que coincide la ficha, como palabra, puntuación, operador, etc. Tanto la ficha como su tipo se devuelven cada vez que se obtiene una nueva ficha. La vinculación de una ficha con su tipo es común en todas las situaciones de división en fichas, excepto las más simples.

Capítulo 2:


41

El constructor predeterminado crea un objeto que puede dividir en fichas texto normal en español, sin acentos ni caracteres de escape. El constructor parametrizado le permite especificar una matriz de tipos de ficha que quiere que use el divisor, en el orden en que habrán de aplicarse. Por tanto, este constructor le permite adecuar de manera precisa un divisor para manejar casi cualquier tipo de cadena de entrada. Con el siguiente programa se demuestra la división en fichas de texto normal y fragmentos de programa. // // // //

Una clase divisora de propósito general. Usa el comparador de límite \G para permitir que la clase recorra la cadena de entrada de principio a fin. Puede adaptarse para dividir diferentes tipos de secuencias de entrada.

import java.util.regex.*; class DivisorFichas { // Éste es el Matcher usado por el divisor. private Matcher mat; // Aquí se definen varios patrones de fichas. Puede // agregar otros propios, si lo desea. // EOS es the patrón que describe el final // de la cadena de entrada. private static Pattern EOS = Pattern.compile("\\G\\z"); // El patrón desconocido busca un carácter para // permitir que la división en fichas avance. Por supuesto, // los s de DivisorFichas tienen la libertad de detenerla // si se encuentra una ficha desconocida. private static Pattern desconocido = Pattern.compile("\\G."); // Algunos patrones generales de fichas. private static Pattern palabra = Pattern.compile("\\G\\p{Alpha}+"); private static Pattern punt = Pattern.compile("\\G\\p{Punct}"); private static Pattern espacio = Pattern.compile("\\G\\s+"); private static Pattern numero = Pattern.compile("\\G\\d+\\.?\\d*"); // Algunos patrones relacionados con programas parecidos a Java. // Esto coincide con una palabra clave o un identificador, // que no debe empezar con un dígito. private static Pattern pcOIden = Pattern.compile("\\G[\\w&&\\D]\\w*"); // Especifica los varios separadores. private static Pattern separador = Pattern.compile("\\G[( ){}\\[\\];,.]"); // Esto busca los diversos operadores. private static Pattern opUnico = Pattern.compile("\\G[=>=)|(==)|(!=)|(\\|\\|)|" + "(\\&\\&)|(<<)|(>>)|(––)|(\\+\\+))");

42

Java: Soluciones de programación private static Pattern opAsign = Pattern.compile("\\G((\\+=)|(–=)|(/=)|(\\*=)|(<<=)|" + "(>>=)|(\\|=)|(&=)|(\\^=)|(>>>=))"); private static Pattern opTriple = Pattern.compile("\\G>>>"); // Esto busca una literal de cadena. private static Pattern literalCadena = Pattern.compile("\\G\".*?\""); // Esto busca un comentario. private static Pattern comentario = Pattern.compile("\\G((//.*(?m)$)|(/\\*(?s).*?\\*/))"); // Esta enumeración define los tipos de ficha // y asocia un patrón con cada tipo. // Si define otro tipo de ficha, entonces // la agrega a la enumeración. enum TipoFicha { // Inicializa los valores de enumeración con sus // patrones correspondientes. PALABRA(palabra), PUNT(punt), ESPACIO(espacio), NUMERO(numero), PC_O_IDENT(pcOIden), SEPARADOR(separador), OP_UNICO(opUnico), OP_DOBLE(opDoble), OP_TRIPLE(opTriple), OP_ASIGN(opAsign), LITERAL_CADENA(literalCadena), COMENTARIO(comentario), FINAL(EOS), DESCONOCIDO(desconocido); // Esto conserva el patrón asociado con cada tipo de ficha. Pattern pat; TipoFicha(Pattern p) { pat = p; } } // Esta matriz contiene la lista de fichas que este // divisor buscará, en el orden en que se realizará // la búsqueda. Por tanto, el orden de los elementos // en esta matriz es importante porque determina // el orden en que se probarán las coincidencias. TipoFicha patrones[ ]; // Cada vez que se obtiene una nueva ficha, ésta // y su tipo se regresan en un objeto de tipo Ficha. class Ficha { String ficha; // la cadena contiene la ficha TipoFicha tipo; // el tipo de la ficha } // Esto contiene la ficha actual. Ficha fichaActual;

Capítulo 2:


// Crea un DivisorFichas personalizado. Divide el texto en fichas. DivisorFichas(String cad) { mat = desconocido.matcher(cad); // Esto describe las fichas para la // división simple de texto en fichas. TipoFicha fichasTexto[ ] = { TipoFicha.NUMERO, TipoFicha.PALABRA, TipoFicha.PUNT, TipoFicha.FINAL, TipoFicha.DESCONOCIDO }; patrones = fichasTexto; fichaActual = new Ficha( ); } // Crea un DivisorFichas personalizado que coincide // con la lista de fichas dados los tipos pasados a dfp. DivisorFichas(String cad, TipoFicha dfp[ ]) { mat = desconocido.matcher(cad); // Siempre agregue FINAL y DESCONOCIDO al final // de la matriz de patrones. TipoFicha tmp[ ] = new TipoFicha[dfp.length+2]; System.arraycopy(dfp, 0, tmp, 0, dfp.length); tmp[dfp.length] = TipoFicha.FINAL; tmp[dfp.length+1] = TipoFicha.DESCONOCIDO; patrones = tmp; fichaActual = new Ficha( ); } // Este método devuelve la siguiente ficha de la // cadena de entrada. Lo que constituye una ficha // se determina con el contenido de la matriz // de patrones. Por tanto, al cambiar la matriz, // se cambia el tipo de fichas que se obtiene. Ficha obtenerFicha( ) { // En primer lugar, omite cualquier espacio en blanco inicial. mat.usePattern(espacio).find( ); for(int i=0; i<patrones.length; i++) { // Selecciona el siguiente patrón de ficha que se usará. mat.usePattern(patrones[i].pat); // Ahora, pruebe a encontrar una coincidencia. if(mat.find( )) { fichaActual.tipo = patrones[i]; fichaActual.ficha = mat.group( ); break; } }

43

44

Java: Soluciones de programación return fichaActual; // devuelve la ficha y su tipo } } // Demuestra DivisorFichas. class DemoDivisorFichas { public static void main(String args[ ]) { DivisorFichas.Ficha t; // Demuestra el texto que se dividirá en fichas. DivisorFichas divf = new DivisorFichas("Este es un texto de ejemplo. Hoy es lunes, " + " 28 de febrero de 2008"); // Lee y despliega las fichas de texto hasta que se lee // la ficha FINAL. System.out.println("Dividiendo texto en fichas."); do { // Obtiene la siguiente ficha. t = divf.obtenerFicha( ); // Despliega la ficha y su tipo. System.out.println("Ficha: " + t.ficha + "\tTipo: " + t.tipo); } while(t.tipo != DivisorFichas.TipoFicha.FINAL); // Ahora crea un divisor para un subconjunto de Java. // Recuerde que el orden importa. Por ejemplo, un // intento para buscar un doble operador, como <= // debe presentarse antes de que se haga un intento por // buscar un solo operador, como <. DivisorFichas.TipoFicha fichasProg[ ] = { DivisorFichas.TipoFicha.NUMERO, DivisorFichas.TipoFicha.PC_O_IDENT, DivisorFichas.TipoFicha.LITERAL_CADENA, DivisorFichas.TipoFicha.COMENTARIO, DivisorFichas.TipoFicha.OP_ASIGN, DivisorFichas.TipoFicha.OP_TRIPLE, DivisorFichas.TipoFicha.OP_DOBLE, DivisorFichas.TipoFicha.OP_UNICO, DivisorFichas.TipoFicha.SEPARADOR, }; // Demuestra la división en fichas de un programa. divf = new DivisorFichas("// comentario\n int count=10; if(a<=b) count––;"+ "a = b >>> c; a = b >> d; resultado = meth(3);" + "w = a<0 ? b*4 : c/2; done = !done;" + "for(int i=0; i<10; i++) sum += i;" + "String cad = \"una literal de cadena\"" + "class Prueba { /* ... */ }", fichasProg);

Capítulo 2:


// Despliega cada ficha y su tipo. System.out.println("\nDividiendo fragmentos del programa."); do { t = divf.obtenerFicha( ); System.out.println("Ficha: " + t.ficha + "\tTipo: " + t.tipo); } while(t.tipo != DivisorFichas.TipoFicha.FINAL); } }

A continuación se muestra una parte de la salida: Dividiendo texto en fichas. Ficha: Este Tipo: PALABRA Ficha: es Tipo: PALABRA Ficha: un Tipo: PALABRA Ficha: texto Tipo: PALABRA Ficha: de Tipo: PALABRA Ficha: ejemplo Tipo: PALABRA Ficha: . Tipo: PUNT Ficha: Hoy Tipo: PALABRA Ficha: es Tipo: PALABRA Ficha: lunes Tipo: PALABRA Ficha: , Tipo: PUNT Ficha: 28 Tipo: NUMERO Ficha: de Tipo: PALABRA Ficha: febrero Tipo: PALABRA Ficha: de Tipo: PALABRA Ficha: 2008 Tipo: NUMERO Ficha: Tipo: FINAL Dividiendo fragmentos Ficha: // comentario Ficha: int Tipo: Ficha: count Tipo: Ficha: = Tipo: Ficha: 10 Tipo: Ficha: ; Tipo: Ficha: if Tipo: Ficha: ( Tipo: Ficha: a Tipo: Ficha: <= Tipo: Ficha: b Tipo: Ficha: ) Tipo: Ficha: count Tipo: Ficha: –– Tipo: Ficha: ; Tipo: Ficha: a Tipo: Ficha: = Tipo: Ficha: b Tipo: Ficha: >>> Tipo: . . .

del programa. Tipo: COMENTARIO PC_O_IDENT PC_O_IDENT OP_UNICO NUMERO SEPARADOR PC_O_IDENT SEPARADOR PC_O_IDENT OP_DOBLE PC_O_IDENT SEPARADOR PC_O_IDENT OP_DOBLE SEPARADOR PC_O_IDENT OP_UNICO PC_O_IDENT OP_TRIPLE

45

46

Java: Soluciones de programación Éste es un ejemplo muy complejo y garantiza un examen a profundidad de su operación. La clase DivisorFichas define estos elementos clave: Elemento

Descripción

La variable de instancia mat

Contiene una referencia al Matcher que usará la instancia de DivisorFichas.

Varios patrones precompilados de fichas

Son los patrones que describen los diversos tipos de fichas.

La enumeración TipoFicha

Esta enumeración representa el tipo de cada ficha. También vincula a un tipo de ficha con su patrón.

La matriz patrones

Esta matriz contiene un conjunto ordenado de objetos de TipoFicha que especifican los tipos de fichas que se obtendrán. El orden de los elementos de la matriz es el orden en que DivisorFichas prueba los patrones, buscando una coincidencia.

La clase Ficha

Esta clase de conveniencia vincula la ficha actual con su tipo. Está anidada dentro de DivisorFichas. Por tanto, para hacer referencia a ella fuera de ésta, debe calificarla con DivisorFichas, como en DivorFichas.Fichas.

La variable de instancia fichaActual

Contiene una referencia a la ficha actual, que es la obtenida por la llamada más reciente a obtenerFicha( ). Es devuelta por obtenerFicha( ).

Los constructores DivisorFichas

Construyen un divisor de fichas, el constructor de un parámetro divide en fichas el texto normal en español, sin acentos. El constructor de dos parámetros permite que el divisor sea configurado para trabajar con otros tipos de entrada.

El método obtenerFicha( )

Devuelve la siguiente ficha de la cadena.

Revisemos más de cerca cada parte. En primer lugar, cada instancia de DivisorFichas tiene su propio Matcher, al que se hace referencia mediante mat. Esto significa que pueden usarse dos o más divisores de fichas dentro del mismo programa, cada uno operando de manera independiente. A continuación, observe los diversos patrones. Todas las expresiones regulares empiezan con \G, lo que significa que una secuencia coincidente debe empezar al final de la coincidencia anterior. Como ya se explicó, esto permite que el motor de expresiones regulares avance por la cadena. (Si no incluye el comparador de límite \G, entonces el motor de expresiones regulares encontrará una secuencia coincidente en cualquier lugar de la cadena, omitiendo posiblemente varias fichas en el proceso). Si agrega patrones adicionales, entonces debe estar seguro de empezar con \G. Observe los patrones que dividen en fichas un subconjunto de Java. El patrón pcOIdent coincide con palabras clave o identificadores. (No suele ser práctico distinguir entre ambos durante el proceso de división. Otras partes de un compilador o un intérprete suelen manejar esta tarea). Otros patrones coinciden con los diversos separadores u operadores. Observe que se requieren cuatro patrones diferentes para manejar los operadores, y que cada uno busca un tipo distinto de operador, incluidos los compuestos por un solo operador, por dos o por tres. Los operadores de asignación pudieran manejarse como operadores de doble carácter, pero por razones de claridad, se les dio un patrón propio. Se proporcionan también patrones que coinciden con los comentarios y las literales de cadena.

Capítulo 2:


47

Después que se han compilado los patrones, se crea la enumeración TipoFicha. Define los tipos de ficha que corresponden a los patrones y vinculan a cada patrón con su tipo. Esta vinculación muestra la capacidad de las enumeraciones de Java, que son tipos de clase más que simples listas de enteros con nombre (como lo son en varios otros lenguajes). La matriz patrones contiene una lista de objetos TipoFicha que especifican los tipos de ficha que obtendrá el divisor. El orden de los tipos en la matriz especifica el orden en que DivisorFichas buscará una ficha. Debido a que el orden en que se realiza la búsqueda puede ser importante (por ejemplo, debe buscar <= antes de <), debe cuidar el orden apropiado de la matriz. En todos los casos, las últimas dos entradas de la matriz deben ser FINAL y DESCONOCIDO. A continuación, se define la clase Ficha. Esta clase anidada no es técnicamente necesaria, pero permite que una ficha y su tipo se encapsulen dentro de un solo objeto. La variable fichaActual, que es una instancia de Ficha, contiene la ficha obtenida más recientemente. obtenerFicha( ) devuelve una referencia a ella. Desde el punto de vista técnico, fichaActual no es necesaria porque bastaría con construir un nuevo objeto de Ficha para cada ficha obtenida, y hacer que obtenerFicha( ) devuelva el nuevo objeto. Sin embargo, cuando se divida en fichas una cadena muy larga, se crearía un gran número de objetos y luego se descartarían. Esto daría como resultado ciclos adicionales de recolección de basura. Al emplear sólo un objeto de Ficha, se elimina esta posible ineficiencia. El constructor DivisorFichas de un parámetro crea un divisor que maneja el texto regular en español, sin acentos, al reducirlo a palabras, signos de puntuación y números. La cadena que habrá de dividirse en fichas se pasa al constructor. Asigna a patrones una matriz que maneja estos elementos de texto simple. El constructor de dos parámetros le permite especificar una matriz de TipoFicha que se asignará a patrones. Esto le permite configurar un divisor que manejará diferentes tipos de entrada. En DemoDivisorFichas, la matriz fichasProg se construye de tal manera que puede dividir en fichas un subconjunto de lenguaje Java. Otros tipos de división pueden crearse al especificar una matriz tipoFicha diferente. Un tema adicional: observe que este constructor siempre agrega FINAL y DESCONOCIDO a la lista de tipos de ficha. Esto es necesario para asegurar que obtenerFicha( ) encuentra el final de la cadena y que devuelve DESCONOCIDO cuando no puede encontrar ninguno de los patrones. El método obtenerFicha( ) obtiene la siguiente ficha de la cadena. Siempre lo hace correctamente porque la ficha será FINAL cuando se ha alcanzado el final de la cadena y DESCONOCIDO si no se encuentran fichas coincidentes. Tome en cuenta que obtenerFicha( ) omite cualquier espacio inicial. Por lo general, las fichas no incluyen espacios en blanco, de modo que obtenerFicha( ) simplemente los descarta. Para usar el divisor de fichas, cree primero un DivisorFichas que busque las fichas que desee. A continuación, configure un bucle que llame a obtenerFicha( ) en el divisor hasta que se llegue al final de la cadena. Cuando esto ocurre, el tipo de la ficha devuelta será EOS. En el programa, este procedimiento se demuestra con la clase DemoDivisorFichas. Una ficha desconocida puede ignorarse (como en el ejemplo) o tratarse como una condición de error.

Opciones Como se mencionó, cuando se divide en fichas con base en delimitadores, puede usar StringTokenizer (ahora obsoleto), StreamTokenizer, Scanner o el método split( ). Si su entrada puede dividirse en fichas con base en delimitadores, entonces es fácil implementar estas otras soluciones efectivas.

48

Java: Soluciones de programación Como se ha mostrado en los ejemplos anteriores, la división en fichas basada en patrones puede implementarse de manera eficiente empleando las clases Pattern y Matcher definidas por la API de expresiones regulares. Éste es el método que prefiero. Sin embargo, son posibles otras soluciones. Una opción está basada en la clase Scanner, que puede usarse para división en fichas basada en patrones al emplear su método findWithinHorizon( ) para obtener una ficha. Como se mencionó antes, por lo general Scanner se basa en delimitadores. Sin embargo, el método findWithinHorizon( ) ignora éstos y trata de encontrar una coincidencia con la expresión regular que se pasa como argumento. La coincidencia se prueba dentro de una parte especificada de la cadena de entrada, que puede ser toda la cadena, si es necesario. Aunque este método funciona, Matcher ofrece un método más simple y directo. (Por supuesto, si quiere alternar entre división basada en delimitadores y en patrones, entonces el uso de Scanner sería la solución perfecta). La división en fichas basada en patrones también puede implementarse a mano, haciendo que la cadena se revise carácter por carácter, y que las fichas se construyan carácter por carácter. Éste era el método que solía usarse antes de que se tuviera la API de expresiones regulares. Para algunos casos, aún podría ser el método más eficiente. Sin embargo, las expresiones regulares ofrecen código sustancialmente más compacto y fácil de mantener. Como opción predeterminada, se buscará una coincidencia en toda la cadena pasada a Matcher. Sin embargo, puede restringir la búsqueda a una región más pequeña al llamar a region( ), como se muestra aquí: Matcher region(int inicio, int final) El índice en que se empezará a buscar se pasa mediante inicio. La búsqueda se detiene en final–1. Puede obtener los límites de búsqueda actuales al llamar a regionStart( ) y regionEnd( ).

3

CAPÍTULO

Manejo de archivos

E

l manejo de archivos es una parte integral de casi todos los proyectos de programación. Los archivos proporcionan los medios para que un programa almacene datos, acceda a datos almacenados o comparta datos. Como resultado, hay muy pocas aplicaciones que no interactúan con un archivo en una forma u otra. Aunque ningún aspecto del manejo de archivo es particularmente difícil, interviene una gran cantidad de clases, interfaces y métodos. La marca de un profesional es la capacidad de aplicarlos efectivamente a sus proyectos. Es importante comprender que la E/S de archivos es un conjunto del sistema general de E/S de Java. Más aún, el sistema de E/S de Java es muy grande. No resulta sorprendente, puesto que da soporte a dos jerarquías distintas de clases de E/S: una para bytes y otra para caracteres. Contiene clases que permiten que una matriz de bytes, una matriz de caracteres o una cadena se use como fuente o destino de operaciones de E/S. También proporciona la capacidad de establecer u obtener varios atributos relacionados con un archivo, como su estado de lectura/escritura, si el archivo es un directorio o si está oculto. Incluso obtiene una lista de archivos dentro de un directorio. A pesar de su tamaño, el sistema de E/S de Java es sorprendentemente fácil de usar. Una razón es su diseño bien pensado. Al estructurar el sistema de E/S alrededor de un conjunto cuidadosamente creado de clases, esta API de gran tamaño se vuelve manejable. Una vez que se comprende la manera de usar las clases centrales, es fácil aprender sus capacidades más avanzadas. La consistencia del sistema de E/S hace que el código resulte fácil de mantener o adaptar, y su rica funcionalidad proporciona soluciones a casi todas las tareas de manejo. El núcleo del sistema de E/S de Java está empaquetado en java.io. Se ha incluido con Java desde la versión 1.0 y contiene las clases e interfaces que usará con más frecuencia cuando realice operaciones de E/S, incluidas las que actúan sobre archivos. Para ponerlo de manera simple, cuando necesite leer o escribir archivos, java.io es el paquete al que normalmente acudirá. Como resultado, todas las soluciones de este capítulo usan sus opciones, de una manera u otra. Otro paquete que incluye clases de manejo de archivos es java.util.zip. Las clases de java.util.zip pueden crear un archivo comprimido, o descomprimir un archivo. Estas clases se construyen sobre la funcionalidad proporcionada por las clases de E/S definidas en java.io. Por tanto, están integradas en la estrategia general de E/S. Tres soluciones demuestran el uso de la compresión de datos cuando se manejan archivos. En este capítulo se proporcionan varias soluciones que demuestran el manejo de archivos. Se empieza por describir varias operaciones fundamentales, como lectura o escritura de bytes o caracteres. Luego se demuestran varias técnicas que le ayudan a utilizar y istrar archivos.

49

50

Java: Soluciones de programación He aquí las soluciones contenidas en este capítulo: • Lea bytes de un archivo • Escriba bytes en un archivo • Use el búfer para la E/S de un archivo basada en bytes • Lea caracteres de un archivo • Escriba caracteres en un archivo • Use el búfer para la E/S de un archivo basada en caracteres • Lea y escriba archivos de aleatorio • Obtenga atributos de archivos • Establezca atributos de archivos • Elabore una lista de un directorio • Comprima y descomprima datos • Cree un archivo ZIP • Descomprima un archivo ZIP • Serialice objetos NOTA Apartir de la versión 1.4, Java empezó a proporciona un método adicional para E/S llamado NIO (New I/O, nueva E/S). Crea un método basado en canal para E/S y está empaquetado en java.nio. El sistema NIO no tiene el objetivo de reemplazar a las clases de E/S basadas en flujo que se encuentran en java.io, sino que las complementa. Debido a que el enfoque de este capítulo está puesto en la E/S basada en flujo, no se incluyen soluciones basadas en NIO. El lector interesado encontrará un análisis de NIO (y de E/S en general) en mi libro Java: The Complete Reference.

Una revisión general del manejo de archivos En Java, el manejo de archivos es simplemente un aspecto especial de un concepto más amplio debido a que la E/S de archivo está fuertemente integrada con el sistema general de E/S de Java. En general, si comprende una parte del sistema E/S, es fácil aplicar ese conocimiento a otras situaciones. Hay dos aspectos del sistema de E/S que hace posible esta característica. El primero es que el sistema de E/S de Java está construido a partir de un conjunto coherente de jerarquías de clase, por encima del cual se encuentran las clases abstractas que definen gran parte de la funcionalidad básica compartida por todas las subclases concretas específicas. El segundo aspecto es el flujo, el cual une al sistema de archivos porque todas las operaciones de E/S ocurren a través de uno. Debido a la importancia del flujo, empezaremos allí la revisión general de las capacidades de manejo de Java.

Flujos Un flujo es una abstracción que produce o consume información. Un flujo está vinculado a un dispositivo físico mediante el sistema de E/S. todos los flujos se comportan de la misma manera, aunque difieran los dispositivos reales a los que están vinculados. Por tanto las mismas clases y los mismos métodos de E/S pueden aplicarse a diferentes tipos de dispositivos. Por ejemplo, los mismos métodos que usa para escribir en la consola pueden usarse para escribir en un archivo

Capítulo 3:

Manejo de archivos

51

de disco o una conexión de red. Los flujos centrales de Java están implementados dentro de las jerarquías de clase definidas en el paquete java.io. Son los mismos flujos que usaría normalmente cuando maneja archivos. Sin embargo, algunos otros paquetes también definen flujos. Por ejemplo, java.util.zip proporciona flujos que crean y operan en datos comprimidos. Las versiones modernas de Java definen dos tipos de flujos: de bytes y de caracteres. (La versión 1.0 original de Java sólo definía flujos de bytes, pero se agregaron rápidamente los de caracteres). Los flujos de bytes proporcionan un medio conveniente para manejar entrada y salida de bytes. Se usan, por ejemplo, cuando se leen o escriben datos binarios. Resultan especialmente útiles cuando se trabaja con archivos. Los flujos de caracteres están diseñados para manejar la entrada y salida de caracteres, lo que mejora la internacionalización. El hecho de que Java defina dos tipos diferentes de flujos hace muy grande el sistema de E/S porque se necesitan dos jerarquías de clases separadas (una para bytes y otra para caracteres). La gran cantidad de clases puede hacer que los sistemas parezcan más intimidantes de lo que son en realidad. En su mayor parte, la funcionalidad de los flujos de bytes son equiparables a la de los flujo de caracteres. Otro tema interesante es que, en el nivel inferior, toda E/S aún está orientada a bytes. Los flujos basados en caracteres proporcionan medios convenientes y eficientes para manejar caracteres.

Las clases de flujo de bytes Los flujos de bytes están definidos por dos jerarquías de clase: una para entrada y otra para salida. En la parte superior de éstas se encuentran dos clases abstractas: InputStream y OutputStream. InputStream define las características comunes a los flujos de entrada de bytes, y OutputStream describe el comportamiento de los flujos de salida de bytes. Los métodos especificados por InputStream y OutputStream se muestran en las tablas 3–1 y 3–2. A partir de InputStream y OutputStream se crean varias subclases, que ofrecen funcionalidad variable. Estas clases se muestran en la tabla 3–3. Entre las clases de flujo de bytes, dos están directamente relacionadas con los archivos: FileInputStream y FileOutputStream. Debido a que son implementaciones concretas de InputStream y OutputStream, pueden usarse en cualquier lugar en que se necesite un InputStream o un OutputStream. Por ejemplo, una instancia de FileInputStream puede envolverse en otra clase de flujo de bytes, como BufferedInputStream. Ésta es una razón por la que el método de E/S basada en flujos de Java es tan poderosa: permite la creación de una jerarquía de clase completamente integrada.

Las clases de flujo de caracteres Los flujos de caracteres se definen con el uso de jerarquías de clase que son diferentes de las de flujos de bytes. Las jerarquías de flujo de caracteres tienen a la cabeza estas dos clases abstractas: Reader y Writer. Reader se usa para entrada y Writer para salida. En las tablas 3–4 y 3–5 se muestran los métodos definidos por estas clases. Las clases concretas derivadas de Reader y Writer operan en flujos de caracteres de Unicode. En general, las clases basadas en caracteres son equiparables a las clases basadas en bytes. Las clases de flujo de caracteres se muestran en la tabla 3–6. Entre las clases de flujo de caracteres, dos están directamente relacionadas con archivos: FileReader y FileWriter. Debido a que son implementaciones concretas de Reader y Writer, pueden usarse en cualquier lugar en que se necesite un lector o un escritor de archivos. Por ejemplo, una instancia de FileReader puede envolverse en un BufferedReader para incluir en búfer las operaciones de entrada.

52


Método

Descripción

int available( ) throws IOException

Devuelve el número de bytes de entrada disponibles para lectura.

void close( )throws IOException

Cierra el origen de la entrada.

void mark(int numBytes)

Coloca una marca en el punto actual en el flujo de entrada que seguirá siendo válido hasta que se lea numBytes. No todos los flujos implementan mark( ).

boolean marked( )

Devuelve verdadero si el flujo que se invoca da soporte a mark( )/reset( ).

abstract int read( ) throws IOException

Devuelve una representación de entero del siguiente byte disponible de entrada. Se devuelve –1 cando se encuentra el final del archivo.

int read(byte bufer[ ])throws IOException

Trata de leer hasta el byte bufer.length en bufer y devuelve el número real de bytes que se leyó correctamente. Se devuelve –1 cuando se encuentra el final del archivo.

int read(byte bufer[ ], int despl, int numBytes)throws IOException

Trata de leer hasta los bytes numBytes en bufer, a partir de bufer[despl], devolviendo el número de bytes que se leyó correctamente. Se devuelve –1 cuando se encuentra el final del archivo.

void reset( ) throws IOException

Restablece el apuntador de entrada a la marca establecida antes. No todos los flujos soportan reset( ).

long skip(long numBytes) throws IOException

Ignora (es decir, omite) un numBytes de bytes de entrada, regresando el número de bytes que se ignoró realmente.

Tabla 3-1 Los metodos definidos por inputstream Método

Descripción

void close( ) throws IOException

Cierra el flujo de salida.

void flush( ) throws IOException

Finaliza el estado de salida, de modo que se limpie cualquier búfer. Es decir, regenera los búferes de salida.

abstract void write(int b) throws IOException

Escribe el byte de orden inferior de b en el flujo de salida.

void write(byte bufer[ ]) throws IOException

Escribe una matriz completa de bytes en el flujo de salida.

void write(byte bufer[ ], int despl., int numBytes) throws IOException

Escribe un subrango de numBytes bytes, a partir del búfer de la matriz, empezando en el bufer[despl].

Tabla 3-2 Los métodos especificados por OutputStream

Capítulo 3:

Manejo de archivos

53

Clase de flujo de bytes

Descripción

BufferedInputStream

Flujo de entrada en búfer.

BufferedOutputStream

Flujo de salida en búfer.

ByteArrayInputStream

Flujo de entrada que se lee de una matriz de bytes.

ByteArrayOutputStream

Flujo de salida que se lee de una matriz de bytes.

DataInputStream

Un flujo de entrada que contiene métodos para leer los tipos estándar de datos de Java.

DataOutputStream

Un flujo de salida que contiene métodos para escribir los tipos estándar de datos de Java.

FileInputStream

Flujo de entrada que se lee de un archivo.

FileOutputStream

Flujo de salida que se escribe en un archivo.

FilterInputStream

Implementa InputStream y permite que se modifique (filtre) el contenido de otro flujo.

FilterOutputStream

Implementa OutputStream y permite que se modifique (filtre) el contenido de otro flujo.

InputStream

Clase abstracta que describe la entrada del flujo.

OutputStream

Clase abstracta que describe la salida del flujo.

PipedInputStream

Canalización de entrada.

PipedOutputStream

Canalización de salida.

PrintStream

Flujo de salida que contiene print( ) y println( ).

PushbackInputStream

Flujo de entrada que permite que se devuelvan bytes al flujo.

RandomAccessFile

Soporta E/S de archivo de aleatorio.

SequenceInputStream

Flujo de entrada que es una combinación de dos o más flujos de entrada que se leerán de manera secuencial, uno tras otro.

Tabla 3-3 Las clases de flujo de bytes

Una superclase de Filereader es InputStreamReader. Traduce bytes en caracteres. Una superclase de FileWriter es OutputStreamWriter. Traduce caracteres en bytes. Estas clases son necesarias porque todos los archivos están, en esencia, orientados a bytes.

La clase RandomAccessFile Las clases de flujo que acabamos de describir operan en archivos de manera estrictamente secuencial. Sin embargo, Java también le permite acceder al contenido de un archivo en orden no secuencial. Para ello, usará RandomAccessFile, que encapsula un archivo de aleatorio (o directo). RandomAccessFile no se deriva de InputStream ni de OutputStream. En cambio, implementa las interfaces DataInput y DataOutput (que se describen en breve). RandomAccessFile

54


Método

Descripción

abstract void close( ) throws IOException

Cierra el origen de la entrada.

void mark(int numCars) throws IOException

Coloca una marca en el punto actual en el flujo de entrada que seguirá siendo válido hasta que se lea el numCars de caracteres. No todos los flujos soportan mark( ).

boolean marked( )

Devuelve verdadero si el flujo da soporte a mark( )/reset( ).

int read( ) throws IOException

Devuelve una representación entera del siguiente carácter disponible desde el flujo de entrada. Se devuelve –1 cuando se alcanza el final del archivo.

int read(char bufer[ ]) throws IOException

Trata de leer hasta bufer.length caracteres en bufer y devuelve el número real de caracteres que se leyó correctamente. Se devuelve –1 cuando se alcanza el final del archivo.

abstract int read(char bufer[ ], int despl, int numCars) throws IOException

Trata de leer hasta numCars de caracteres en bufer[despl] y devuelve el número de caracteres que se leyó correctamente. Se devuelve –1 cuando se alcanza el final del archivo.

boolean ready( ) throws IOException

Devuelve verdadero si no está pendiente una entrada. De otra manera, devuelve falso.

void reset( ) throws IOException

Restablece el puntero de entrada a la marca establecida antes. No todos los flujos dan soporte a reset( ).

long skip(long numCars) throws IOException

Omite un numCars de caracteres en la entrada, devolviendo el número de caracteres que se omitió en realidad.

Tabla 3-4 Los métodos definidos por Reader

soporta aleatorio porque permite cambiar la ubicación en el archivo en que ocurrirá la siguiente operación de lectura o escritura. Esto se hace al llamar al método seek( ).

La clase File Además de las clases que dan soporte a E/S, Java proporciona la clase File, que encapsula información acerca de un archivo. Esta clase es extremadamente útil cuando se manipula un archivo (en lugar de su contenido) o el sistema de archivos del equipo. Por ejemplo, con File puede determinar si un archivo está oculto, establecer la fecha de un archivo o definirlo como de sólo lectura, hacer una lista del contenido de un directorio o crear un nuevo directorio, entre muchas otras cosas. Por tanto, File pone el sistema de archivos bajo control. Esto hace que File sea una de las clases más importantes en el sistema de E/S de Java.

Capítulo 3:

Manejo de archivos

55

Método

Descripción

Writer append(char car) throws IOException

Adjunta car al final del flujo de salida que se invoca. Devuelve una referencia al flujo.

Writer append(CharSequence cars) throws IOException

Adjunta cars al final del flujo de salida que se invoca. Devuelve una referencia al flujo.

Writer append(CharSequence cars, int inicio, int final) throws IOException

Adjunta un subrango de cars, especificada por inicio y final, hasta el final del flujo de salida. Devuelve una referencia al flujo.

abstract void close( ) throws IOException

Cierra el flujo de salida.

abstract void flush( ) throws IOException

Finaliza el estado de salida para que se limpien los búferes. Es decir, regenera los búferes de salida.

void write(int car) throws IOException

Escribe el carácter en los 16 bits de orden inferior de car en el flujo de salida.

void write(char bufer[ ]) throws IOException

Escribe una matriz completa de caracteres en el flujo de salida.

abstract void write(char bufer[ ], int despl, int numCars) throws IOException

Escribe un subrango de numCars de caracteres de la matriz bufer, empezando en bufer[despl] hasta el flujo de salida.

void write(String cad) throws IOException

Escribe cad en el flujo de salida.

void write(String cad, int despl, int numCars) throws IOException

Escribe un subrango de numCars de caracteres desde la cadena cad, empezando en el despl especificado.

Tabla 3-5 Los métodos definidos por Writer

Las interfaces de E/S El sistema de E/S de Java incluye las siguientes interfaces (que están empaquetadas en java.io). Closeable

DataInput

DataOutput

Externalizable

FileFilter

FilenameFilter

Flushable

ObjectInput

ObjectInputValidation

ObjectOutput

ObjectStreamConstants

Serializable

Los usados de manera directa o indirecta por las soluciones de este capítulo son DataInput, DataOutput, Closeable, Flushable, FileFilter, FilenameFilter, ObjectInput y ObjectOutput. Las interfaces DataInput y DataOutput definen varios métodos de lectura y escritura, como readInt( ) y writeDouble( ), que pueden leer y escribir tipos de datos primitivos de Java. También especifican métodos read( ) y write( ), que equivalen a los especificados por InputStream y OutputStream. Todas las operaciones están orientadas a bytes. RandomAccessFile implementa las interfaces DataInput y DataOutput. Por tanto, las operaciones de archivo de aleatorio en Java están orientadas a bytes.

56


Clase de flujo de caracteres

Significado

BufferedReader

Flujo de caracteres de entrada en búfer.

BufferedWriter

Flujo de caracteres de salida en búfer.

CharArrayReader

Flujo de entrada que se lee desde una matriz de caracteres.

CharArrayWriter

Flujo de salida que se escribe en una matriz de caracteres.

FileReader

Flujo de entrada que se lee de un archivo.

FileWriter

Flujo de salida que se escribe en un archivo.

FilterReader

Lector filtrado.

FilterWriter

Escritor filtrado.

InputStreamReader

Flujo de entrada que traduce bytes en caracteres.

LineNumberReader

Flujo de entrada que cuenta líneas.

OutputStreamWriter

Flujo de salida que traduce caracteres en bytes.

PipedReader

Canalización de entrada.

PipedWriter

Canalización de salida.

PushbackReader

Flujo de entrada que permite que los caracteres se devuelvan al flujo de entrada.

Reader

Clase abstracta que describe entrada de flujo de caracteres.

StringReader

Flujo de entrada que lee de una cadena.

StringWriter

Flujo de salida que escribe en una cadena.

Writer

Clase abstracta que describe la salida de flujo de caracteres.

Tabla 3-6 Las clases de flujo de caracteres

Las interfaces Closeable y Flushable son implementadas por varias de las clases de E/S. Proporcionan una manera uniforme de especificar que un flujo puede cerrarse o limpiarse. La interfaces Closeable sólo define un método, close( ), que se muestra aquí: void close( ) throws IOException Este método cierra un flujo abierto. Una vez cerrado, no es posible volver a usar el flujo. Todas las clases de E/S que abren un flujo implementan Closeable. La interfaz Flushable también especifica sólo un método, flush( ), que se muestra aquí: void flush( ) throws IOException La llamada a flush( ) causa que se escriba físicamente cualquier salida en búfer en el dispositivo correspondiente. Esta interfaz es implementada por las clases de E/S que escriben en un flujo. FileFilter y FilenameFilter se usan para filtrar listados de directorios.

Capítulo 3:

Manejo de archivos

57

Las interfaces ObjectInput y ObjectOutput se usan cuando se serializan objetos (guardándolos y restaurándolos).

Los flujos de archivos comprimidos En java.util.zip, Java proporciona un conjunto muy poderoso de flujos de archivos especializados que manejan la compresión y descompresión de datos. Todas son subclases de InputStream u OutputStream, descritas antes. A continuación se muestran los flujos de archivo comprimidos. DeflaterInputStream

Lee datos, comprimiéndolos en el proceso.

DeflaterOutputStream

Escribe datos, comprimiéndolos en el proceso.

GZIPInputStream

Lee un archivo GZIP.

GZIPOutputStream

Escribe un archivo GZIP.

InflaterInputStream

Lee datos, descomprimiéndolos en el proceso.

InflaterOutputStream

Escribe datos, descomprimiéndolos en el proceso.

ZipInputStream

Lee un archivo ZIP.

ZipOutputStream

Escribe un archivo ZIP.

Empleando los flujos de archivos comprimidos, es posible comprimir datos de manera automática mientras se escriben en un archivo o descomprimir los datos automáticamente cuando se leen de un archivo. También puede crear archivos comprimidos que son compatibles con los formatos ZIP y GZIP estándar, y puede descomprimir los archivos en esos formatos. La compresión real es proporcionada por las clases Inflater y Deflater, también empaquetadas en java.util.zip. Usan la biblioteca de compresión ZLIB. Por lo general no necesitará tratar con estas clases directamente cuando comprima o descomprima archivos, porque su operación predeterminada es suficiente.

Consejos para el manejo de errores La E/S de archivos plantea un desafío especial cuando se trata de manejo de errores. Hay dos razones para esto. En primer lugar, las fallas de E/S son una posibilidad muy real cuando se leen o escriben archivos. A pesar del hecho de que el hardware de computación (e Internet) es mucho más confiable que en el pasado, aún falla a una tasa muy elevada, y cualquiera de esas fallas debe manejarse de manera consistente con las necesidades de su aplicación. La segunda razón de que el manejo de errores presente un desafío cuando se trabaja con archivos es que casi todas las operaciones de archivo pueden generar una o más excepciones. Esto significa que casi todo el código de manejo de archivos debe incluirse en un bloque try. La excepción de E/S más común es IOException. Muchos constructores y métodos en el sistema de E/S pueden lanzar esta excepción. Como regla general, es generada cuando algo sale mal al leer o escribir datos, o al abrir un archivo. Otras excepciones comunes relacionadas con E/S, como FileNotFoundException y ZipException, son subclases de IOException. Hay otra excepción común relacionada con el manejo de archivos: SecurityException. Muchos constructores o métodos lanzarán una SecurityException si la aplicación que invoca no tiene permiso para acceder a un archivo o realizar una operación específica. Necesitará manejar esta excepción de una manera apropiada para su aplicación. Por simplicidad, los ejemplos de este capítulo no manejan excepciones de seguridad, pero tal vez sea necesario que sus aplicaciones las incluyan.

58

Java: Soluciones de programación Debido a que muchos constructores y métodos pueden generar una IOException, no es poco común ver código que simplemente envuelve todas las operaciones de E/S dentro de un solo bloque try y luego captura la IOException que pueda ocurrir. Aunque sea adecuado experimentar con E/S de archivo o posiblemente con simples programas de utilería que son para su propio uso personal, este método no suele ser adecuado para código comercial. Esto se debe a que no es fácil tratar de manera individual con cada posible error. En cambio, para un control detallado, es mejor poner cada operación dentro de su propio bloque try. De esta manera, puede reportar y responder de manera precisa al error que ocurrió. Este es el método demostrado por los ejemplos en este capítulo. Otra manera en que a veces se maneja IOException es lanzarla fuera del método en que ocurre. Para esto, debe incluir una cláusula throws IOException en la declaración del método. Este método es bueno en algunos casos, porque reporta una falla de E/S al llamador. Sin embargo, en otras situaciones es un método abreviado poco satisfactorio porque causa que todos los s del método manejen la excepción. Los ejemplos de este capítulo no usan este método. En cambio, manejan explícitamente todas las excepciones IOException. Esto permite que cada manejador de error reporte precisamente el error que ocurrió. Si maneja excepciones IOException al lanzarlas fuera del método en que ocurren, debe tener un cuidado adicional en cerrar cualquier archivo que haya sido abierto por el método. La manera más fácil de hacer esto consiste en envolver el código de su método en un bloque try y luego usar una cláusula finally para cerrar los archivos antes que el método que regresa. En los ejemplos de este capítulo, cualquier excepción de E/S que ocurra se maneja con el simple despliegue de un mensaje. Aunque este método sea aceptable para los programas de ejemplo, por lo general las aplicaciones reales necesitarán proporcionar una respuesta más sofisticada a un error de E/S. Por ejemplo, tal vez quiera dar al la capacidad de volver a probar la operación, especificar una operación alterna o manejar de otra manera el problema. El objetivo principal es evitar la pérdida o corrupción de los datos. Parte de la tarea de ser un gran programador consiste en saber cómo manejar efectivamente las cosas que podrían salir mal cuando falla una operación de E/S. Un punto final: un error común que ocurre cuando se manejan archivos consiste en olvidar el cierre de un archivo cuando se termina de usarlo. Los archivos abiertos usan recursos del sistema. Por tanto, hay límites al número de archivos que pueden abrirse en cualquier momento. El cierre de un archivo también asegura que cualquier dato escrito en el archivo se escriba realmente en el dispositivo físico. Por tanto, la regla es muy simple: si abre un archivo, ciérrelo. Aunque los archivos suelen cerrarse automáticamente cuando termina una aplicación, es mejor no depender de esto porque puede llevar a una programación deficiente y a malos hábitos. Es mejor cerrar explícitamente cada archivo, manejando de manera apropiada cualquier excepción que pudiera ocurrir. Por esto, en los ejemplos de este capítulo todos los archivos se cierran de manera explícita, aunque el programa se esté terminando.

Capítulo 3:

Manejo de archivos

59

Lea bytes de un archivo Componentes clave Clases

Métodos

java.io.FileInputStream

int read( ) void close( )

Las dos operaciones con archivos más fundamentales son la lectura de y la escritura de bytes en un archivo. En esta solución se muestra cómo realizar la primera. (En la siguiente se muestra cómo manejar la segunda). Aunque Java ofrece la capacidad de leer otros tipos de datos, como caracteres, valores de punto flotante o líneas de texto, la E/S de bytes es la base del manejo de archivos, porque todas las operaciones con archivos están, en esencia, orientadas a bytes. Más aún, este tipo de operaciones puede usarse con cualquier tipo de archivo, sin importar lo que contenga. Por ejemplo, si quiere escribir una utilería de archivos que despliegue la representación hexadecimal de los bytes de un archivo, entonces necesitar usar clases de E/S basadas en bytes. Esto permite que el programa cree un "volcado hexadecimal" para cualquier tipo de archivo, incluidos los que contienen texto, imágenes, código ejecutable, etcétera. Una manera de leer bytes de un archivo consiste en usar FileInputStream. Se deriva de InputStream, que define la funcionalidad básica de todos los flujos de entrada de bytes. Implementa la interfaz Closeable.

Paso a paso Para leer bytes de un archivo empleando FileInputStream se requieren estos pasos: 1. Abra el archivo al crear una instancia de FileInputStream. 2. Lea el archivo empleando el método read( ). 3. Cierre el archivo al llamar a close( ).

Análisis A fin de abrir un archivo para entrada, cree un objeto de FileInputStream, que define tres constructores. El que usaremos es: FileInputStream(String nombreArchivo) throws FileNotFoundException Aquí, nombreArchivo especifica el nombre del archivo que desea abrir. Si el archivo no existe, entonces se lanza FileNotFoundException. Para leer del archivo, puede usar cualquier versión del método read( ), que se hereda de InputStream. Aquí se muestra el que usaremos: int read( ) throws IOException Lee un solo byte del archivo y lo devuelve como un valor entero. read( ) devuelve –1 cuando se encuentra el final del archivo. Lanzará una IOException si ocurre un error de E/S. Otras versiones de read( ) pueden recibir como entrada varios bytes a las vez y ponerlos en una matriz.

60

Java: Soluciones de programación Cuando haya terminado con el archivo, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException Se lanza una IOException si ocurre un error cuando se cierra el archivo.

Ejemplo En el siguiente programa se usa FileInputStream para desplegar el contenido de un archivo, byte por byte, en formato hexadecimal. // // // // // // // // //

Despliega un archivo en formato hexadecimal. Para usar este programa, especifique el nombre del archivo que quiere ver. Por ejemplo, para ver un archivo llamado prueba.exe, use la siguiente línea de comandos: java VolcarHex prueba.exe import java.io.*; class VolcarHex { public static void main(String args[ ]) { FileInputStream fin; // Primero se asegura de que se ha especificado un // archivo en la línea de comandos. if(args.length != 1) { System.out.println("Uso: java VolcarHex Archivo"); return; } // Ahora, abre el archivo. try { fin = new FileInputStream(args[0]); } catch(FileNotFoundException exc) { System.out.println("Archivo no encontrado"); return; } // Lee bytes y despliega sus valores hexadecimales. try { int i; int count = 0; // Lee bytes hasta que se encuentra EOF do { i = fin.read( ); if(i != –1) System.out.printf("%02X ", i); count++;

Capítulo 3:

Manejo de archivos

61

if(count == 16) { System.out.println( ); count = 0; } } while(i != –1); } catch(IOException exc) { System.out.println("Error al leer el archivo"); } // Cierra el archivo. try { fin.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo"); } } }

He aquí una parte de un ejemplo de la salida producida cuando se ejecuta este programa en su propio archivo de clase. CA 00 68 53 1A 49 44 70

FE 04 61 74 01 6E 69 6F

BA 00 01 72 00 6E 76 46

BE 15 00 69 09 65 69 69

00 07 12 6E 54 72 73 63

00 00 4C 67 69 43 6F 68

00 17 6A 3B 70 6C 72 61

32 07 61 01 6F 61 46 3B

00 00 76 00 46 73 69 01

1D 19 61 04 69 73 63 00

09 01 2F 74 63 65 68 06

00 00 6C 69 68 73 61 74

03 05 61 70 61 01 73 68

00 66 6E 6F 01 00 24 69

14 69 67 07 00 19 54 73

0A 63 2F 00 0C 4C 69 24

Opciones Hay otras dos formas de read( ) que puede usar para leer bytes de un archivo. En primer lugar, puede leer un bloque de bytes del archivo a usar esta forma de read( ): int read( )(byte buf[ ]) throws IOException Llena la matriz a la que hace referencia buf con bytes leídos del archivo. Devuelve el número de bytes que se lee en realidad, lo que podría ser menos que buf.length si se encuentra el final del archivo. Al tratar de leer al final del archivo se causa que read( ) devuelva –1. Por ejemplo, en el programa anterior, he aquí otra manera de secuenciar las lecturas y desplegar los bytes en el archivo: // Lee bytes y despliega sus valores hexadecimales. try { int lon; byte datos[ ] = new byte[16]; // Lee bytes hasta que se encuentra EOF. do { lon = fin.read(datos); for(int j=0; j
62

Java: Soluciones de programación System.out.println( ); } while(lon != –1); } catch(IOException exc) { System.out.println("Error al leer el archivo"); }

Con este método se crea una matriz de 16 bytes y se usa para leer hasta 16 bytes de datos con cada llamada a read( ). Esto es más eficiente que realizar 16 operaciones de lectura separadas, como en el ejemplo. Aquí se muestra la ultima forma de read( ): int read(byte buf[ ], int indInicio, int num) throws IOException Esta versión lee num de bytes del archivo y los almacena en buf, empezando en el índice especificado por indInicio. Devuelve el número de bytes que se lee en realidad, que podría ser menor que num si se encuentra el final del archivo. Tratar de leer el final del archivo causa que read( ) devuelva –1. FileInputStream proporciona constructores adicionales que le permiten crear un objeto al pasar un objeto de File o uno de FileDescriptor. Estos constructores ofrecen una opción conveniente en algunas situaciones. Para leer caracteres (es decir, objetos de tipo char) en lugar de bytes, use FileReader. (Consulte Lea caracteres de un archivo). Puede almacenar en búfer la entrada de un archivo al envolver un FileInputStream dentro de un BufferedInputStream. Esto hace más eficientes las operaciones con archivos. (Consulte Use el búfer para la E/S de un archivo basada en bytes).

Escriba bytes en un archivo Componentes clave Clases

Métodos

java.io.FileOutputStream

int write(int valbyte) void close( )

Como se estableció en la solución anterior, hay dos operaciones de archivo fundamentales: lectura y escritura de bytes en un archivo. En la solución anterior se mostró cómo leer bytes. En ésta se muestra cómo escribirlos. Aunque Java le ofrece la capacidad de escribir otros tipos de datos, la salida basada en bytes es útil en circunstancias en que deben escribirse datos simples (es decir, sin formato) en un archivo. Por ejemplo, si quiere guardar en disco el contenido de un búfer de pantalla, entonces la opción correcta es la salida basada en bytes. También es la opción correcta cuando se crean varias utilerías de archivo, como las de copia, división, mezcla o búsqueda de archivos, porque los operadores de archivos basados en bytes pueden usarse con cualquier tipo de archivo, sin importar lo que contenga o el formato de sus datos.

Capítulo 3:

Manejo de archivos

63

Para escribir bytes en un archivo, puede usar FileOutputStream. Se deriva de OutputStream, que define la funcionalidad básica de todos los flujos de salida de bytes. Implementa las interfaces Closeable y Flushable.

Paso a paso Para escribir en un archivo empleando FileOutputStream, se requieren estos pasos: 1. Abra el archivo al crear un objeto de FileOutputStream. 2. Escriba en el archivo empleando el método write( ). 3. Cierre el archivo al llamar a close( ).

Análisis A fin de abrir un archivo para salida, cree un objeto de FileOutputStream, que define varios constructores. El que usaremos es: FileOutputStream(String nombreArchivo) throws FileNotFoundException Aquí, nombreArchivo especifica el nombre del archivo que desea abrir. Si el archivo no puede crearse, entonces se lanza FileNotFoundException. Cualquier archivo existente que tenga el mismo nombre habrá de destruirse. Para escribir en un archivo, puede usar cualquier versión del método write( ), que se hereda de OutputStream. Aquí se muestra su forma más simple: void write(int valbyte) throws IOException Con este método se escribe el byte especificado por valbyte en el archivo. Aunque valbyte se declara como entero, sólo se escriben los ocho bytes de orden inferior en el archivo. Lanzará una IOException si ocurre un error durante la escritura. Otras versiones de write( ) pueden dar salida a una matriz de bytes. Cuando haya terminado con el archivo, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException Se lanza una IOException si ocurre un error mientras se cierra el archivo.

Ejemplo En el siguiente ejemplo se usa FileOutputStream para escribir bytes en un archivo. Primero crea un archivo llamado Prueba.dat. luego escribe cada tercer byte en la matriz vals, que contiene los códigos ASCII de la letra A a la J. Por tanto, después de que se ejecuta el programa, Prueba.dat contendrá los caracteres ASCII ACEGI. // Usa FileOutputStream para escribir los bytes en un archivo. import java.io.*; class EscribirBytes { public static void main(String args[ ]) { // Esta matriz contiene el código ASCII de la // letra A a la J. byte[ ] vals = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 };

64

Java: Soluciones de programación FileOutputStream fout; try { // Abre el archivo de salida. fout = new FileOutputStream("Prueba.dat"); } catch(FileNotFoundException exc) { System.out.println("Error al abrir el archivo de salida"); return; } try { // Escribe cada tercer valor de la matriz vals en el archivo. for(int i=0; i
Opciones Hay otras dos formas de write( ) que puede usar para escribir bytes en un archivo. En primer lugar, puede escribir un bloque de bytes empleando esta forma de write( ): void write(byte buf[ ]) throws IOException El contenido de la matriz a la que hace referencia buf se escribe en el archivo. Por ejemplo, en el programa anterior, si quisiera escribir todo el contenido de la matriz vals en el archivo, podría usar esta simple llamada a write( ). fout.write(vals)

Esto sería más eficiente que escribir de byte en byte. Puede escribir una parte de una matriz en un archivo al usar esta forma de write( ): void write(byte buf[ ], int indInicio, int num) throws IOException Esta versión escribe un num de bytes de buf en un archivo, empezando en el índice especificado por indInicio. FileOutputStream proporciona varios constructores adicionales. En primer lugar, puede especificar el archivo que se abrirá al pasar un objeto de File o uno de FileDescriptor. También puede especificar si la salida se adjuntará al final del archivo empleando uno de estos constructores: FileOutputStream(String nombreArchivo, boolean adjunt) throws FileNotFoundException FileOutputStream(String objetoArchivo, boolean adjunt) throws FileNotFoundException

Capítulo 3:

Manejo de archivos

65

En la primera versión, nombreArchivo especifica el nombre del archivo que quiere abrir. En la segunda versión, objetoArchivo especifica el objeto de File que describe el archivo que quiere abrir. Si adjunt es true, entonces el contenido del archivo existente se conservará y toda la salida se escribirá al final del archivo. Esto es útil cuando quiere agregar algo a un archivo existente. De otra manera, cuando adjunt es false, el contenido del archivo anterior, con el mismo nombre, se destruirá. En ambos casos, si no puede abrirse el archivo, se lanzará FileNotFoundException. Verá los efectos de abrir un archivo usando el modo de adjuntar si sustituye la línea en el ejemplo: fout = new FileOutputStream("Prueba.dat", true);

Ahora, cada vez que ejecute el programa, los caracteres se agregarán al final del contenido anterior de Prueba.dat. Puede almacenar en búfer la salida a un archivo al envolver un FileOutputStream dentro de un BufferedOutputStream. (Consulte Use el búfer para la E/S de un archivo basada en bytes.) Para escribir caracteres (es decir, objetos de tipo char) en lugar de bytes, use FileWriter. (Consulte Escriba caracteres en un archivo.)

Use el búfer para la E/S de un archivo basada en bytes Componentes clave Clases

Métodos

java.io.BufferedInputStream


java.io.BufferedOutputStream void


En las dos soluciones anteriores se mostró el procedimiento general para leer y escribir bytes en un archivo empleando FileInputStream y FileOutputStream. Aunque no hay nada erróneo en esto, ninguna de esas clases proporciona uso automático del búfer. Esto significa que cada operación de lectura o escritura interactúa, al final de cuentas, con varios controladores de E/S en el nivel del sistema (lo que proporciona al archivo físico). Éste no suele ser un método eficiente. En muchos casos, una mejor manera consiste en usar el búfer para el flujo de datos. En el caso de la salida, los datos se almacenan en un búfer hasta que éste se llena. Luego todo el búfer se escribe en el archivo en una sola operación. En el caso de entrada, se lee un búfer completo del archivo y luego cada operación de entrada obtiene sus datos del búfer. Cuando el búfer se agota, se obtiene el siguiente búfer del archivo. Este mecanismo causa que el número de operaciones individuales de archivo se reduzca en gran medida. Aunque es posible usar manualmente el búfer para las operaciones de E/S al leer y escribir matrices de bytes (en lugar de bytes individuales), ésta no es una solución conveniente ni apropiada en muchos casos. En cambio, para lograr los beneficios de rendimiento de usar el búfer para las operaciones de E/S de archivos, por lo general querrá envolver un flujo de archivo dentro de una de las clases de flujo de búfer de Java. Al hacerlo así se mejorará de manera importante la velocidad de sus operaciones de E/S sin esfuerzo adicional de su parte.

66

Java: Soluciones de programación Para crear un flujo de entrada en búfer, use BufferedInputStream. Deriva de InputStream y de FilterInputStream. Implementa la interfaz Closeable. Para crear un flujo de salida en búfer, use BufferedOutputStream. Deriva de OutputStream y de FilterOutputStream. Implementa las interfaces Closeable y Flushable.

Paso a paso Para usar el búfer con un flujo de archivo, se requieren estos pasos: 1. Cree el flujo de archivo. Para entrada, sería una instancia de FileInputStream. En el caso de la salida, sería una instancia de FileOutputStream. 2. Envuelva el flujo de archivo en el flujo de búfer apropiado. Para el caso de la entrada, envuelva el flujo de archivo en un BufferedInputStream. Para el caso de la salida, en un BufferedOutputStream. 3. Realice todas las operaciones de E/S mediante el flujo en búfer. 4. Cierre el flujo que usará el búfer. El cierre de éste causa automáticamente que se cierre el flujo de archivo.

Análisis Para crear un flujo de entrada que se almacenará en búfer, use BufferedInputStream. Define dos constructores. El que usaremos es: BufferedInputStream(InputStream flujo) Esto crea un flujo en entrada en búfer que usa el búfer para el flujo de entrada especificado por flujo. Usa el tamaño de búfer predeterminado. Para crear un flujo de salida que se almacenará en búfer, use BufferedOutputStream. Define dos constructores. El que usaremos es: BufferedOutputStream(OutputStream flujo) Esto crea un flujo en salida en búfer que usa el búfer para el flujo de salida especificado por flujo. Usa el tamaño de búfer predeterminado. Para leer de un flujo en búfer, puede usar read( ). Para escribir en un flujo en búfer, puede usar write( ). (Consulte Lea bytes de un archivo y Escriba bytes en un archivo, para conocer más detalles). Cuando haya terminado con el flujo en búfer, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException. Al cerrar un flujo en búfer también se causa que el flujo original se cierre automáticamente. Si ocurre un error, se lanzará una IOException.

Ejemplo En el siguiente ejemplo se muestran BufferedInputStream y BufferedOutputStream en acción. Se crea un programa que copia un archivo. Debido a que se usan flujos de bytes, puede copiarse cualquier tipo de archivo, incluidos los que contienen texto, datos o programas.

Capítulo 3: // // // // // // // // // //

Manejo de archivos

Usa flujos en buffer para copiar un archivo. Para usar este programa, especifique el nombre de los archivos de origen y de destino. Por ejemplo, para copiar un archivo llamado ejemplo.dat en uno llamado ejemplo.bak, use la siguiente línea de comandos: java CopiarArchivoBufer ejemplo.dat ejemplo.bak

import java.io.*; class CopiarArchivoBufer { public static void main(String args[ ]) { BufferedInputStream fin; BufferedOutputStream fout; // Primero se asegura de que se han especificado ambos archivos. if(args.length != 2) { System.out.println("Uso: CopiarArchivoBufer De A"); return; } // Abre un archivo de entrada que está envuelto en un BufferedInputStream. try { fin = new BufferedInputStream(new FileInputStream(args[0])); } catch(FileNotFoundException exc) { System.out.println("Archivo de entrada no encontrado"); return; } // Abre un archivo de salida que está envuelto en un BufferedOutputStream. try { fout = new BufferedOutputStream(new FileOutputStream(args[1])); } catch(FileNotFoundException exc) { System.out.println("Error al abrir el archivo de salida"); // Cierra el archivo de entrada abierto. try { fin.close( ); } catch(IOException exc2) { System.out.println("Error al cerrar el archivo de entrada"); } return; } // Copia el archivo. // Debido al uso de flujos en búfer, las operaciones // de lectura y escritura se incluyen en búfer // automáticamente, lo que da un mejor rendimiento. try { int i;

67

68

Java: Soluciones de programación do { i = fin.read( ); if(i != –1) fout.write(i); } while(i != –1); } catch(IOException exc) { System.out.println("Error de archivo"); } try { fin.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de entrada"); } try { fout.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de salida"); } } }

Opciones La mejora en el rendimiento que se genera con el uso de flujos en búfer puede ser muy importante. En realidad, no tiene que depender de cronometrajes en nanosegundos. Suele ser muy evidente con la simple observación. Esto es cierto en el programa de copia de archivos que acabamos de mostrar. Para ver la diferencia de lo que hace el uso del búfer, use primero el programa de ejemplo como se muestra para copiar un archivo muy grande y observe cuánto tarda en ejecutarse. Luego, modifique el programa para que use FileInputStream y FileOutputStream directamente. En otras palabras, no envuelva el archivo dentro de un flujo de entrada en búfer. Luego, vuelva a ejecutar el programa, copiando el mismo archivo largo. Si el archivo que está copiando es lo suficientemente grande, notará con facilidad que la versión que no usa el búfer toma más tiempo. Aunque el tamaño de los búferes que proporcionan automáticamente BufferedInputStream y BufferedOutputStream suelen ser suficientes, es posible especificar su tamaño. Podría hacer esto si sus datos están organizados en bloques de tamaño fijo y estará operando de bloque en bloque. Con el fin de especificar el tamaño del búfer para entrada en búfer, use el siguiente constructor. BufferedInputStream(InputStream flujo int longit) Esto crea un flujo de entrada en búfer que usa el búfer para el flujo especificado en flujo. La longitud del búfer se pasa vía longit, que debe ser mayor que cero. Para especificar el tamaño del búfer para una salida en búfer, use el siguiente constructor: BufferedOutputStream(OutputStream flujo int longit) Esto crea un flujo de salida en búfer que usa el búfer para el flujo especificado en flujo. La longitud del búfer se pasa vía longit, que debe ser mayor que cero. BufferedInputStream sobreescribe los métodos mark( ) y reset( ) especificados por InputStream. Esto es importante porque en éste último, mark( ) no hace nada y reset( ) lanza una IOException. Al sobreescribir estos métodos, BufferedInputStream le permite moverse dentro de un búfer. En ciertas situaciones, esta capacidad resulta útil.

Capítulo 3:

Manejo de archivos

69

Lea caracteres de un archivo Componentes clave Clases

Métodos

java.io.FileReader


Aunque los flujos de bytes son técnicamente suficientes para manejar todas las tareas de entrada de archivos (porque todos los archivos pueden tratarse como flujos de bytes), Java ofrece un mejor método cuando se opera con datos de carácter: los flujos de carácter. Los flujos basados en carácter operan directamente en objetos de tipo char (en lugar de bytes). Por tanto, cuando se trabaja con archivos que contienen texto, los flujos basados en carácter suelen ser la mejor opción. Para leer caracteres de un archivo, puede usar FileReader, que se deriva de InputStreamReader y Reader. (InputStreamReader proporciona el mecanismo que traduce bytes en caracteres). FileReader implementa las interfaces Closeable y Readable. [(Readable está empaquetada en java. lang y define un objeto que proporciona caracteres mediante el método read( )]. Cuando se lee un archivo vía FileReader, la traducción de bytes en caracteres se maneja automáticamente.

Paso a paso Para leer un archivo empleando FileReader se requieren tres pasos principales: 1. Abra el archivo empleando FileReader. 2. Lea del archivo usando el método read( ). 3. Cierre el archivo al llamar a close( ).

Análisis Para abrir un archivo, simplemente cree un objeto de FileReader, que define tres constructores. El que usaremos es: FileReader(String nombreArchivo) throws FileNotFoundException Aquí, nombreArchivo es el nombre de un archivo. Lanza una FileNotFoundException, si el archivo no existe. Para leer un carácter de un archivo, puede usar esta versión de read( ) (heredada de Reader): int read( ) throws IOException Cada vez que se le llama, lee un solo carácter de un archivo y devuelve el carácter como un valor entero. read( ) devuelve –1 cuando se encuentra el final del archivo. Lanzará una IOException si ocurre un error de E/S. Otras versiones de read( ) pueden dar entrada a varios caracteres al mismo tiempo y ponerlos en una matriz. Cuando haya terminado con el archivo, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException Si ocurre un error cuando trata de cerrar el archivo, se lanza una IOException.

70


Ejemplo En el siguiente programa se usa FileReader para ingresar y desplegar el contenido de un archivo de texto, de carácter en carácter: // // // // // // // // //

Usa un FileReader para desplegar un archivo de texto. Para usar este programa, especifique el nombre del archivo que quiere ver. Por ejemplo, para ver un archivo llamado Prueba.txt, use la siguiente línea de comandos. java MostrarArchivo Prueba.txt

import java.io.*; class MostrarArchivo { public static void main(String args[ ]) { FileReader fr; // Primero se asegura de que se haya especificado un archivo. if(args.length != 1) { System.out.println("Uso: MostrarArchivo archivo"); return; } try { // Abre el archivo. fr = new FileReader(args[0]); } catch(FileNotFoundException exc) { System.out.println("No se ha encontrado el archivo"); return; } // En este punto, el archivo está abierto // y puede leerse su contenido. try { int car; // Lee el archivo de carácter en carácter. do { car = fr.read( ); if(car != –1) System.out.print((char)car); } while(car != –1); } catch(IOException exc) { System.out.println("Error al leer el archivo"); }

Capítulo 3:

Manejo de archivos

71

try { fr.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo"); } } }

Opciones Hay otras tres formas de read( ) disponibles para FileReader. La primera es: int read(char buf[ ]) throws IOException Este método rellena la matriz a la que hace referencia buf y lee caracteres de un archivo. Devuelve el número de caracteres que se lee en realidad, que podría ser menos que buf.length si se encuentra el final del archivo. Al tratar de leer el final del archivo se causa que read( ) devuelva –1. Por ejemplo, en el programa anterior, he aquí otra manera de escribir la parte del código que lee y despliega los caracteres en el archivo: try { int cuenta; char cars[ ] = new char[80]; // Lee el archivo de búfer en búfer. do { cuenta = fr.read(cars); for(int i=0; i < cuenta; i++) System.out.print(cars[i]); } while(cuenta != –1); } catch(IOException exc) { System.out.println("Error al leer el archivo"); }

Este método crea una matriz de 80 caracteres y lo usa para leer hasta 80 caracteres con cada llamada a read( ). Esto es más eficiente que realizar 80 operaciones de lectura separadas, como se hace en el ejemplo. Aquí se muestra la siguiente forma de read( ): int read(char buf[ ], int indInicio, int num) throws IOException Esta versión lee un num de caracteres del archivo final y los almacena en buf, empezando en el índice especificado en indInicio. Devuelve el número de caracteres que lee en realidad, lo que podría ser menos que num si se encuentra el final del archivo. Tratar de leer el final del archivo causa que read( ) devuelva –1. Aquí se muestra la versión final de read( ): int read(CharBuffer buf) throws IOException

72

Java: Soluciones de programación Esta versión de read( ) está especificada por la interfaz Readable. Lee caracteres en el búfer al que se hace referencia con buf. Devuelve el número de caracteres que se lee en realidad, que podría ser menor que el tamaño del búfer, si se encuentra el final del archivo. Si se trata de leer el final del archivo, read( ) devuelve –1. CharBuffer está empaquetado en java.nio y lo usa el sistema NIO. FileReader proporciona dos constructores adicionales que le permiten crear un objeto al pasar un objeto de File o al pasarlo en un FileDescriptor. Estos constructores pueden ofrecer una opción conveniente en algunas situaciones. Para leer los bytes contenidos en un archivo en lugar de los caracteres, use FileInputStream. (Consulte Lea bytes de un archivo). Puede usar el búfer para la entrada desde un archivo al envolver un FileReader en un BufferReader. (Consulte Use el búfer para la E/S de un archivo basada en bytes).


Métodos

java.io.FileWriter

void write(String cad) void close( )

Aunque un flujo de bytes puede usarse para escribir caracteres en un archivo, no es la mejor opción. En casos en que está tratando exclusivamente con texto, los flujos de archivo basados en caracteres de Java son una mucho mejor solución porque automáticamente manejan la traducción de caracteres en bytes. No sólo puede ser esto más eficiente, también puede simplificar la internacionalización. Para escribir caracteres en un archivo, puede usar FileWriter, que se deriva de OutputStreamWriter y Writer. (OutputStreamWriter proporciona el mecanismo que traduce caracteres en bytes.) FileWriter implementa las interfaces Closeable, Flushable y Appendable. [(Appendable está empaquetado en java.lang. Define un objeto al que pueden agregarse caracteres vía el método append( )]. Cuando se escribe un archivo vía FileWriter, la traducción de caracteres en bytes se maneja automáticamente.

Paso a paso Para escribir un archivo empleando FileWriter, se requieren estos pasos: 1. Abra el archivo usando FileWriter. 2. Escriba en el archivo usando el método write( ). 3. Cierre el archivo al llamar a close( ).

Capítulo 3:

Manejo de archivos

73

Análisis Para abrir un archivo, simplemente cree un objeto de FileWriter, que define varios constructores. El que usaremos es FileWriter(String nombreArchivo) throws IOException Aquí, nombreArchivo es el nombre de un archivo. Lanza una IOException, si falla. Para escribir en el archivo, use el método write( ), que se hereda de Writer. Aquí se muestra una versión: void write(String cad) throws IOException Esta versión de write( ) escribe cad en el archivo. Lanza una IOException si ocurre un error mientras se escribe. Están disponibles varias otras versiones de write( ) que escriben caracteres individuales, partes de una cadena o el contenido a la matriz char. Cuando haya terminado con el archivo, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException

Ejemplo En este ejemplo se usa un FileWriter para escribir una matriz de cadenas (cada una contiene un número ID de empleado de cinco dígitos y una dirección de correo electrónico) en un archivo llamado Empleados.dat. Observe que después de que se escribe cada cadena en la matriz, se escribe una nueva línea. Esto hace que cada cadena tenga su propia línea. Sin la nueva línea, la siguiente cadena empezaría en la misma línea, inmediatamente después de la anterior. Por supuesto, no todas las aplicaciones necesitarán la adición de la nueva línea. // Usa FileWriter para escribir una matriz de cadenas en un archivo. import java.io.*; class EscribeCars { public static void main(String args[ ]) { String cad; FileWriter fw; String cads[ ] = { "32435 [email protected]", "86754 [email protected]", "35789 [email protected]" }; try { // Abre el archivo de salida. fw = new FileWriter("Empleados.dat"); } catch(IOException exc) { System.out.println("Error al abrir el archivo"); return ; } try {

74

Java: Soluciones de programación // Escriba las cadenas en cads en el archivo. for(int i=0; i < cads.length; i++) { fw.write(cads[i]); // escribe líneas en un archivo fw.write("\n"); // salida a una nueva línea } } catch(IOException exc) { System.out.println("Error al escribir el archivo"); } try { fw.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo"); } } }

Después de que se ejecuta este programa, Empleados.dat contendrán la siguiente salida: 32435 [email protected] 86754 [email protected] 35789 [email protected]

Opciones Hay varias otras formas de write( ) que puede usar. Aquí se muestran: void write(int car) throws IOException void write(char buf[ ]) throws IOException void write(char buf[ ], int indInicio, int num) throws IOException void write(String cad, int indInicio, int num) throws IOException La primera forma escribe los 16 bits de orden menor de char. La segunda forma escribe el contenido de buf. La tercera forma escribe un num de caracteres desde buf, empezando en el índice especificado por indInicio. La forma final escribe un num de caracteres desde cad, empezando en el índice especificado por indInicio. La última forma de write( ) resulta especialmente útil en ocasiones. Por ejemplo, suponiendo las cadenas de empleadas usada en el ejemplo (un número de ID de empleado de 5 dígitos, seguido por un espacio, seguido por la dirección de correo electrónico de empleado), la siguiente llamada a write( ) sólo escribirá la dirección de correo electrónico en un archivo: fw.write(cads[i], 6, cads[i].length( )–6);

Si se sustituye esta línea en el ejemplo, entonces el archivo Empleados.dat contendrán lo siguiente: [email protected] [email protected] [email protected]

Como es evidente, la parte de ID de empleado de cada cadena no está almacenada en el archivo.

Capítulo 3:

Manejo de archivos

75

FileWriter proporciona varios constructores adicionales. En primer lugar, puede crear un objeto al pasar un objeto de File o al pasarlo en un FileDescriptor. También puede especificar si la salida se habrá de adjuntar al final del archivo al usar uno de esos constructores: FileWriter(String nombreArchivo, boolean adjunt) throws IOException FileWriter(File objetoArchivo, boolean adjunt) throws IOException En la primera versión, nombreArchivo especifica el nombre del archivo que quiere abrir. En la segunda versión, objetoArchivo especifica el archivo de File que describe el archivo. En ambos casos, si adjunt es verdadero, entonces el contenido de un archivo existente se preservará y toda la salida se escribirá al final del archivo. Esto es útil cuando quiere agregar algo a un archivo existente. De otra manera, cuando adjunt es falso, se destruirá el contenido de cualquier archivo existente con el mismo nombre. Si el archivo no puede abrirse, entonces ambos constructores lanzan IOException. Puede ver los efectos de abrir un archivo empleando el modo de adjuntar al sustituir esta línea en el ejemplo: fw = new FileWriter("Empleados.dat", true);

Ahora, cada vez que ejecuta el programa, los datos de los empleados se agregarán al final del archivo existente. Para escribir bytes en lugar de caracteres, use FileOutputStream. (Consulte Escriba bytes en un archivo). Puede usar el búfer para la salida de un archivo el envolver un FileWriter en un BufferWriter. (Consulte Use el búfer para la E/S de un archivo basada en bytes).

Use el búfer para la E/S de un archivo basada en caracteres Componentes clave Clases

Métodos

java.io.BufferedReader


java.io.BufferedWriter

void write(int valbytes) void close( )

Aunque FileReader y FileWriter proporcionan las capacidades para leer y escribir en un archivo de texto, emplearlos solos tal vez no siempre sea el método más eficiente. La razón es que cada operación de lectura o escritura individual traduce (directa o indirectamente) en una operación en el archivo, y el al archivo consume tiempo. A menudo, un mejor método es proporcionar un búfer para los datos. En este método, cada operación de entrada lee desde un bloque de datos y cada operación de salida escribe en un bloque de datos. Por tanto, el número de operaciones de archivo es reducido, lo que da como resultado el rendimiento mejorado. Aunque es posible usar el búfer manualmente en las operaciones de E/S al leer y escribir matrices de caracteres (en lugar de caracteres individuales), este método no será óptimo en todos los casos. En cambio, para lograr los beneficios del rendimiento de usar el búfer para las operaciones de E/S, por lo general querrá envolver un flujo de caracteres dentro de una clase de

76

Java: Soluciones de programación lector o escritor en búfer de Java. Al hacerlo así, en ocasiones aumentará de manera importante la velocidad de sus operaciones de E/S sin esfuerzo adicional de su parte. Para crear un lector de flujo de entrada en búfer, use BufferedReader. Deriva de Reader e implementa las interfaces Closeable y Readable. [(Readable está empaquetado en java.lang y define un objeto que proporciona caracteres vía el método read( )]. Para crear un lector de flujo de salida en búfer, use BufferedWriter. Deriva de Writer e implementa las interfaces Closeable, Flushable y Appendable. [(Appendable está empaquetado en java.lang. Define un objeto al que pueden agregarse caracteres mediante el método append( )].

Paso a paso Para usar el búfer con un flujo de archivo basado en caracteres, se requieren estos pasos: 1. Cree el flujo base. Para entrada, será una instancia de FileReader. En el caso de la salida, será una instancia de FileWriter. 2. Envuelva el flujo de archivo en el lector o escritor en búfer apropiado. Para el caso de la entrada, use BufferedReader. Para el caso de la salida, use BufferedWriter. 3. Realice todas las operaciones de E/S mediante el lector o escritor que usa el búfer. 4. Cierre el flujo en búfer. El cierre de éste causa automáticamente que se cierre el flujo de archivo.

Análisis Para crear un lector que usará el búfer, use BufferedReader. Define dos constructores. El que usaremos es: BufferedReader(Reader lect) Esto crea un lector que usa el búfer para el flujo de entrada especificado por lect. Usa el tamaño de búfer predeterminado. En el caso de operaciones de entrada de archivo, pasará un FileReader a lect. Para crear un escritor que usa el búfer para flujo de salida, use BufferedWriter. Define dos constructores. El que usaremos es: BufferedWriter(OutputStream escr) Esto crea un escritor que usa el búfer para el flujo de salida especificado por escr. Usa el tamaño de búfer predeterminado. Por tanto, para usar el búfer con las operaciones de archivo, pasará un FileWriter a escr. Por ejemplo, suponiendo un archivo llamado Prueba.dat, en las siguientes líneas se muestra cómo crear un BufferedReader y un BufferedWriter vinculado con ese archivo. BufferedReader bw = new BufferedReader (new FileReader("Prueba.dat")); BufferedWriter br = new BufferedWriter (new FileWriter("Prueba.dat"));

Para leer de un BufferedReader, puede usar cualquiera de los métodos de read( ), que se heredan de Reader. Aquí se muestra el que usaremos: int read( ) throws IOException

Capítulo 3:

Manejo de archivos

77

Devuelve el siguiente carácter en el flujo (en los 16 bits de orden inferior de un entero) o –1 si se llega al final del flujo. Si ocurre un error durante la lectura, se lanza una IOException. Para escribir en un flujo en búfer, puede usar cualquier versión del método write( ), que se hereda de Writer. Aquí se muestra el que usaremos: void write(int car) throws IOException Este método escribe el carácter especificado por car en el archivo. Aunque valbyte se declare como entero, sólo se escriben en el flujo los 16 bits de orden inferior. Si ocurre un error durante la escritura, se lanza una IOException. Otras versiones de write( ) pueden dar salida a una matriz de caracteres. Cuando haya terminado con el lector o escritor que usa el búfer, debe cerrarlo al llamar a close( ). Aquí se muestra: void close( ) throws IOException. Al cerrar un BufferedReader o un BufferedWriter también se causa que el flujo original se cierre automáticamente.

Ejemplo El siguiente ejemplo usa un BufferedReader y un BufferedWriter para copiar un archivo. En el proceso, invierte las mayúsculas y minúsculas de las letras. En otras palabras, las minúsculas se vuelven mayúsculas, y viceversa. Todos los demás caracteres quedan sin cambio. // // // // // // // // // // //

Usa un BufferedReader y un BufferedWriter para copiar un archivo de texto, invirtiendo las mayúsculas y minúsculas en el proceso. Para usar este programa, especifique el nombre de los archivos de origen y destino. Por ejemplo, para copiar un archivo llamado prueba.txt en uno llamado prueba.inv, use la siguiente línea de comandos: java CopiarInvertir test.txt test.inv

import java.io.*; class CopiarInvertir { public static void main(String args[ ]) { BufferedReader br; BufferedWriter bw; // Primero se asegura de que se han especificado ambos archivos. if(args.length != 2) { System.out.println("Uso: CopiarInvertir De A"); return; }

78

Java: Soluciones de programación // Abre un FileReader envuelto en un BufferedReader. try { br = new BufferedReader(new FileReader(args[0])); } catch(FileNotFoundException exc) { System.out.println("No se ha encontrado el archivo de entrada"); return; } // Abre un FileWriter envuelto en un BufferedWriter. try { bw = new BufferedWriter(new FileWriter(args[1])); } catch(IOException exc) { System.out.println("Error al abrir el archivo de salida"); // Cierra el lector de entrada abierto. try { br.close( ); } catch(IOException exc2) { System.out.println("Error al cerrar el archivo de entrada"); } return; } // Copia el archivo, invirtiendo las mayúsculas y minúsculas // en el proceso. Debido a que se usan flujos en búfer, las // operaciones de lectura y escritura usan el búfer, // automáticamente, lo que da un mejor rendimiento. try { int i; char ch; do { i = br.read( ); if(i != –1) { if(Character.isLowerCase((char) i)) bw.write(Character.toUpperCase((char) i)); else if(Character.isUpperCase((char) i)) bw.write(Character.toLowerCase((char) i)); else bw.write((char) i); } } while(i != –1); } catch(IOException exc) { System.out.println("Error de archivo"); } try { br.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de entrada"); }

Capítulo 3:

Manejo de archivos

79

try { bw.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de salida"); } } }

Opciones Es fácil ver de primera mano la mejora en el rendimiento que se obtiene al envolver un flujo de archivo en un flujo que usa el búfer, al hacer el siguiente experimento. En primer lugar, ejecute el programa de ejemplo, como se muestra, en un archivo de texto muy largo. Ahora observe cuánto tarda en ejecutarse. Luego, modifique el programa para que use FileReader y FileWriter directamente. En otras palabras, no envuelva ninguno en una clase que use el búfer. Luego, vuelva a ejecutar el programa con el mismo archivo de texto largo. Si el archivo que está empleando es lo suficientemente largo, observará con facilidad que la versión que no usa el búfer ocupa más tiempo. Como regla general, el búfer predeterminado proporcionado por BufferedReader y BufferedWriter es suficiente, pero es posible especificar un tamaño de búfer elegido por usted. Sin embargo, esto es más aplicable a situaciones en que un archivo está organizado en bloques de caracteres, y en que cada bloque tiene un tamaño fijo. Francamente, cuando se trabaja con archivos de texto, esta situación no es común. Por tanto, el tamaño de búfer predeterminado suele ser la elección apropiada. Para especificar el tamaño del búfer para un BufferedReader, use este constructor: BufferedReader(Reader lect, int longit) Esto crea un lector que usa el búfer con base en lect, que tiene una longitud de búfer longit, que debe ser mayor que cero. Para especificar el tamaño del búfer para un BufferWriter, use este constructor: BufferedWriter(OutputStream esch, int longit) Esto crea un escritor que usa el búfer en Esch que tiene una longitud de búfer de longit, que debe ser mayor que cero. BufferedReader sobreescribe los métodos mark( ) y reset( ) especificados por Reader. Esto es importante porque las implementaciones predeterminadas proporcionadas por Reader (heredadas por FileReader) simplemente lanzan una IOException. Al sobreescribir estos métodos, BufferedReader le permite moverse dentro de un búfer. Esta capacidad le resultará útil en ciertas situaciones. BufferedReader proporciona un método que le resultará especialmente útil en algunos casos: readLine( ). Este método lee una línea de texto completo. Aquí se muestra: String readLine( ) throws IOException Devuelve una cadena que contiene los caracteres leídos. Devuelve null si se hace un intento de leer al final del flujo. La cadena devuelta por readLine( ) no termina con los caracteres de final de línea, como un retorno de carro o un alimentador de línea. Sin embargo, la operación de lectura sí consume esos caracteres.

80


Lea y escriba archivos de aleatorio Componentes clave Clases

Métodos

java.io.RandomAccessFile

void seek(long nuevaPos) long length( ) int read( ) void write(int val) void close( )

En la solución anterior se ha mostrado cómo leer y escribir archivos en forma lineal, un byte o carácter tras otro. Sin embargo, Java también le permite acceder al contenido de un archivo en orden aleatorio o directo. Para ello, utilizará, RandomAccessFile, que encapsula un archivo de aleatorio. RandomAccessFile soporta colocación de solicitudes, lo que significa que puede leer o escribir en cualquier lugar dentro del archivo. RandomAccessFile está orientada a byte, pero no deriva de InputStream u OutputStream. En cambio, implementa las interfaces DataInput y DataUutput, que definen los métodos básicos de E/S, como readInt( ) y writeDouble( ), que leen y escriben tipos primitivos de Java. También proporciona varios métodos read( ) y write( ) basados en bytes. Además se implementa la interfaz Closeable.

Paso a paso Para leer y escribir bytes en un orden no secuencial, se requieren los siguientes pasos: 1. Abra un archivo de aleatorio al crear una instancia de RandomAccessFile. 2. Use el método seek( ) para colocar el apuntador al archivo en el lugar en que quiera leer o escribir. 3. Use los métodos de RandomAccessFile para leer o escribir datos. 4. Cierre el archivo.

Análisis RandomAccessFile proporciona dos constructores. El que usaremos aquí se muestra a continuación: RandomAccessFile(String nombreArchivo, String ) throws FileNotFoundException El nombre del archivo se pasa en nombreArchivo y determina el tipo de a archivo que se permite. Si es "r", puede leerse el archivo, pero no escribirse en él. Si es "rw", el archivo se abre en el modo de lectura y escritura. Otros valores de válido se describen bajo Opciones. Se lanza una FileNotFoundException si el archivo no puede abrirse para "r" o si el archivo no puede abrirse o crearse para "rw".

Capítulo 3:

Manejo de archivos

81

La ubicación dentro del archivo en que ocurrirá la siguiente operación de E/S está determinada por la posición del apuntador a archivo. Se trata, en esencia, de un índice en el archivo. La posición del apuntador al archivo se establece al llamar al método seek( ), que se muestra a continuación: void seek(long nuevaPos) throws IOException Aquí, nuevaPos especifica la nueva posición, en bytes, del apuntador desde el principio del archivo. Después de una llamada a seek( ), la siguiente operación de lectura o escritura ocurrirá en la nueva posición del archivo. El valor de nuevaPos debe ser mayor que cero. Si se trata de usar un valor menor de cero se lanzará una IOException. Por tanto, no es posible buscar antes del principio de un archivo. Sin embargo, sí es posible buscar después del final. RandomAccessFile da soporte a varios métodos read( ) y write( ), de los cuales, muchos están especificados por las interfaces DataInput y DataOutput. Aquí se muestran las usadas en el ejemplo: int read( ) throws IOException void write(int val) throws IOException El método read( ) devuelve el byte en la ubicación del apuntador a archivo actual; write( ) escribe val en la posición actual del apuntador a archivo. Cuando se trabaja con archivos de aleatorio, en ocasiones es útil saber la longitud del archivo en bytes. Una razón es que puede buscar hasta el final del archivo. Puede obtener la longitud actual del archivo al llamar a length( ), que se muestra aquí: long length( ) throws IOException Devuelve el tamaño del archivo.

Ejemplo En el siguiente ejemplo se ilustran las operaciones de aleatorio. Invierte el contenido de un archivo al intercambiar la posición de los bytes, del principio al final. Por ejemplo, dado un archivo que contiene ABCDE Después de ejecutar InvertirArchivo en él, el archivo contendrá EDCBA // // // // // // // //

Usa RandomAccessFile para invertir un archivo. Para usar este programa, especifique el nombre del archivo. Por ejemplo, para invertir un archivo llamado prueba.txt use la siguiente línea de comandos: java InvertirArchivo prueba.txt

import java.io.*; class InvertirArchivo { public static void main(String args[ ])

82

Java: Soluciones de programación { // Primero, se asegura de que se ha especificado un archivo. if(args.length != 1) { System.out.println("Uso: InvertirArchivo nombre"); return; } RandomAccessFile raf; try { // Abre el archivo. raf = new RandomAccessFile(args[0], "rw"); } catch(FileNotFoundException exc) { System.out.println("No se puede abrir el archivo"); return ; } try { int x, y; // Invierte el archivo. for(long i=0, j=raf.length( )–1; i < j; i++, j––) { // Lee el siguiente conjunto de bytes. raf.seek(i); x = raf.read( ); raf.seek(j); y = raf.read( ); // Intercambia los bytes. raf.seek(j); raf.write(x); raf.seek(i); raf.write(y); } } catch(IOException exc) { System.out.println("Error al escribir el archivo"); } try { raf.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo"); } } }

Capítulo 3:

Manejo de archivos

83

Opciones Hay una segunda forma de RandomAccessFile que abre el archivo especificado por una instancia de File. Aquí se muestra esta forma: RandomAccessFile(File objetoArchivo, String ) throws FileNotFoundException Abre el archivo especificado por objetoArchivo con el modo de pasado en . RandomAccessFile da soporte a dos modos de adicionales. La primera es "rws", y causa que cada cambio a los datos o metadatos de un archivo afecte de inmediato al dispositivo físico. La segunda es "rwd" y causa que cada cambio a los datos de un archivo afecte de inmediato al dispositivo físico.

Obtenga atributos de archivos Componentes clave Clases

Métodos

java.io.File

boolean canRead( ) boolean canWrite( ) boolean exists( ) boolean isDirectory( ) boolean isFile( ) boolean isHidden( ) long lastModified( ) long length( )

Las soluciones anteriores ilustran técnicas usadas para leer y escribir archivos. Sin embargo, hay otro aspecto del manejo de archivos que no se relaciona con la manipulación del contenido de un archivo, sino que trata con sus atributos, como su longitud, la hora en que fue modificado por última vez, si es de sólo lectura, etc. Los atributos de archivo pueden ser muy útiles cuando se istran archivos. Por ejemplo, tal vez quiera confirmar que un archivo no es de sólo lectura antes de tratar de escribir en él. O tal vez quiera saber la longitud de un archivo antes de copiarlo, de modo que confirme que cabe en el dispositivo de destino. Para obtener y establecer los atributos asociados con un archivo, usará la clase File. En esta solución se describe el procedimiento empleado para obtener atributos de archivo. En la siguiente solución se muestra cómo pueden establecer varios de ellos.

84


Paso a paso Para obtener los atributos asociados con un archivo se requieren estos pasos: 1. Cree un objeto de File que represente el archivo. 2. Si es necesario, confirme que el archivo existe al llamar a exists( ) con la instancia File. 3. Obtenga el atributo o los atributos en que está interesado al llamar a uno o más métodos de File.

Análisis File define cuatro constructores. Aquí se muestra el que usaremos: File(String nombre) El nombre del archivo se especifica con nombre, que puede incluir un nombre de ruta completo. Tenga en cuenta dos temas importantes. En primer lugar, la creación de un objeto de File no hace que un archivo se abra, ni implica que un archivo con ese nombre realmente exista. En cambio, crea un objeto que representa un nombre de ruta. En segundo lugar, nombre también puede especificar un directorio. En cuanto a File, un directorio es simplemente un tipo especial de archivo. Para el caso de análisis, en las siguientes descripciones se usa el término "archivo" para aludir a ambos casos, a menos que se indique otra cosa. A menudo querrá confirmar que el archivo representado por un objeto de File realmente exista antes de tratar de obtener información acerca de él. Para ello, use el método exists( ), que se muestra aquí: boolean exists( ) devuelve verdadero si existe el archivo, y falso, si no. Para obtener los atributos de un archivo, usará uno o más de los métodos siguientes: boolean canRead( )

Devuelve verdadero si el archivo existe y puede leerse.

boolean canWrite( )

Devuelve verdadero si el archivo existe y puede escribirse.

boolean isDirectory( ) Devuelve verdadero si el archivo existe y es un directorio. boolean isFile( )

Devuelve verdadero si el archivo existe y es un archivo, en lugar de un directorio o algún otro objeto soportado por el sistema de archivos.

boolean isHidden( )

Devuelve verdadero si el archivo está oculto.

long lastModified( )

Devuelve la fecha y hora en que el archivo se modificó por última vez en milisegundos, a partir del 1 de enero de 1970. Este valor puede usarse para construir un objeto de Fecha, por ejemplo, se devuelve 0 si el archivo no existe.

long length( )

Devuelve el tamaño del archivo, o cero si el archivo no existe.

Ejemplo El siguiente ejemplo crea un método llamado mostrarAtribs( ), que despliega los atributos asociados con un archivo. Para usar el programa, especifique el archivo en la línea de comandos. // Despliega los atributos asociados con un archivo. // // Para usar el programa, especifique el nombre del archivo

Capítulo 3:

Manejo de archivos

// en la línea de comandos. Por ejemplo, para desplegar los // atributos del archivo prueba.pba, use esta línea de comandos: // // java MostrarAtributosArchivo prueba.pba // import java.io.*; import java.util.*; class MostrarAtributosArchivo { // Despliega los atributos de un archivo. public static void mostrarAtribs(String nombre) { File f; // Crea un objeto de archivo para el archivo. f = new File(nombre); // Primero, confirma que el archivo exista. if(!f.exists( )) { System.out.println("No se ha encontrado el archivo."); return; } // Despliega varios atributos de archivo. System.out.println("Atributos de archivo: "); if(f.canRead( )) System.out.println(" De lectura"); if(f.canWrite( )) System.out.println(" De escritura"); if(f.isDirectory( )) System.out.println(" Es un directorio"); if(f.isFile( )) System.out.println(" Es un archivo"); if(f.isHidden( )) System.out.println(" Se encuentra oculto"); System.out.println(" Modificado por \u00a3ltima vez el " + new Date(f.lastModified( ))); System.out.println("

Longitud: " + f.length( ));

} // Demuestra el método showAttributes( ). public static void main(String args[ ]) { // Primero se asegura de que se ha especificado un archivo. if(args.length != 1) { System.out.println("Uso: MostrarAtributosArchivo nombrearchivo"); return; } mostrarAtribs(args[0]); } }

85

86

Java: Soluciones de programación Cuando se ejecuta en su propio archivo de origen, MostrarAtributosArchivo produce la siguiente salida: Atributos de archivo: De lectura De escritura Es un archivo Modificado por última vez el Thu Mar 27 19:25:35 CST 2008 Longitud: 6

Opciones Si está usando Java 6 o posterior, y si su plataforma lo soporta, puede determinar si su aplicación ejecutará su archivo al llamar canExecute( ), que se muestra aquí: boolean canExecute( ) Devuelve verdadero si el archivo puede ejecutarse al invocar el programa, y falso si no. Además del constructor File usado por la solución, File proporciona otros tres. Se muestran a continuación: File(String dir, String nombre) File(File dir, String nombre) File(URI uri) En las dos primeras formas, dir especifica un directorio principal y nombre especifica el nombre de un archivo o subdirectorio. En la última forma, uri especifica un objeto URI que describe el archivo.

Establezca atributos de archivos Componentes clave Clases

Métodos

java.io.File

boolean boolean boolean boolean

exists( ) setLastModified(long nuevaHora) setreadOnly( ) setWritable(boolean puedeEscribirse boolean quien)

En la solución anterior se mostró cómo obtener varios atributos de un archivo empleando la clase File. Ésta también le da la capacidad de establecer atributos. En esta solución se muestra el procedimiento.

Capítulo 3:

Manejo de archivos

87

Paso a paso Para establecer los atributos asociados con un archivo se requieren estos pasos: 1. Cree el objeto de File que representa al archivo. 2. Si es necesario, confirme que el archivo existe al llamar a exists( ) en la instancia de File. 3. Establezca el atributo o los atributos en que está interesado al llamar a uno o más métodos de File.

Análisis Los constructores de File y el método exists( ) se describen con detalle en la solución anterior. (Consulte Obtenga atributos de archivo, para conocer más detalles.) Como se mencionó, a menudo querrá confirmar que en realidad existe el archivo representado por un objeto de File antes de que trate de obtener información acerca de él. Esto se hace al llamar a exists( ). Para establecer los atributos de un archivo, usará uno o más de los siguientes métodos. Observe que setWritable( ) requiere Java 6 o posterior. boolean setLastModified(long nuevaHora)

Establece la estampa de tiempo del archivo en nuevaHora. Devuelve verdadero si se realiza correctamente. La hora se representa como el número de milisegundos a partir de 1 de enero de 1970. Puede obtener una hora en esta forma al usar la clase Calendar.

boolean setReadOnly( )

Hace que el archivo sea de sólo lectura. Devuelve verdadero si se realiza correctamente.

boolean setWritable(boolean puedeEscribirse, boolean quien)

Establece el atributo de permiso de escritura del archivo. Si puedeEscribirse es true, entonces las operaciones de escritura se habilitan. De otra manera, se niegan. Si quien es true, entonces el cambio sólo se aplica al propietario del archivo. De otra manera, el cambio se aplica de manera general. (Requiere Java 6 o posterior.)

Ejemplo En el siguiente ejemplo se muestra cómo establecer los atributos de un archivo. // Establezca atributos de archivo. // // Para usar el programa, especifique el nombre del archivo // en la línea de comandos. Por ejemplo, establezca los atributos // de un archivo prueba.pba, use la siguiente línea de comandos // // java EstablecerAtributosArchivo prueba.pba // import java.io.*; import java.util.*; class EstablecerAtributosArchivo { // muestra el estatus de lectura/escritura de un archivo. static void rwStatus(File f) {

88

Java: Soluciones de programación if(f.canRead( )) System.out.println(" De lectura"); else System.out.println(" No es de lectura"); if(f.canWrite( )) System.out.println(" De escritura"); else System.out.println(" No es de escritura"); } public static void main(String args[ ]) { // Primero, se asegura de que se ha especificado un archivo. if(args.length != 1) { System.out.println("Uso: EstablecerAtributosArchivo nombrearchivo"); return; } File f = new File(args[0]); // Confirma que existe el archivo. if(!f.exists( )) { System.out.println("No se ha encontrado el archivo."); return; } // Despliega el estado de lectura/escritura // y la estampa de tiempo originales. System.out.println("permisos originales de hora y lectura/escritura:"); rwStatus(f); System.out.println(" Modificado por \u00a3ltima vez el " + new Date(f.lastModified( ))); System.out.println( ); // Actualiza la estampa de tiempo. long t = Calendar.getInstance( ).getTimeInMillis( ); if(!f.setLastModified(t)) System.out.println("No se puede establecer la hora."); // Establece el archivo en sólo lectura. if(!f.setReadOnly( )) System.out.println("No puede establecerse como de s\u00a2lo lectura."); System.out.println("Permisos de lectura/escritura y hora modificados:"); rwStatus(f); System.out.println(" Modificado por \u00a3ltima vez el " + new Date(f.lastModified( ))); System.out.println( ); // Devuelve el estatus de lectura/escritura. if(!f.setWritable(true, false)) System.out.println("No puede regresar a lectura/escritura."); System.out.println("Ahora los permisos de lectura/escritura son: "); rwStatus(f); } }

Capítulo 3:

Manejo de archivos

89

Aquí se muestra la salida: Permisos originales de hora y lectura/escritura: De lectura De escritura Modificado por última vez el Thu Mar 27 19:25:35 CST 2008 Permisos de lectura/escritura y hora modificados: De lectura No es de escritura Modificado por última vez el Thu Mar 27 23:17:44 CST 2008 Ahora los permisos de lectura/escritura son: De lectura De escritura

Opciones Además del constructor usado por esta solución, File define otros tres. Consulte Obtenga atributos de archivos para conocer la descripción. Si está usando Java 6 o posterior y si su plataforma lo soporta, puede establecer un atributo de permiso ejecutable de un archivo al llamar a setExecutable( ). Tiene dos formas, que se muestran aquí: boolean setExecutable(boolean puedeEjecu) boolean setExecutable(boolean puedeEjecu, boolean quien) Si puedeEjecu es true, entonces se permiten las operaciones de ejecución. De otra manera, se niegan. La primera forma sólo afecta al propietario del archivo. En la segunda forma, si quien es true, el cambio se aplica sólo al propietario del archivo. Si quien es false, se aplica de manera general. Si está usando Java 6 o posterior, y si su plataforma lo soporta, puede establecer o limpiar el atributo de sólo lectura de un archivo al llamar a setReadable( ). Tiene dos formas, que se muestran aquí: boolean setReadable(boolean puedeLeer) boolean setReadable(boolean puedeLeer, boolean quien) Si puedeLeer es true, entonces se permiten las operaciones de lectura. De otra manera, se niegan. La primera forma afecta sólo al propietario del archivo. En la segunda forma, si quien es true, entonces el cambio sólo se aplica al propietario del archivo. Si es false, se aplica de manera general. Además de establecer los atributos de archivo, File también le permite eliminar un archivo, cambiar su nombre y crear un directorio. Aquí se muestran los métodos que lo hacen: boolean delete( )

Elimina un archivo (o un directorio vacío). Devuelve verdadero si es correcto.

boolean mkdir( )

Crea un directorio. Devuelve verdadero si se aplica correctamente.

boolean mkdirs( )

Crea toda una ruta de directorio (que incluye todos los directorios principales necesarios). Devuelve verdadero si se aplica correctamente.

boolean renameTo(File nuevoNombre)

Cambia el nombre del archivo por nuevoNombre. Devuelve verdadero si se aplica correctamente.

90


Elabore una lista de un directorio Componentes clave Clases

Métodos

java.io.File

File[ ] listFiles( ) File[ ] listFiles(FileFilter ff) String getName( ) Boolean isDirectory( )

java.io.FileFilter

boolean accept(File nombre)

Otra tarea común relacionada con archivos consiste en obtener una lista de los archivos dentro de un directorio. Por ejemplo, tal vez quiera obtener una lista de todos los archivos de un directorio para que puedan transmitirse a un sitio de respaldo o para que pueda confirmar que se han instalado apropiadamente todos los archivos de una aplicación. Cualquiera que sea el propósito, puede obtenerse una lista de directorios empleando convenientemente la clase File.

Paso a paso Java proporciona diversas maneras de obtener un listado de directorios. Para el método usado en esta solución se requieren estos pasos: 1. Cree un objeto de File que representa el directorio. 2. Confirme que existe el objeto de File y en realidad representa un directorio válido. (En los casos en que se sabe que el objeto de File representa un directorio existente, puede omitirse este paso). 3. Si quiere obtener una lista filtrada de archivos (como las que tienen una extensión de archivo especificada), cree un objeto de FileFilter que describe el patrón que los archivos deben cumplir. 4. Para obtener un listado de directorios, llame a listFiles( ) en el objeto de File. Devuelva una matriz de objetos de File que represente a los archivos en el directorio. Hay tres versiones de listFiles( ). Uno le da todos los archivos; los otros dos le permiten filtrar los archivos. 5. Para obtener el nombre del archivo, llame al método getName( ) de File. 6. Si sólo está interesado en archivos normales y no en directorios, use el método isDirectory( ) para determinar cuáles archivos representan directorios.

Análisis Consulte Obtenga atributos de archivos para conocer una descripción de los constructores de File y de los métodos exists( ) e isDirectory( ). Es importante comprender que un listado de directorios sólo puede obtenerse si el objeto de File representa un directorio. Por tanto, a menudo es necesario confirmar que el objeto es, por supuesto, un directorio válido antes de tratar de obtener la lista de archivos.

Capítulo 3:

Manejo de archivos

91

File define tres versiones de listFiles( ). La primera devuelve una matriz de cadenas que contiene todos los archivos (incluidos los que representan subdirectorios). Por tanto, obtiene una lista no filtrada de archivos. Se muestra aquí: File[ ] listFiles( ) Para obtener una lista de archivos filtrados, puede usar una de dos formas. La usada en esta solución se muestra aquí: File[ ] listFiles(FileFilter ff) Obtiene una lista de sólo los archivos (y directorios) que cumplen el criterio especificado por ff. Dado que la matriz contiene el listado de directorios, puede obtener el nombre de cada archivo al llamar a getName( ), que está definido por File. Aquí se muestra: String getName( ) Se devuelve la representación de cadena del archivo (o directorio). Para restringir la lista de archivos sólo a los que cumplen con ciertos criterios, implemente un FileFilter, que es una interfaz que sólo especifica un método accept( ). Aquí se muestra: boolean accept(File nombre) Este método debe devolver verdadero para archivos que quiera que sean parte del listado de directorios y falso para los que serán excluidos. Dependiendo de la manera en que implemente accept( ), puede usarse para incluir todos los archivos cuyos nombres llenan un patrón general. Por ejemplo, he aquí una implementación simple que acepta todos los archivos de origen de Java: // Un filtro de archivo simple para archivos de origen de Java. class ArchivosJava implements FileFilter { public boolean accept(File f) { if(f.getName( ).endsWith(".java")) return true; return false; } }

Para un filtrado más complejo, puede usar expresiones regulares. Con este método, puede crear fácilmente filtros que manejen comodines, busquen coincidencias alternas, ignoren diferencias entre mayúsculas y minúsculas, etc. (Una revisión general de las expresiones regulares se encuentra en el capítulo 2).

Ejemplo En el siguiente ejemplo se ilustran las formas filtradas y no filtradas de listFiles( ). Para usar el programa, especifique en la línea de comandos el nombre del directorio del que habrá de elaborarse una lista. El programa despliega primero todos los archivos del directorio especificado. Luego, usa un filtro para desplegar sólo los archivos fuente de Java. // // // // // // //

Despliega una lista de todos los archivos y subdirectorios en el directorio especificado en la línea de comandos. Por ejemplo, para desplegar la lista del contenido de un directorio llamado \MisProgramas, use java ListaArchivos \MisProgramas

import java.io.*;

92

Java: Soluciones de programación // Un filtro de archivo simple para archivos fuente de Java. class ArchivosJava implements FileFilter { public boolean accept(File f) { if(f.getName( ).endsWith(".java")) return true; return false; } } class ListaArchivos { public static void main(String args[ ]) { // Primero se asegura de que se ha especificado un archivo. if(args.length != 1) { System.out.println("Uso: ListaArchivos nombredir"); return; } File dir = new File(args[0]); // Confirma la existencia. if(!dir.exists( )) { System.out.println(args[0] + " no encontrado."); return; } // Confirma que es un directorio. if(!dir.isDirectory( )) { System.out.println(args[0] + " no es un directorio."); return; } File[ ] listaArchivos; // Obtiene una lista de todos los archivos. listaArchivos = dir.listFiles( ); // Despliega los archivos. System.out.println("Todos los archivos:"); for(File f : listaArchivos) if(!f.isDirectory( )) System.out.println(f.getName( )); // Obtiene una lista de archivos fuente de Java únicamente. // // Empieza por crear un filtro para los archivos .java. ArchivosJava aj = new ArchivosJava( ); // Ahora, pasa el archivo a list( ). listaArchivos = dir.listFiles(aj); // Despliega los archivos filtrados. System.out.println("\nArchivos fuente de Java:");

Capítulo 3:

Manejo de archivos

93

for(File f : listaArchivos) if(!f.isDirectory( )) System.out.println(f.getName( )); } }

Aquí se muestra una salida de ejemplo: Todos los archivos: VolcarHex.java EscribirBytes.java CopiarArchivoBufer.java MostrarArchivo.java CopiarInvertir.java EscribirCars.java VolcarHex.class EscribirBytes.class CopiarArchivoBufer.class EscribirCars.class CopiarInvertir.class MostrarArchivo.class Archivos fuente de Java: VolcarHex.java EscribirBytes.java CopiarArchivoBufer.java MostrarArchivo.java CopiarInvertir.java EscribirCars.java

Ejemplo adicional Las capacidades de las expresiones regulares le permiten crear filtros de archivo muy poderosos que usan complejos filtros con comodines. Las expresiones regulares también le permiten implementar filtros que aceptan una o más opciones. Por ejemplo, puede crear un filtro de archivo que acepta archivos que terminan en ".class" o ".java". He aquí otro ejemplo. Con el uso de expresiones regulares, puede crear un filtro de archivo que acepte archivos que contengan cualquiera de estas dos subcadenas: "bytes" o "cars". Este filtro aceptaría estos nombres de archivo: EscribirBytes.java EscribirCars.java Mediante el uso de expresiones regulares, las capacidades de un filtro de archivo son casi ilimitadas. Una de las maneras más fáciles para usar una expresión regular en un filtro de archivo consiste en usar el método matches( ) de String. Recordará del capítulo 2 que tiene esta forma general: boolean matches(String expReg) Devuelve verdadero si la expresión regular encuentra una coincidencia en la cadena que invoca; de lo contrario, es falso.

94

Java: Soluciones de programación He aquí un filtro de archivo que usa una expresión regular para buscar todos los archivos cuyo nombre contiene la secuencia "cars" o "bytes". Observe que ignora las mayúsculas y minúsculas de las letras // Un filtro de archivo que acepta nombres que incluyen // "bytes" o "cars". class MiFf implements FileFilter { public boolean accept(File f) { if(f.getName( ).matches(".*(?i)(bytes|cars).*")) return true; return false; } }

Si se aplica este filtro a la misma dirección usada en el ejemplo anterior, se aceptan los siguientes archivos: EscribirBytes.java EscribirCars.java EscribirBytes.class EscribirCars.class

Puede probar este filtro al sustituirlo en el programa de ejemplo anterior. Tal vez quiera experimentar con él un poco, probando diferentes patrones. Encontrará que las expresiones regulares ofrecen una tremenda cantidad de capacidad y control sobre el proceso de filtrado.

Opciones Como se acaba de describir, listFiles( ) devuelve la lista de archivos como una matriz de objetos de File. Esta suele ser la forma que usted querrá. Sin embargo, puede obtener una lista que contiene sólo los nombres de los archivos en una matriz de objetos de String. Esto se hace al usar el método list( ), que también está definido por File. Hay dos versiones de list( ). La primera obtiene todos los archivos. Por tanto, obtiene una lista de archivos no filtrados. Se muestra aquí: String[ ] list( ) Para obtener una lista de archivos filtrados, use esta segunda forma de list( ): String[ ] list(FilenameFilter fnf) Obtiene una lista sólo de los archivos que cumplen el criterio especificado por fnf. Observe que la forma filtrada de list( ) usa un FilenameFilter, en lugar de un FileFilter. FilenameFilter es una interfaz que ofrece una manera alterna de construir un filtro: sólo especifica un método, accept( ), que se muestra aquí: boolean accept(File dir, String nombre) En este método, el directorio se pasa a dir y el nombre de archivo a name. Debe devolver verdadero para archivos que coinciden con el nombre de archivo especificado por nombre. De otra manera, devuelve falso. Puede usar FilenameFilter con listFiles( ) para obtener una lista de archivos filtrada. Aquí se muestra esta forma de listFiles( ): File[ ] listFiles(FilenameFilter fnf)

Capítulo 3:

Manejo de archivos

95

Comprima y descomprima datos Componentes clave Clases

Métodos

java.util.zip.DeflaterOutputStream

void write(int valbyte) void close( )

java.util.zip.InflaterInputStream


Como se mencionó cerca del principio del capítulo, Java proporciona clases de flujo que comprimen y descomprimen automáticamente los datos. Estas clases están empaquetadas en java.util.zip. Cuatro de estas clases se usan para leer y escribir archivos GZIP y ZIP estándares. Sin embargo, también es posible usar el algoritmo de compresión directamente, sin crear uno de estos archivos estándar. Hay una muy buena razón por la que desearía hacer esto: le permite a su aplicación operar de manera directa sobre datos comprimidos. Esto podría resultar especialmente valioso cuando se usan archivos de datos muy grandes. Por ejemplo, una base de datos que contiene un inventario de un vendedor en línea muy grande podría contener varios miles de entradas. Al almacenar esa base de datos en forma comprimida, su tamaño puede reducirse de manera importante. Debido a que los flujos de archivo comprimidos de Java le dan la capacidad de leer y escribir un archivo comprimido directamente, todas las operaciones de archivo pueden tomar lugar sobre el archivo comprimido, sin la necesidad de crear una copia descomprimida. En esta solución se muestra la manera de implementar este esquema. Como verá, el uso de datos comprimidos es muy fácil porque incluye una capa superior casi transparente para el manejo básico de archivos requerido por la aplicación. En la base de la biblioteca de compresión se encuentran las clases Deflater e Inflater. Proporcionan el algoritmo que comprime y descomprime los datos. Como se mencionó cerca del inicio de este capítulo, la implementación predeterminada de estas clases usa la biblioteca de compresión ZLIB. Los flujos de datos comprimidos, definidos por java.util.zip, usan las implementaciones predeterminadas de estas clases. Estas implementaciones predeterminadas son adecuadas para casi todas las tareas de compresión, y por lo general no necesitará interactuar directamente con Deflater o Inflater. En esta solución se usa DeflaterOutputStream para escribir en un archivo de datos comprimidos e InflaterInputStream para leer un archivo de datos comprimido. DeflaterOutputStream se deriva de OutputStream y FilterOutputStream e implementa las interfaces Closeable y Flushable. InflaterInputStream se deriva de InputStream y FilterInputStream e implementa la interfaz Closeable.

Paso a paso Para comprimir datos y escribirlos en un archivo se requieren estos pasos: 1. Cree un flujo de archivo que use DeflaterOutputStream. 2. Escriba la salida en la instancia de DeflaterOutputStream. Puede usar uno de los métodos estándar de write( )para escribir los datos. Sin embargo, a menudo un DeflaterOutputStream se envuelve en un DataOutputStream, que le permite escribir convenientemente tipos de datos primitivos, como int y double. En cualquier caso, los datos se comprimirán automáticamente. 3. Cierre el flujo de salida cuando termine de escribir.

96

Java: Soluciones de programación Para leer los datos de un archivo comprimido se requieren estos pasos: 1. Cree un flujo de archivo que use InflaterInputStream. 2. Lea de la instancia de InflaterInputStream. Puede usar uno de los métodos estándar de read( ) para leer los datos. Sin embargo, a menudo InflaterInputStream está envuelto en un DataInputStream, que le permite leer convenientemente tipos de datos primitivos, como int o double. En cualquier caso, los datos se descomprimirán automáticamente. 3. Cierre el flujo de entrada cuando haya terminado de escribir.

Análisis DeflaterOutputStream e InflaterInputStream son el núcleo de las capacidades de compresión de archivos de Java. Pueden usarse explícitamente (como se hace en la solución), o implícitamente cuando crea un archivo GZIP o ZIP. DeflaterOutputStream escribe datos en un archivo, comprimiéndolos en el proceso. InflaterInputStream lee los datos de un archivo, descomprimiéndolos en el proceso. DeflaterOutputStream e InflaterInputStream definen tres constructores, cada uno. He aquí los usados en esta solución. DeflaterOutputStream(OutputStream flujoSal) InflaterInputStream(InputStream flujoEnt) Aquí, flujoSal especifica el flujo de salida y flujoEnt especifica el de entrada. Estos constructores usan el compresor y el descompresor predeterminados. Como se mencionó, éstos son objetos de tipo Inflater y Deflater. Proporcionan los algoritmos que realizan la compresión y descompresión real de los datos. Los otros constructores le permiten especificar un compresor o descompresor, y un tamaño de búfer. Sin embargo, el compresor, el descompresor y el tamaño de búfer son adecuados para casi todas las tareas. Una vez que están abiertos los flujos basados en compresión, la compresión y la descompresión ocurren automáticamente cada vez que tiene lugar una operación de escritura o lectura. Por tanto, los datos contenidos en un archivo escrito por DeflaterOutputStream estarán en un formato comprimido. Los datos leídos de un archivo comprimido mediante un InflaterInputStream, estarán en su formato descomprimido (es decir, simple). Esto significa que puede almacenar datos en forma comprimida, pero su programa tendrá transparente a él (como si estuvieran almacenados en un archivo no comprimido). Esta es una de las razones por las que la biblioteca de compresión de Java es tan poderosa. Para escribir datos, puede usar cualquier de los métodos estándar de write( ) definidos por OutputStream. Para leer datos, puede usar cualquiera de los métodos estándar de read( ) definidos por InputStream. (Estos se describen en Escriba bytes en un archivo y Lea bytes de un archivo.) Sin embargo, a menudo es mejor envolver DeflaterOutputStream en un DataOutputStream y envolver InflaterInputStream en un DataInputStream. Al hacerlo así se tiene a métodos como writeInt( ), writeDouble( ), readInt( ) y readDouble( ), que le permiten leer y escribir datos primitivos de manera conveniente.

Ejemplo En el siguiente ejemplo se muestra cómo crear un archivo de datos comprimido y luego leer los datos en el archivo. El archivo de datos es una colección de valores double. Sin embargo, el archivo empieza con un entero que contiene una cuenta de double en el archivo. Tome en cuenta que DeflaterOutputStream está envuelto en un DataOutputStream. InflaterInputStream está envuelto en un DataInputStream.

Capítulo 3:

Manejo de archivos

97

Esto permite que valores de tipos primitivos, como int o double, se escriban de manera conveniente en una forma comprimida y que luego se vuelvan a leer. El programa crea el archivo de datos al escribir una matriz de seis valores double en un archivo llamado datos.cmprs. En primer lugar, escribe una cuenta del número de valores que seguirá al llamar a writeInt( ). La cuenta es seis, en el ejemplo. Luego escribe los valores double al llamar a writeDouble( ). Debido a que se usa DeflaterOutputStream, los datos se comprimen automáticamente antes de almacenarse en el archivo. El programa lee después los valores. Hace esto al obtener primero la cuenta al llamar a readInt( ). Luego lee ese número de valores al llamar a readDouble( ). En el proceso, promedia los valores. Lo que es importante comprender es que el archivo se comprime y descomprime "al vuelo". En ningún momento existe una versión descomprimida del archivo. Es interesante observar que el archivo comprimido que crea el programa tiene 36 bytes de largo. Sin compresión, el archivo tendría 52 bytes. // // // // // // // // //

Crea un archivo comprimido de datos al usar un DeflaterOutputStream y luego leer los datos con un InflaterInputStream. Este programa usa la biblioteca de compresión predeterminada de Java, que es ZLIB. El archivo comprimido creado por este programa no está en un formato específico, como ZIP or GZIP. Simplemente contiene una versión comprimida de los datos.

import java.io.*; import java.util.zip.*; class DemoCompresion { public static void main(String args[ ]) { DataOutputStream fout; DataInputStream fin; double datos[ ] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 }; // Abre el archivo de salida. try { fout = new DataOutputStream( new DeflaterOutputStream( new FileOutputStream("datos.cmprs"))); } catch(FileNotFoundException exc) { System.out.println("Error al abrir el archivo de salida"); return; } // Comprime los datos usando ZLIB. try { // Sólo escribe los datos normalmente. El // DeflaterOutputStream los descomprimirá // automáticamente.

98

Java: Soluciones de programación // Primero, escribe el tamaño de los datos. fout.writeInt(datos.length); // Ahora, escribe los datos. for(double d : datos) fout.writeDouble(d); } catch(IOException exc) { System.out.println("Error en el archivo comprimido"); } try { fout.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de salida"); } // Ahora, abre datos.cmprs para entrada. No es necesario // crear una copia descomprimida del archivo porque la // descompresión se maneja al vuelo, con InflaterInputStream. // Así, la descompresión es automática y transparente. try { fin = new DataInputStream( new InflaterInputStream( new FileInputStream("datos.cmprs"))); } catch(FileNotFoundException exc) { System.out.println("No se ha encontrado el archivo de entrada"); return; } // Descomprime el archivo al vuelo. try { // Primero, recupera la cantidad de datos // contenidos en el archivo. int num = fin.readInt( ); double prom = 0.0; double d; System.out.print("Datos: "); // Ahora, lee los datos. La descompresión es automática. for(int i=0; i < num; i++) { d = fin.readDouble( ); prom += d; System.out.print(d + " "); } System.out.println("\nEl promedio es " + prom / num);

Capítulo 3:

Manejo de archivos

99

} catch(IOException exc) { System.out.println("Error al leer el archivo de entrada"); } try { fin.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de entrada"); } } }

Aquí se muestra la salida: Datos: 1.1 2.2 3.3 4.4 5.5 6.6 El promedio es 3.85

Opciones Como se mencionó, tanto DeflaterOutputStream como InflaterInputStream ofrecen constructores que le permiten especificar el compresor, el descompresor o el tamaño del búfer. La biblioteca de compresión también soporta sumas de verificación a través de las siguientes clases: Alder32 y CRC32. Puede crear flujos que usan una suma de verificación con estas clases: CheckedInputStream y CheckedOutputStream. Aunque usar DeflaterOutputStream e InflaterInputStream directamente es aceptable, a menudo querrá usar sus subclases: GZIPInputStream GZIPOutputStream ZipInputStream ZipOutputStream Estas clases crean archivos comprimidos en formato GZIP o ZIP. La ventaja es que sus archivos de datos estarán en un formato que las herramientas estándar pueden comprender. Sin embargo, si eso no otorga beneficios a su aplicación, entonces el uso directo de DeflaterOutputStream e InflaterInputStream es un poco más eficiente. (En las siguientes soluciones se muestra cómo crear, comprimir y descomprimir un archivo ZIP).

100


Cree un archivo ZIP Componentes clave Clases

Métodos

java.util.zip.ZipInputStream

void closeEntry( ) ZipEntry getNextEntry( )

java.util.zip.ZipOutputStream

void closeEntry( ) void putNextEntry(ZipEntry ze) void write(int val)

java.util.zip.ZipEntry

long getCompressedSize( ) long GetSize( )

Hay dos formatos de archivo comprimido muy populares: GZIP y ZIP. Java proporciona soporte a ambos. La creación de un archivo GZIP es fácil: simplemente cree un GZIPOutputStream y luego escriba en él. Leer un archivo GZIP es igualmente fácil: sólo cree un GZIPInputStream y luego léalo. Sin embargo, la situación es un poco más complicada si quiere crear un archivo ZIP. En esta solución se crea el procedimiento básico. Antes de empezar, es importante tomar en cuenta que los archivos ZIP pueden ser muy complejos. En esta solución se muestra cómo crear un esqueleto básico. Si estará trabajando ampliamente con archivos ZIP, necesitará estudiar de cerca las especificaciones tanto de java.util. zip como del propio archivo ZIP. En general, un archivo ZIP puede contener uno o más archivos comprimidos. Cada archivo está asociado con una entrada que describe el archivo. Se trata de un objeto de tipo ZipEntry. Este tipo de objetos identifica a cada archivo dentro del archivo ZIP. Por tanto, para comprimir un archivo, primero escribirá su ZipEntry y luego sus datos.

Paso a paso La creación de un archivo ZIP que contenga uno o más archivos comprimidos incluye estos pasos: 1. Cree el archivo ZIP al abrir un ZipOutputStream. Cualquier dato escrito en este flujo se comprimirá automáticamente. 2. Abra el archivo que se comprimirá. Puede usar cualquier flujo de archivo apropiado, como FileInputStream envuelto en un BufferedInputStream. 3. Cree una ZipEntry para representar el archivo que se está comprimiendo. A menudo el nombre de este archivo se vuelve el nombre de la entrada. Escriba la entrada en la instancia ZipOutputStream al llamar a putNextEntry( ). 4. Escriba el contenido del archivo de entrada en el ZipOutputStream. Los datos se comprimirán automáticamente. 5. Cierra la ZipEntry del archivo de entrada al llamar a closeEntry( ). 6. Por lo general, querrá reportar el progreso de la compresión, incluido el tamaño de reducción del archivo. Para ayudarle en esto, ZipEntry proporciona getSize( ), que obtiene el tamaño sin comprimir del archivo, y getCompressedSize( ), que obtiene el tamaño comprimido.

Capítulo 3:

Manejo de archivos

101

7. Repita del paso 3 al 5 hasta que se hayan escrito todos los archivos que desea almacenar en el archivo ZIP. 8. Cierre los archivos.

Análisis Para crear un archivo ZIP, usará una instancia de ZipOutputStream. Los datos escritos en un ZipOutputStream se comprimen automáticamente en un archivo ZIP. ZipOutputStream se deriva de DeflaterOutputStream e implementa las interfaces Closeable y Flushable. Sólo define al constructor, que se muestra aquí: ZipOutputStream(OutputStream flujo) El flujo que recibirá los datos comprimidos se especifica con flujo. Esto normalmente será una instancia de FileOutputStream. Antes de que pueda comprimir un archivo, debe crear una instancia de ZipEntry que representa el archivo y escribe la entrada en el archivo ZIP. Por tanto, cada archivo almacenado en un archivo ZIP está asociado con una instancia de ZipEntry, que define dos constructores. El que usaremos es ZipEntry(String nombreEntrada) Aquí, nombreEntrada especifica el nombre de la entrada. Por lo general, será el nombre del archivo que se está almacenando. Para escribir la ZipEntry en el archivo, llame a putNextEntry( ) en la instancia de ZipOutputStream. Aquí se muestra: void putNextEntry(ZipEntry encabezado) throws IOException La entrada que habrá de escribirse se pasa en ze. Se lanza una IOException si ocurre un error de E/S. También se lanzará una ZipException en el caso de un error de formato. Debido a que se trata de una subclase de IOException, a menudo basta con el manejo de ésta última. Sin embargo, querrá manejar ambas excepciones individualmente cuando se necesita mayor control. Después de que se ha escrito ZipEntry, puede escribir los datos comprimidos en el archivo. Esto se logra con sólo llamar a uno de los métodos de write( ) soportados por ZipOutputStream. El que se usa aquí es void write(int val) throws IOException Por supuesto, esto es simplemente una sobreescritura del mismo método definido por OutputStream. Esta versión lanza una IOException si ocurre un error de E/S. Cuando se escriben datos en la instancia de ZipOutputStream, se comprimen automáticamente. Después de que se ha escrito el archivo, debe cerrar su entrada al llamar a closeEntry( ), que se muestra aquí: void closeEntry( ) throws IOException Se lanza una IOException si ocurre un error de E/S. También lanzará una ZipException en el caso de un error de formato.

102


Usted determina la efectividad de la compresión al llamar a getSize( ) y getCompressedSize( ) en la ZipEntry asociada con un archivo. Aquí se muestran: long getSize( ) long getCompressedSize( ) El tamaño sin comprimir es devuelto por getSize( ); el comprimido, por getCompressedSize( ). Ambos métodos devuelven –1 si el tamaño no está disponible. Debe cerrarse la ZipEntry asociada con el archivo antes de que se llame a los métodos. Cuando haya terminado de comprimir todos los archivos que se almacenarán en el archivo ZIP, cierre todos los flujos. Esto incluye el ZipOutputStream. Tenga en cuenta que la versión de close( ) implementada por ZipOutputStream lanzará una IOException si ocurre un error de E/S y una ZipException en el caso de un error de formato.

Ejemplo En el siguiente ejemplo se pone la solución en acción. Puede usarse para crear un archivo ZIP que contenga la forma comprimida de uno o más archivos. Para usar el programa, especifique el nombre del archivo ZIP, luego la lista de archivos que habrán de comprimirse. Por ejemplo, para comprimir los archivos ejemploA.dat y ejemploB.dat en un archivo llamado ejemplos.zip, use la siguiente línea de comandos: java Zip ejemplos.zip ejemploA.dat ejemploB.dat

Mientras se ejecuta el programa, se reporta el avance. Esto incluye el nombre del archivo que se está comprimiendo, su tamaño original y su tamaño una vez comprimido. Como suele ser el caso, el programa usa los nombres de los archivos como nombres de las entradas de ZipEntry. Sin embargo, hay un punto importante que debe comprenderse acerca del programa. No almacena ninguna información de ruta de directorio para los archivos. Si un nombre de archivo tiene una ruta asociada con él, se elimina cuando se crea la ZipEntry. (Observe que se usa File.separator para especificar el carácter separador. Esto se debe a que difiere entre Unix y Windows). Como la mayoría de los lectores sabe, las herramientas ZIP más populares le dan la opción de incluir nombre de ruta o ignorarlos. Sin embargo, esto se le deja como ejercicio. // // // // // // // // // // // // // // // // //

Crea un archivo ZIP simple. Para usar este programa, especifique el nombre del archivo que recibirá los datos comprimidos y uno o más archivos de origen que contiene los datos que habrán de comprimirse. Este programa no retiene ninguna información de ruta de directorio sobre los archivos que habrán de comprimirse. Por ejemplo, para comprimir los archivos ejemploA.dat y ejemploB.dat en un archivo llamado ejemplos.zip, use la siguiente línea de comandos: java Zip ejemplos.zip ejemploA.dat ejemploB.dat

Capítulo 3:

Manejo de archivos

import java.io.*; import java.util.zip.*; class Zip { // Elimina cualquier información de ruta de un // nombre de archivo. static String elimRuta(String nombreAr) { int pos = nombreAr.lastIndexOf(File.separatorChar); if(pos > –1) nombreAr = nombreAr.substring(pos+1); return nombreAr; } public static void main(String args[ ]) { BufferedInputStream fin; ZipOutputStream fout; // Primero se asegura de que se hayan especificado // los archivos. if(args.length < 2) { System.out.println("Uso: Zip <listaarchivos>"); return; } // Abre el archivo de salida. try { fout = new ZipOutputStream( new BufferedOutputStream( new FileOutputStream(args[0]))); } catch(FileNotFoundException exc) { System.out.println("Error al abrir el archivo de salida"); return; } for(int n=1; n < args.length; n++) { // Abre el archivo de entrada. try { fin = new BufferedInputStream( new FileInputStream(args[n])); } catch(FileNotFoundException exc) { System.out.println("No se ha encontrado el archivo de entrada"); // Cierra el archivo de salida abierto. try { fout.close( ); } catch(ZipException exc2) { System.out.println("Archivo ZIP no v\u00a0lido"); } catch(IOException exc2) { System.out.println("Error al cerrar el archivo de salida"); } return; }

103

104

Java: Soluciones de programación // Crea la siguiente ZipEntry. En este programa, // no se retiene información de ruta de directorios, // así que se elimina primero cualquier ruta asociada // con el nombre de archivo al llamar a elimRuta( ). ZipEntry ze = new ZipEntry(elimRuta(args[n])); // Comprime el siguiente archivo. try { fout.putNextEntry(ze); int i; do { i = fin.read( ); if(i != –1) fout.write(i); } while(i != –1); fout.closeEntry( ); } catch(ZipException exc) { System.out.println("Archivo ZIP no v\u00a0lido"); } catch(IOException exc) { System.out.println("Error de archivo de salida"); } try { fin.close( ); // Reporta el progreso y el tamaño de la reducción. System.out.println("Comprimiendo " + args[n]); System.out.println(" Tama\u00a4o original: " + ze.getSize( ) + " Tama\u00a4o comprimido: " + ze.getCompressedSize( ) + "\n"); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de entrada"); } } try { fout.close( ); } catch(ZipException exc2) { System.out.println("Archivo ZIP no v\u00a0lido"); } catch(IOException exc) { System.out.println("Error al cerrar el archivo ZIP"); } }

}

He aquí una ejecución de ejemplo: Comprimiendo VolcarHex.java Tamaño original: 1384 Tamaño comprimido: 612 Comprimiendo EscribirBytes.java Tamaño original: 895 Tamaño comprimido: 428

Capítulo 3:

Manejo de archivos

105

Opciones La clase ZipEntry le da la capacidad de establecer u obtener el valor de varios atributos relacionados con una entrada de archivo ZIP. Puede obtener el nombre de la entrada al llamar a getName( ); puede establecerlo al llamar a setName( ). Puede establecer la hora de creación de la entrada al llamar a setTime( ); puede obtenerla al llamar a getTime( ). Como opción predeterminada, se usa la hora actual del sistema. Hay un método que podría resultar muy útil: isDirectory( ). Devuelve verdadero si la entrada representa un directorio. Sin embargo, hay un pequeño problema con este método, porque sólo devuelve verdadero si el nombre de la entrada termina con /. (Esto es para seguir la especificación del archivo ZIP). Sin embargo, como la mayoría de los lectores sabe, los entornos Windows usan \ como separador de ruta. Por tanto, isDirectory( ) no funciona apropiadamente cuando se le da una ruta de Windows. Hay maneras obvias de evitar esta limitación, como sustituir cada \ con / cuando se crea el nombre de la entrada. Puede experimentar con esta y otras soluciones si quiere almacenar información de directorios.


Métodos

java.util.zip.ZipEntry

long getCompressedSize( ) long getSize( ) String getName( )

java.util.zip.ZipFile

void close( ) Enumeration entries( ) InputStream getInputStream(ZipEntry ze)

En la solución anterior se mostraron los pasos necesarios para crear un archivo ZIP. En esta solución se describe la manera de descomprimir un archivo ZIP. Hay dos métodos generales que puede usar para descomprimir un archivo ZIP. El primero usa ZipInputStream para obtener cada entrada en el archivo ZIP. Aunque no hay nada malo en esto, es necesario manejar manualmente el proceso. El segundo método usa ZipFile para afinar el proceso. Este es el método que se emplea en esta solución.

Paso a paso La descompresión de un archivo ZIP incluye los siguientes pasos: 1. 2.

Abra el archivo ZIP al crear una instancia de ZipFile. Obtenga una enumeración de las entradas del archivo ZIP al llamar a entries( ) en la instancia de ZipFile.

106

Java: Soluciones de programación 3.

Recorra en ciclo la enumeración de las entradas, descomprimiendo cada entrada, por turno, como se describe en los pasos siguientes. 4. Obtenga el flujo de una entrada al llamar a getInputStream( ) en la entrada actual. 5. Obtenga el nombre de la entrada al llamar a getName( ) y úsela como nombre del flujo de salida que recibirá el archivo descomprimido. 6. Para descomprimir la entrada, copie bytes del flujo de entrada al de salida. La descompresión es automática. 7. Por lo general, querrá reportar el progreso de la descompresión, incluido el tamaño de los archivos comprimido y expandido. Para hacer esto puede usar métodos proporcionados por ZipEntry. Para obtener el tamaño descomprimido de un archivo llame a getSize( ). Para obtener el tamaño comprimido, llame a getCompressedSize( ). 8. Cierre los flujos de entrada y de salida. 9. Repita del paso 4 al 7, hasta que se hayan descomprimido todas las entradas. 10. Cierre la instancia de ZipFile.

Análisis La manera más fácil de descomprimir un archivo ZIP consiste en usar ZipFile, porque afina el proceso de encontrar y leer cada entrada del archivo. Proporciona tres constructores. El usado aquí es: ZipFile(String nombreArchivoZip) throws IOException El nombre del archivo ZIP que se descomprimirá se especifica con nombreArchivoZip. Se lanza una IOException si ocurre un error de E/S. Se lanza una ZipException si se especifica un archivo ZIP que no es válido. ZipException es una subclase de IOException. Por tanto, al capturar una IOException se manejarán ambas excepciones. Sin embargo, para un manejo de errores más preciso, es necesario manejar ambas excepciones individualmente. Puede obtenerse una enumeración de las entradas en el archivo ZIP al llamar a entries( ) en la instancia de ZipFile. Aquí se muestra: Enumeration entries( ) Empleando la enumeración devuelta por entries( ) puede recorrer en ciclo las entradas del archivo, descomprimiendo cada una por turnos. (También omite una entrada, si lo desea. No hay una regla que diga que debe descomprimir todas las entradas de un archivo ZIP). Para obtener un flujo de entrada, llame a getInputStream( ) en la instancia de ZipFile. Aquí se muestra: InputStream getInputStream(ZipEntry ze) throws IOException El flujo leerá de la entrada pasada en ze. Se lanza una IOException si ocurre un error de E/S. Se lanza una ZipException si la entrada está en un formato inadecuado. Puede obtener el nombre de la entrada al llamar a getName( ) en la instancia de ZipEntry. Aquí se muestra: String getName( ) Puede usar entonces el nombre de la entrada como nombre del archivo de salida restaurado (es decir, descomprimido).

Capítulo 3:

Manejo de archivos

107

Una vez que haya descomprimido todas las entradas del archivo, debe cerrar la instancia de ZipFile al llamar a close( ), como se muestra aquí: void close( ) throws IOException Además de cerrar el archivo ZIP, también cerrará cualquier flujo abierto por llamadas a getInputStream( ). (Sin embargo, prefiero no depender de esto. En cambio, prefiero cerrar cada flujo de entrada por separado, a medida que avanza la descompresión, para no tener varios flujos abiertos, pero sin usar, con recursos asignados). Los tamaños de las entradas comprimida y descomprimida pueden obtenerse al llamar a getCompressedSize( ) y getSize( ), respectivamente. Estos métodos se describieron en la solución anterior. Puede usar esta información para proporcionar retroalimentación acerca del progreso de la descompresión.

Ejemplo En el siguiente ejemplo se descomprime un archivo ZIP. Reconocerá un nombre de ruta completo para la entrada, pero no creará la ruta del directorio, si no existe. Se trata de una capacidad que puede agregar, si lo desea. // // // // // // // // // // // // // //

Descomprime un archivo ZIP. Para usar este programa, especifique el nombre del archivo comprimido. Por ejemplo, para descomprimir un archivo llamado ejemplo.zip use la siguiente línea de comandos: java Unzip ejemplo.zip Nota: este programa descomprimirá una entrada que incluye información de ruta de directorios, pero no creará la ruta del directorio, si aún no existe.

import java.io.*; import java.util.zip.*; import java.util.*; class Unzip { public static void main(String args[ ]) { BufferedInputStream fin; BufferedOutputStream fout; ZipFile zf; // Primero se asegura de que se ha especificado un // archivo de entrada. if(args.length != 1) { System.out.println("Uso: Unzip nombre"); return; }

108

Java: Soluciones de programación // Abre el archivo zip. try { zf = new ZipFile(args[0]); } catch(ZipException exc) { System.out.println("Archivo ZIP no v\u00a0lido"); return; } catch(IOException exc) { System.out.println("Error al abrir el archivo ZIP"); return; } // Obtiene una enumeración de las entradas en el archivo. Enumeration archivos = zf.entries( ); // Descomprime cada entrada. while(archivos.hasMoreElements( )) { ZipEntry ze = archivos.nextElement( ); System.out.println("Descomprimiendo " + ze.getName( )); System.out.println(" Tama\u00a4o comprimido: " + ze.getCompressedSize( ) + " Tama\u00a4o expandido: " + ze.getSize( ) + "\n"); // Abre el flujo en la entrada especificada. try { fin = new BufferedInputStream(zf.getInputStream(ze)); } catch(ZipException exc) { System.out.println("Archivo ZIP no v\u00a0lido"); break; } catch(IOException exc) { System.out.println("Error al abrir la entrada"); break; } // Abre el archivo de salida. Usa el nombre proporcionado // por la entrada. try { fout = new BufferedOutputStream( new FileOutputStream(ze.getName( ))); } catch(FileNotFoundException exc) { System.out.println("No se puede crear el archivo de salida"); // Cierra el flujo de entrada abierto. try { fin.close( ); } catch(IOException exc2) { System.out.println("Error al cerrar el archivo ZIP de entrada"); } break; }

Capítulo 3:

Manejo de archivos

// Descomprime la entrada. try { int i; do { i = fin.read( ); if(i != –1) fout.write(i); } while(i != –1); } catch(IOException exc) { System.out.println("Error de archivo mientras se descomprime"); } // Cierra el archivo de salida para la entrada actual. try { fout.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo de salida"); } // Cierra el flujo para la entrada actual. try { fin.close( ); } catch(IOException exc) { System.out.println("Error al cerrar la entrada"); } } // Cierra el archivo Zip. try { zf.close( ); } catch(IOException exc) { System.out.println("Error al cerrar el archivo Zip"); } } }

Aquí se muestra la salida de ejemplo: Descomprimiendo VolcarHex.java Tamaño comprimido: 612 Tamaño expandido: 1384 Descomprimiendo EscribirBytes.java Tamaño comprimido: 428 Tamaño expandido: 895

Opciones ZipFile proporciona dos constructores adicionales, que se muestran aquí: ZipFile(File f) throws ZipException, IOException ZipFile(File f, int como) throws IOException Cada uno abre el archivo ZIP especificado por f. El valor de cómo debe ser ZipFile.OPEN_READ o ZipFile.OPEN_READ | ZipFile.OPEN_DELETE

109

110


Cuando se especifica OPEN_DELETE, habrá de eliminarse el archivo ZIP. Sin embargo, aún podrá leer el archivo a través de la instancia de ZipFile abierta. Esta opción le permite borrar automáticamente un archivo ZIP después de que se ha descomprimido. Por ejemplo, si sustituye esta línea en el ejemplo, eliminará el archivo ZIP después de descomprimirlo: zf = new ZipFile(new File(args[0]), ZipFile.OPEN_READ | ZipFile.OPEN_DELETE);

Por supuesto, debe usar esta opción con cuidado porque borra el archivo ZIP, lo que significa que no puede usarse nuevamente más adelante. Y un tema adicional: el segundo constructor también puede lanzar una ZipException. Si quiere extraer una entrada específica de un archivo ZIP, puede llamar a getEntry( ) en la instancia de ZipFile. Aquí se muestra cómo: ZipEntry getEntry(String nombreent) El nombre de la entrada se pasa en nombreent. Se devuelve una ZipEntry para la entrada. Si ésta no se puede encontrar, se devuelve null.

Serialice objetos Componentes clave Clases

Métodos

java.io.ObjectInputStream

void close( ) Object readObject( )

java.io.ObjectOutputStream

void close( ) void writeObject(Object objetivo)

Serializable

Además de bytes, caracteres y tipos primitivos de Java, también puede escribir objetos en un archivo. Una vez almacenados, estos objetos pueden leerse y restaurarse. Al proceso se le denomina serialización, la cual se utiliza por diferentes propósitos, incluidos el almacenamiento de datos que consta de objetos e invocación a métodos remotos (RMI, Remote Method Invocation). Debido a que un objeto puede contener referencias a otros objetos, la serialización de objetos puede incluir un proceso muy sofisticado. Por fortuna, java.io proporciona las clases ObjectOutputStream y ObjectInputStream para manejar esta tarea. En esta solución se describen los procedimientos básicos necesarios para guardar y restaurar un objeto. ObjectOutputStream extiende OutputStream e implementa la interfaz ObjectOutput, que extiende la interfaz DataOutput. ObjectOutput agrega el método writeObject( ), que escribe objetos en un flujo. ObjectOutputStream también implementa las interfaces Closeable y Flushable, junto con ObjectStreamConstants.

Capítulo 3:

Manejo de archivos

111

ObjectInputStream extiende InputStream e implementa la interfaz ObjectInput, que extiende la interfaz DataInput. ObjectInput agrega el método readObject( ), que lee objetos de un flujo. ObjectInputStream también implementa las interfaces Closeable y ObjectStreamConstants. Con el fin de que un objeto se serialice, su clase debe implementar la interfaz Serializable. Ésta no define . Simplemente se usa para indicar que una clase puede serializarse. Si una clase es serializable, todas sus clases también lo son. Sin embargo, las variables declaradas como transient no se guardan en las partes de serialización. Además, las variables static no se guardan. Por tanto, la serialización guarda el estado actual del objeto. Un tema adicional: la solución que se muestra aquí serializa un objeto usando el mecanismo predeterminado proporcionado por ObjectInputStream y ObjectOutputStream. Es posible tomar control manual del proceso, pero esas técnicas están más allá del alcance de este libro.

Paso a paso Guardar un objeto en un archivo incluye estos pasos: 1. Asegúrese de que el objeto que quiere guardar implementa la interfaz Serializable. 2. Abra el archivo al crear un objeto ObjectOutputStream. 3. Escriba el objeto en el archivo al llamar a writeObject( ). 4. Cierre el flujo cuando haya terminado. Leer un objeto de un archivo requiere estos pasos: 1. Abra el archivo al crear un objeto ObjectInputStream. 2. Lea el objeto del archivo al llamar a readObject( ). Debe cambiar el objeto al tipo que se está leyendo. 3. Cierre el flujo cuando haya terminado.

Análisis La clase ObjectOutputStream se usa para escribir objetos en un flujo. Aquí se muestra el constructor público para esta clase: ObjectOutputStream(OutputStream flujo) throws IOException El argumento flujo es el flujo de salida en que se escribirán los objetos serializados. Lanza una IOException si el archivo no puede abrirse. Una vez que se ha abierto el flujo de salida, puede escribir un objeto en él al llamar a writeObject( ), mostrado aquí: final void writeObject(Object obj) throws IOException El objeto que habrá de escribirse se pasa a obj. Una IOException se lanza si ocurre un error mientras se escribe el objeto. Si trata de escribir un objeto que no implementa Serializable, se lanza una NotSerializableException. También es posible una InvalidClassException.

112


La clase ObjectInputStream se usa para leer objetos de un flujo. Aquí se muestra su constructor público: ObjectInputStream(InputStream flujo) throws IOException El flujo del que se leerán los objetos se especifica con flujo. Lanza una IOException si no puede abrirse el archivo. Una vez que queda abierto el flujo de entrada, puede escribir un objeto en él al llamar a readObject( ), que se muestra aquí: final Object readObject(Object obj) throws IOException, ClassNotFoundException Devuelve el siguiente objeto del archivo. Se lanza una IOException si ocurre un error mientras se lee el objeto. Si no puede encontrarse la clase del objeto, se lanza una ClassNotFoundException. También son posibles otras excepciones. Cuando haya terminado con una ObjectInputStream o una ObjectOutputStream, debe cerrarla al llamar a close( ). Es el mismo para ambas clases y se muestra aquí: void close( ) throws IOException Se lanza una IOException si ocurre un error mientras se cierra el archivo.

Ejemplo A continuación se muestra un ejemplo de serialización. Crea una clase llamada MiClase que contiene tres campos: una cadena, una matriz y un objeto de File. Luego crea dos objetos de MiClase, despliega su contenido y los guarda en un archivo llamado objetivo.dat. Luego lee los objetos de nuevo y despliega su contenido. Como lo muestra la salida, el contenido de los objetos reconstruidos son los mismos que los del original. // Demuestra la serialización de objetos. import java.io.*; // Una clase serializable simple. class MiClase implements Serializable { String cad; double[ ] vals; File na; public MiClase(String c, double[ ] nums, String nombrearch) { cad = c; vals = nums; na = new File(nombrearch); } public String toString( ) { String datos = " cad: " + cad + "\n for(double d : vals)

vals: ";

datos += d + " ";

Capítulo 3: datos += "\n

Manejo de archivos

na: " + na.getName( );

return datos; } } public class DemoSerial { public static void main(String args[ ]) { double v[ ] = { 1.1, 2.2, 3.3 }; double v2[ ] = { 9.0, 8.0, 7.7 }; // Crea dos objetos de MiClase. MiClase obj1 = new MiClase("Esto es una prueba", v, "Prueba.txt"); MiClase obj2 = new MiClase("Alfa Beta Gama", v2, "Ejemplo.dat"); // Abra el archivo de salida. ObjectOutputStream fout; try { fout = new ObjectOutputStream(new FileOutputStream("obj.dat")); } catch(IOException exc) { System.out.println("Error al abrir el archivo de salida"); return; } // Escribe objetos en un archivo. try { System.out.println("Escribiendo objetos en un archivo."); System.out.println("obj1:\n" + obj1); fout.writeObject(obj1); System.out.println("obj2:\n" + obj2); fout.writeObject(obj2); } catch(IOException exc) { System.out.println("Error al escribir objeto"); } try { fout.close( ); } catch(IOException exc) { System.out.println("Error al cerrar archivo de salida"); return; } // Lee el objeto del archivo. ObjectInputStream fin; // Abre el archivo de salida. try {

113

114

Java: Soluciones de programación fin = new ObjectInputStream(new FileInputStream("obj.dat")); } catch(IOException exc) { System.out.println("Error al abrir archivo de entrada"); return; } System.out.println("\nLeyendo objetos del archivo."); try { MiClase inputObj; inputObj = (MiClase) fin.readObject( ); System.out.println("Primer objeto:\n" + inputObj); inputObj = (MiClase) fin.readObject( ); System.out.println("Segundo objeto:\n" + inputObj); } catch(IOException exc) { System.out.println("Error al leer datos de objeto"); } catch(ClassNotFoundException exc) { System.out.println("Definici\u00a2n de clase no encontrada"); } try { fin.close( ); } catch(IOException exc) { System.out.println("Error al cerrar archivo de entrada"); return; } }

}

Aquí se muestra la salida: Escribiendo objetos en un archivo. obj1: cad: Esto es una prueba vals: 1.1 2.2 3.3 na: Prueba.txt obj2: cad: Alfa Beta Gama vals: 9.0 8.0 7.7 na: Ejemplo.dat Leyendo objetos del archivo. Primer objeto: cad: Esto es una prueba vals: 1.1 2.2 3.3 na: Prueba.txt Segundo objeto: cad: Alfa Beta Gama vals: 9.0 8.0 7.7 na: Ejemplo.dat

Capítulo 3:

Manejo de archivos

115

Opciones Los de una clase que no quiere almacenar pueden modificarse con el especificador transient. Esto es útil cuando una variable de instancia contiene un valor que no es importante para el estado del objeto. Al no guardar campos innecesarios, el tamaño del archivo se reduce. Puede confirmar esto al hacer na transitorio en el ejemplo. Después de esto, na no se guardará cuando se guarde el objeto de MiClase. Por tanto, no se reconstruirá y su valor será nulo después de la llamada a readObject( ). Esto dará como resultado que se lance una NullPointerException cuando toString( ) trate de acceder a ella. Varios de los métodos de entrada proporcionados por ObjectInputStream lanzan un EOFException cuando se encuentra el final del archivo mientras se lee un objeto. EOFException es una subclase de IOException. Por tanto, si su código necesita discernir entre una condición EOF y otros tipos de errores de E/S, entonces querrá capturar EOFException explícitamente cuando lea objetos. Puede adquirir cierto grado de control manual sobre la serialización de objetos al implementar la interfaz Externalizable. Especifica los métodos readExternal( ) y writeExternal( ), que implementará para leer y escribir objetos.

4

CAPÍTULO

Formato de datos

S

i está desplegando la hora y la fecha, trabajando con valores monetarios o simplemente desea limitar el número de dígitos decimales, la formación de los datos de una manera específica, legible para los seres humanos es una parte importante de muchos programas. También es un área de la programación que plantea muchas preguntas del tipo "¿Cómo se hace?". Una razón para esto es el tamaño y la complejidad del problema: hay muchos tipos diferentes de datos, formatos y opciones. Otra razón es la riqueza de las capacidades de formato de Java. En muchos casos, Java ofrece más de una manera de formar datos. Por ejemplo, puede formar una fecha usando java.util. Formatter o java.text.DateFormat. En este capítulo se examina el tema de la formación y se presentan soluciones que muestran varias maneras de resolver diversas tareas comunes de formato. El eje principal de este capítulo es java.util.Formatter, que es una clase para formación de propósito general y que tiene una gran cantidad de opciones. Formatter también es usada por printf( ), que tiene soporte en PrintStream y PrintWriter. El método printf( ) es, en esencia, un método abreviado para uso con formato estilo Formatter, cuando se captura información directamente como un flujo. Como resultado, la mayoría de las soluciones usan Formatter, de manera directa o indirecta. Java incluye varias clases alternas para formación que se basan en Formatter (que se agregó en Java 5). Dos de ellas son java.text.DateFormat y java.text.NumberFormat. Ofrecen un método diferente para formar fecha, hora y datos numéricos que podrían ser útiles en algunos casos. (NumberFormat resulta especialmente útil cuando se forman valores numéricos de una manera sensible al idioma local). Otras dos clases de formación son java.text.SimpleDateFormat y java.text. DecimalFormat, que son subclases de DateFormat y NumberFormat, respectivamente. Le permiten formar fechas, horas y números con base en patrones. Aunque el principal eje de este capítulo es Formatter, varias soluciones utilizan estas opciones, principalmente para tener un abanico más completo, pero también porque ofrecen soluciones simples, pero elegantes a algunos tipos de tareas de formación. He aquí las soluciones de este capítulo: • • • • • •

Cuatro técnicas simples de formación numérica que emplean Formatter Alinee verticalmente datos numéricos empleando Formatter Justifique a la izquierda la salida con Formatter Forme fecha y hora empleando Formatter Especifique un idioma local usando Formatter Use flujos con Formatter

117

118

Java: Soluciones de programación • • • • • •

Use printf( ) para desplegar datos formados Forme fecha y hora con DateFormat Forme fecha y hora con patrones empleando SimpleDateFormat Forme valores numéricos con NumberFormat Forme valores monetarios usando NumberFormat Forme valores numéricos con patrones empleando DecimalFormat

Revisión general de Formatter Formatter es una clase de formación de propósito general, y casi todas las soluciones de este capítulo dependen de ella. Está empaquetada en java.util e implementa las interfaces Closeable y Flushable. Aunque en las soluciones individuales se analizan sus características de manera detallada, resulta útil para presentar una revisión general de sus capacidades y su modo básico de operación. Es importante establecer desde el principio que Formatter es una clase relativamente nueva, agregada en Java 5. Por tanto, necesitará usar una versión moderna de Java para usar sus capacidades. Formatter trabaja al convertir la forma binaria de los datos usados por el programa en un texto formado, legible para el ser humano. Da salida al texto formado a un objeto de destino, que puede ser un búfer o un flujo (incluido un flujo de archivo). Si el destino es un búfer, entonces el contenido de éste puede obtenerse de su programa, cada vez que sea necesario. Es posible permitir que Formatter proporcione este búfer automáticamente, o puede especificarlo de manera explícita cuando se cree un objeto de Formatter. Si el destino es un flujo, entonces la salida se escribe en el flujo y no está disponible de otra manera en su programa. La clase Formatter define muchos constructores, que le permiten construir un Formatter de diversas maneras. Tal vez el de uso más amplio sea el constructor predeterminado: Formatter( ) Usa automáticamente la configuración de región e idioma local predeterminada y asigna un StringBuilder como constructor para que contenga la salida formada. Otros constructores le permiten especificar el destino y el idioma local. También puede especificar un archivo u otro tipo de OutputStream como contenedor de la salida formada. He aquí una muestra de constructores de Formatter: Formatter(Locale loc) Formatter(Appendable destino) Formatter(Appendable destino, Locale loc) Formatter(String nombrearchivo) throws FileNotFoundException Formatter(OutputStream flujoSal) Formatter(PrintStream flujoSal) El parámetro loc especifica una configuración de región e idioma local. Si no se especifica una, se usa la predeterminada. Al especificar un idioma local, puede formar datos en relación con un país, un idioma, o ambos. El parámetro destino especifica un destino para la salida formada. Este destino debe implementarse en la interfaz Appendable, que describe objetos a los que pueden agregarse datos al final. (Appendable se implementa con stringBuilder, PrintStream y PrintWriter, entre varios otros objetos). Si destino es nulo, entonces Formatter asigna automáticamente un StringBuilder para usar un búfer para la salida formada. El parámetro nombrearchivo especifica el

Capítulo 4:

Formato de datos

119

Método

Descripción

void close( )

Cierra el Formatter que invoca. Esto causa que se libere cualquier recurso empleado por el objeto. Después de que se ha cerrado un Formatter, ya no puede reutilizarse.

void flush( )

Limpia el búfer de formato. Esto causa que cualquier salida que se encuentra en búfer se escriba en el destino.

Formatter format(String cadFmt, Object ... args)

Forma los argumentos pasados mediante args, de acuerdo con los especificadotes de formato contenidos en cadFmt. Devuelve el objeto que invoca.

Formatter format(Locale loc, String cadFmt, Object ... args)

Forma los argumentos pasados mediante args, de acuerdo con los especificadotes de formato contenidos en cadFmt. El idioma local especificado por loc se usa para este formato. Devuelve el objeto que invoca.

IOException ioException( )

Si el objeto que es el destino para la salida lanza una IOException, entonces se devuelve esta excepción. De otra manera, se devuelve null.

Locale locale( )

Devuelve la configuración de región y de idioma local del objeto que se invoca.

Appendable out( )

Devuelve una referencia al objeto que es el destino para la salida.

String toString( )

Devuelve la cadena obtenida al llamar a toString( ) en el objeto de destino. Si se trata de un búfer, entonces se devolverá la salida formada.

Tabla 4-1 Los métodos definidos por Formatter

nombre de un archivo que recibirá la salida formada. El parámetro flujoSal especifica una referencia a un flujo de salida que recibirá la salida. Formatter define los métodos mostrados en la tabla 4-1. Excepto por ioException( ), cualquier intento por usar uno de estos métodos después de que se ha cerrado la instancia de Formatter dará como resultado una FormatterClosedException.

Fundamentos de formación Después de que ha creado un Formatter, puede usar su método format( ) para crear una cadena formada. Aquí se muestran sus dos formas: Formatter format(Locale loc, String cadFmt, Object ... args) Formatter format(String cadFmt, Object ... args) En la primera forma, el parámetro loc especifica la configuración de región y de idioma local. En la segunda, se usa el idioma de la instancia de Formatter. Por esto, probablemente la segunda forma sea la más común. En el caso de ambas formas, cadFmt incluye dos tipos de elementos. El primer tipo está integrado por caracteres que simplemente se copian en el destino. El segundo tipo contiene especificadores de formato que definen la manera en que están formados los argumentos subsecuentes pasados vía args. En su forma más simple, un especificador de formato empieza con un signo porcentual seguido por el especificador de conversión de formato. Todos estos especificadores contienen un solo carácter. Por ejemplo, el especificador de formato para los datos de punto flotante es %f. En general, debe

120


haber el mismo número de argumentos que especificadores de formato, y ambos deben coincidir en orden, de izquierda a derecha. Por ejemplo, tome en consideración este fragmento: Formatter fmt = new Formatter( ); fmt.format("Formatter es %s poderosa %d %f", "muy", 88, 3.1416);

Esta secuencia crea un Formatter que contiene la siguiente cadena: Formatter es muy poderosa 88 3.141600

En este ejemplo, los especificadores de formato %s, %d y %f se reemplazan con los argumentos que siguen a la cadena de formato. Por tanto %s es reemplazada por "muy", %d es reemplazada con 88 y %f es reemplazada con 3.1416. Todos los demás caracteres simplemente se usan tal como están. Como podrá suponer, el especificador de formato %s especifica una cadena y %d un valor entero. Como se mencionó antes, %f especifica un valor de punto flotante. Es importante comprender que en el caso de cualquier instancia determinada de Formatter, cada llamada a format( ) agrega salida al final de la salida anterior. Por tanto, si el destino de formato es un búfer, entonces cada llamada a format( ) adjunta la salida al final del búfer. En otras palabras, una llamada a format( ) no restablece el búfer. Por ejemplo, estas dos llamada a format( ) fmt.format("%s %s", "Esto", "es"); fmt.format("%s", " una prueba. ");

crea una cadena que contiene "Esto es una prueba." Por tanto, es posible hacer una secuencia de llamadas a format( ) para construir la cadena deseada. El método format( ) acepta una amplia variedad de especificadores de formato, que se muestran en la tabla 4-2. Observe que muchos especificadores tienen formas en mayúsculas y minúsculas. Cuando se usa un especificador en mayúsculas, entonces las letras se muestran en mayúsculas. De otra manera, los especificadores en mayúsculas y minúsculas realizan la misma conversión. Es importante comprender que Java revisa el tipo de cada especificador de formato contra su argumento correspondiente. Si el argumento no coincide, se lanza una IllegalFormatException, que también se lanza si un especificador de formato está mal formado o si no se proporciona un argumento correspondiente que coincida con un especificador de formato. Hay varias subclases de IllegalFormatException que describen errores específicos. (Consulte la documentación de la API de Java para conocer detalles). Si está usando una versión basada en búfer de Formatter, después de llamar a format( ), puede obtener la cadena formada si llama a toString( ) en Formatter. Devuelve el resultado de llamar a toString( ) en el búfer. Así, continuando con el ejemplo anterior, la siguiente instrucción permite obtener la cadena formada que está contenida en fmt: String cad = fmt.toString( );

Por supuesto, si sólo quiere desplegar la cadena formada, no hay razón para asignarla primero a un objeto String. Cuando un objeto Formatter se pasa a println( ), por ejemplo, se llama automáticamente al método toString( ), que (en este caso) devuelve el resultado de llamar a toString( ) en el búfer. Otro tema importantes es que puede obtener una referencia a un destino al llamar a out( ). Devuelve una referencia al objeto Appendable en que se escribió la salida formada. En el caso de un Formatter basado en búfer, esto será una referencia al búfer, que es un StringBuilder, como opción predeterminada.

Capítulo 4:

Formato de datos

Especificador de formato

Conversión aplicada

%a %A

Hexadecimal de punto flotante

%b %B

Booleano

%c

Carácter

%d

Entero decimal

%h %H

Código de hash del argumento

%e %E

Notación científica

%f

Punto flotante decimal

%g %G

Usa %e o %f, el que sea más corto

%o

Entero octal

%n

Inserta un carácter de nueva línea

%s %S

Cadena

%t %T

Hora y fecha

%x %X

Entero hexadecimal

%%

Inserta un signo %

121

Tabla 4-2 Los especificadores de formato

Especificación de un ancho mínimo de campo Un entero colocado entre el signo % y el especificador de conversión de formato actúa como especificador de ancho mínimo de campo. Esto llena la salida con espacios para asegurar que alcanza una cierta longitud mínima. Si la cadena o el número es mayor que el mínimo, aún se imprimirá completo. El relleno predeterminado se hace con espacios. Si quiere rellenar con ceros, coloque un 0 antes de especificador de ancho de campo. Por ejemplo, %05d rellenará con ceros un número que cuente con menos de cinco dígitos para que su longitud total sea de cinco. El especificador de ancho de campo puede usarse con todos los especificadores de formato, excepto %n.

Especificación de precisión Es posible aplicar un especificador de precisión a los especificadores de formato %f, %e, %g y %s. Sigue al especificador de ancho mínimo de campo (si hay uno) y está formado por un punto seguido de un entero. Su significado exacto depende del tipo de datos al que se aplica. Cuando el especificador de precisión se aplica a datos de punto flotante formados por % o %e, determina el número de lugares decimales desplegados. Por ejemplo, %10.4f despliega un número de por lo menos diez caracteres de ancho con cuatro lugares decimales. Cuando se usa %g, el especificador de precisión determina el número de dígitos significativos. La precisión predeterminada es 6.

122


Aplicado a cadenas, el especificador de precisión especifica la longitud máxima de campo. Por ejemplo, %5.7s despliega una cadena de por lo menos cinco y no más de siete caracteres de largo. Si la cadena es mayor que el ancho máximo del campo, se truncarán los caracteres del final.

Uso de las marcas de formato Formatter reconoce un conjunto de marcas de formato que le permiten controlar varios aspectos de la conversión. Todas las marcas de formato son caracteres únicos, y una marca de formato sigue a % en una especificación de formato. Aquí se muestran las marcas: Marca

Efecto

–

Justificación a la izquierda

#

Alterna el formato de conversión

0

La salida es rellenada con ceros en lugar de espacios

espacio

La salida numérica positiva es precedida por un espacio

+

La salida numérica positiva es precedida por un signo +

.

Los valores numéricos incluyen separadores de grupo

(

Los valores numéricos negativos están encerrados entre paréntesis

De éstos, el # requiere cierta explicación. El # puede aplicarse a %o, %x, %a, %e y %f. Para los casos de %a, %e y %f, el # asegura que habrá un punto decimal aunque no haya dígitos decimales. Si antecede el especificador de formato %x con un #, el número hexadecimal se imprimirá con un prefijo 0x. Anteceder el especificador %o con # causa que el número se imprima con un cero al principio.

La opción en mayúsculas Como ya se mencionó, varios de los especificadores de formato tienen versiones en mayúsculas que causan que la conversión use mayúsculas cuando sea apropiado. En la siguiente tabla se describe el efecto. Especificador

Efecto

%A

Causa que los dígitos hexadecimales de la a a f se desplieguen en mayúsculas, como de la A a la F. Además, el prefijo Ox se despliega como OX, y la p se desplegará como P.

%B

Pone en mayúsculas los valores verdadero y falso.

%E

Causa que el símbolo e que indica el exponente se despliegue en mayúsculas.

%G

Causa que el símbolo e que indica el exponente se despliegue en mayúsculas.

%H

Causa que los dígitos hexadecimales de la a la f se desplieguen en mayúsculas, como de la A a la F.

%S

Pone en mayúsculas la cadena correspondiente.

%T

Causa que todas las salidas alfabéticas relacionadas con la fecha o la hora (como los nombres de los meses o el indicador de AM/PM) se desplieguen en mayúsculas.

%X

Causa que los dígitos hexadecimales de la a a f se desplieguen en mayúsculas, como de la A a la F. Además, el prefijo Ox se despliega como OX, si está presente.

Capítulo 4:

Formato de datos

123

Uso de un índice de argumentos Formatter incluye una característica muy útil que le permite especificar el argumento al que se aplica un especificador de formato. Por lo general, los especificadores de formato y los argumentos coinciden en orden, de izquierda a derecha. Es decir, el primer especificador de formato coincide con el primer argumento, el segundo especificador con el segundo argumento, etc. Sin embargo, al usar un índice de argumentos, se controla específicamente cuál argumento coincide con un especificador de formato predeterminado. Un índice de argumentos va inmediatamente después del % en el especificador de formato. Tiene el siguiente formato: n$ donde n es el índice del argumento deseado, empezando en 1. Por ejemplo, considere este ejemplo: fmt.format ("%3$s %1$s %2$s", "alfa", "beta", "gama");

produce la cadena: gama alfa beta

En este ejemplo, el primer especificador de formato coincide con "gama", el segundo con "alfa" y el tercero con "beta". Por tanto, los argumentos se usan en un orden diferente al que va estrictamente de izquierda a derecha. Una ventaja de los índices de argumento es que le permiten reutilizar un argumento sin tener que especificarlo dos veces. Por ejemplo, considere esta línea: fmt.format("%s en may\u00a3sculas es %1$S", "Prueba");

Produce la siguiente cadena: Prueba en mayúsculas es PRUEBA

Como puede ver, el argumento "Prueba" es usado por ambos especificadores de formato. Hay un método abreviado conveniente llamado índice relativo, que le permite reutilizar el argumento con el que coincide el especificador de formato anterior. Simplemente especifique < para el índice de argumento. Por ejemplo, la siguiente llamada a format( ) produce los mismos resultados que el ejemplo anterior: fmt.format("%s en may\u00a3sculas es %<S", "Prueba");

Revisión general de NumberFormat y DateFormat NumberFormat y DateFormat son clases abstractas que son parte de java.text. NumberFormat se utiliza para formar valores numéricos; DateFormat para formar la fecha y la hora. Ambos también proporcionan soporte a análisis sintáctico de datos, y ambos funcionan de una manera sensible al idioma local. Estas clases utilizan Formatter y proporcionan otra manera de formar información. Una subclase concreta de NumberFormat es DecimalFormat. Soporta un método basado en patrones para formar valores numéricos. Una subclase concreta de DateFormat es SimpleDateFormat, que también soporta un método basado en patrones para formación. La operación de estas clases se describe en las soluciones que los usan.

124


Cuatro técnicas simples de formación numérica que emplean Formatter Componentes clave Clases

Métodos

java.util.Formatter


Algunas de las preguntas que los principiantes plantean con más frecuencia se relacionan con la formación de valores numéricos. He aquí cuatro de ellas: • ¿Cómo controlo el número de lugares decimales desplegados cuando doy salida a un valor de punto flotante? Por ejemplo, ¿cómo despliego sólo dos lugares decimales? • ¿Cómo incluyo separadores de grupo en un número? Por ejemplo, en inglés, las comas se usan para separar grupos de tres dígitos, como 1,234,709. ¿Cómo se crean esas agrupaciones? • ¿Hay una manera simple de incluir una + al principio de un valor positivo? Si lo hay, ¿cuál es? • ¿Puedo desplegar valores negativos dentro de paréntesis? Si es posible, ¿cómo se hace? Por fortuna, es fácil responder todas estas preguntas porque Formatter ofrece soluciones muy simples a estos tipos de tareas de formato. En esta solución se muestra cómo hacerlo.

Paso a paso Para formar un valor numérico empleando Formatter se requieren los pasos siguientes: 1. Construya un Formatter. 2. Cree un especificador para el formato deseado, como se describe en los pasos siguientes: 3. Para especificar el número de lugares decimales desplegados, use un especificador de precisión con los formatos %f o %e. 4. Para incluir separadores de grupo, use la marca , con %f, %g o %d. 5. Para desplegar un + al principio del valor positivo, especifique la marca +. 6. Para desplegar valores negativos dentro de paréntesis, use la marca (. 7. Pase el especificador de formato y el valor a format( ) para crear un valor formado.

Análisis Para conocer una descripción de los constructores de Formatter y el método format( ), consulte Revisión general de Formatter, que se presentó casi al principio de este capítulo. Para especificar el número de lugares decimales (en otras palabras, el número de dígitos fraccionales) que se desplegará, use un especificador de precisión con el formato %f o %g. El especificador de precisión consta de un punto seguido por la precisión. Precede de inmediato al especificador de conversión. Por ejemplo, %.3f causa que se desplieguen tres dígitos decimales.

Capítulo 4:

Formato de datos

125

Para incluir separadores de grupo (que son las comas, en español), use la marca ,. Por ejemplo, %,d inserta el separador de grupo en un valor entero. Para anteceder valores negativos con un signo +, use la marca +. Por ejemplo, %+f causa que un valor positivo, de punto flotante, sea antecedido por un +. En algunos casos, como cuando se crean declaraciones de pérdidas y ganancias, se acostumbra desplegar valores negativos entre paréntesis. Esto se logra fácilmente con el uso de la marca (. Por ejemplo, %(,2f despliega un valor usando dos dígitos decimales. Si el valor es negativo, se incluye entre paréntesis.

Ejemplo Con el siguiente programa se pone la solución en acción. // Usa Formatter para: // // . Especifica el número de dígitos decimales. // . Usa un separador de grupo. // . Antecede un valor positivo con un signo +. // . Muestra valores negativos entre paréntesis. import java.util.*; class FormatosNumericos { public static void main(String args[]) { Formatter fmt = new Formatter( ); // Limita el número de dígitos decimales // al especificar la precisión. fmt.format("Precisi\u00a2n predeterminada: %f\n", 10.0/3.0); fmt.format("Dos d\u00a1gitos decimales: %.2f\n\n", 10.0/3.0); // Usando separadores de grupo. fmt.format("Sin separadores de grupo: %d\n", 123456789); fmt.format("Con separadores de grupo: %,d\n\n", 123456789); // Muestra valores positivos con + al principio // y valores negativos entre paréntesis. fmt.format("Formato predeterminado positivo y negativo: %.2f %.2f\n", 423.78, –505.09); fmt.format("Con + y parentesis: %+.2f %(.2f\n", 423.78, –505.09); // Despliega la salida formada. System.out.println(fmt); } }

Aquí se muestra la salida: Precisión predeterminada: 3.333333 Dos dígitos decimales: 3.33

126


Sin separadores de grupo: 123456789 Con separadores de grupo: 123,456,789 Formato predeterminado positivo y negativo: 423.78 –505.09 Con + y paréntesis: +423.78 (505.09)

Opciones La clase java.text.NumberFormat también puede usarse para formar valores numéricos. No soporta todas las opciones disponibles mediante Formatter, pero le permite especificar el número mínimo y máximo de dígitos fraccionales que se desplegará. También puede formar valores en el formato de moneda de la configuración local. Además, puede usar DecimalFormat para formar valores numéricos. (Consulte las soluciones relacionadas con NumberFormat y DecimalFormat cerca del final del capítulo, para conocer más detalles). Puede usar la marca # con %e y %f para asegurar que habrá un punto decimal aunque no se muestren dígitos decimales. Por ejemplo, %#.0f causa que el valor 100.0 se despliegue como 100.. Puede usar más de una marca a la vez. Por ejemplo, para mostrar números negativos con separadores de grupo dentro de paréntesis, use este especificador de formato; %,(f.

Alinee verticalmente datos numéricos empleando Formatter Componentes clave Clases

Métodos

java.util.Formatter


Una tarea de formato común incluye la creación de tablas en que se alinean los valores numéricos de una columna. Por ejemplo, tal vez quiera que se alineen los datos financieros de una declaración de pérdidas y ganancias. Como regla general, la alineación de valores numéricos en una columna implica que los puntos decimales se alineen. En el caso de valores enteros, los dígitos de las unidades deben alinearse. La manera más fácil de alinear verticalmente datos numéricos incluye el uso de un especificador de ancho mínimo de campo. A menudo, también querrá especificar la precisión para mejorar la presentación. Este es el método usado en esta solución.

Paso a paso La alineación vertical de valores numéricos incluye estos pasos: 1. Construya un Formatter. 2. Cree un especificador de formato que defina el ancho del campo en que se desplegarán los valores. El ancho será igual o mayor al del valor más largo (incluido el punto decimal, el signo y los separadores de grupo).

Capítulo 4:

Formato de datos

127

3. Pase el especificador de formato y los datos a format( ) para crear un valor formado. 4. Organice los valores formados verticalmente, uno encima del otro.

Análisis Para una descripción de los constructores de Formatter y el método format( ), consulte Revisión general de Formatter, presentado cerca del principio de este capítulo. En general, la alineación de valores numéricos en una tabla requiere que especifique un ancho mínimo de campo. Cuando se usa éste, la salida se rellena con espacios para asegurar que alcance una cierta longitud mínima. Sin embargo, comprenda que si la cadena o el número que se está formando es mayor que el mínimo, aún se imprimirá completo. Esto significa que debe hacer que el ancho mínimo sea por lo menos igual que el valor más largo, si quiere que los valores se alineen. Como opción predeterminada, se usan los espacios para rellenar la salida. Cuando se alinean datos de punto flotante, a menudo querrá que los valores se alineen de modo que los puntos decimales queden uno encima del otro. En el caso de datos enteros, los dígitos de las unidades se alinean verticalmente.

Ejemplo En el siguiente ejemplo se muestra cómo usar un ancho de campo mínimo para alinear datos verticalmente. Despliega varios valores y sus raíces cúbicas. Usa un ancho de 12 y muestra cuatro lugares decimales. // Usa Formatter para alinear verticalmente valores numéricos. import java.util.*; class AlinearVertical { public static void main(String args[]) { double datos[] = { 12.3, 45.5764, –0.09, –18.0, 1232.01 }; Formatter fmt = new Formatter( ); // Crea una tabla que contiene valores y la // raíz cúbica de esos valores. fmt.format("%12s %12s\n", "Valor", "Ra\u00a1z c\u00a3bica"); for(double v : datos) { fmt.format("%12.4f %12.4f\n", v, Math.cbrt(v)); } // Despliega los datos formados. System.out.println(fmt); } }

Aquí se muestra la salida: Valor 12.3000 45.5764 –0.0900 –18.0000 1232.0100

Raíz cúbica 2.3084 3.5720 –0.4481 –2.6207 10.7202

128


Ejemplo adicional: centro de datos En ocasiones querrá alinear datos verticalmente al centrarlos en lugar de justificarlos a la izquierda o la derecha. En este ejemplo se muestra la manera de hacerlo. Crea un método estático denominado centrar( ), que centra un elemento dentro de un ancho de campo especificado. El método pasa una referencia a Formatter, el especificador de formato que determina el formato de los datos, los datos que habrán de formarse (a manera de una referencia a Object) y el ancho del campo. El método centrar( ) tiene una restricción importante que debe señalarse: sólo funciona para la configuración de idioma predeterminada. Sin embargo, puede mejorarlo fácilmente al hacer que funcione con una configuración especificada. // Centra los datos dentro de un campo. import java.util.*; class DemoCentrar { // Centra los datos dentro de un ancho de campo específico. // El formato de los datos se pasa a cadFmt, // el Formatter se pasa a fmt, los datos que se formarán // pasan a obj, y el ancho del campo se pasa a ancho. static void centrar(String cadFmt, Formatter fmt, Object obj, int ancho) { String cad; try { // Primero, forma los datos para que pueda determinarse // su longitud. Use a Formatter temporal para // este propósito. Formatter tmp = new Formatter( ); tmp.format(cadFmt, obj); cad = tmp.toString( ); } catch(IllegalFormatException exc) { System.out.println("Solicitud de formato no v\u00a0lida"); fmt.format(""); return; } // Obtiene la diferencia entre la longitud de los // datos y la del campo. int dif = ancho – cad.length( ); // Si los datos son más largos que el ancho del campo, // entonces simplemente los usa como están. if(dif < 0) { fmt.format(cad); return; }

Capítulo 4: // Agrega relleno al inicio del campo. char[] rell = new char[dif/2]; Arrays.fill(rell, ‘ ‘); fmt.format(new String(rell)); // Agrega los datos. fmt.format(cad); // Agrega relleno al final del campo. rell = new char[ancho–dif/2–cad.length( )]; Arrays.fill(rell, ‘ ‘); fmt.format(new String(rell)); } // Demuestra centrar( ). public static void main(String args[]) { Formatter fmt = new Formatter( ); fmt.format("|"); centrar("%s", fmt, "Origen", 12); fmt.format("|"); centrar("%10s", fmt, "Perds/Gans", 14); fmt.format("|\n\n"); fmt.format("|"); centrar("%s", fmt, "Menudeo", 12); fmt.format("|"); centrar("%,10d", fmt, 1232675, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Almacenes", 12); fmt.format("|"); centrar("%,10d", fmt, 23232482, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Rentas", 12); fmt.format("|"); centrar("%,10d", fmt, 3052238, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Regal\u00a1as", 12); fmt.format("|"); centrar("%,10d", fmt, 329845, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Intereses", 12); fmt.format("|"); centrar("%,10d", fmt, 8657, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Inversiones", 12);

Formato de datos

129

130

Java: Soluciones de programación fmt.format("|"); centrar("%,10d", fmt, 1675832, 14); fmt.format("|\n"); fmt.format("|"); centrar("%s", fmt, "Patentes", 12); fmt.format("|"); centrar("%,10d", fmt, –2011, 14); fmt.format("|\n"); // Despliega los datos formados. System.out.println(fmt); }

}

Aquí se muestra la salida de ejemplo. Observe que los datos en ambas columnas están centrados dentro del ancho del campo. Las extensiones del ancho están indicados por las barras verticales. |

Origen

| Perds/Gans |

| Menudeo | 1,232,675 | Almacenes | 23,232,482 | Rentas | 3,052,238 | Regalías | 329,845 | Intereses | 8,657 |Inversiones | 1,675,832 | Patentes | –2,011

| | | | | | |

En el programa, preste especial atención a esta secuencia dentro de centrar( ): // Primero, forma los datos para que pueda determinarse // su longitud. Use a Formatter temporal para // este propósito. Formatter tmp = new Formatter( ); tmp.format(cadFmt, obj); cad = tmp.toString( );

Aunque los datos que se están formando se pasan como una referencia a Object vía obj, aún pueden formarse porque format( ) trata automáticamente de formar los datos con base en el especificador de formato. En general, todos los argumentos de format( ) son referencias a Object porque todos los argumentos se pasan vía un parámetro var-args de tipo Object. Una vez más, es el tipo de especificador de formato lo que determina la manera en que se interpreta el argumento. Si el tipo de argumento no coincide con los datos, entonces se lanzará una IllegalFormatException. Un tema adicional es que muchas de las llamadas a format( ) especifican una cadena de formato que no contiene ningún especificador de formato o algún argumento para formarse. Esto es perfectamente legal. Como se explicó, la cadena de formato puede contener dos tipos de elementos: los caracteres regulares que simplemente se pasan a la salida como están, y los especificadores de formato. Sin embargo, ninguno de los dos son obligatorios. Por tanto, cuando no se incluyen especificadores de formato, no se necesitan argumentos adicionales.

Capítulo 4:

Formato de datos

131

Opciones Como opción predeterminada, los espacios se usan como relleno para alcanzar un ancho de campo mínimo, pero puede rellenarlo con criptográficos, al colocar un 0 antes del especificador de ancho de campo. Por ejemplo, si sustituye esta cadena de formato "012.4f %012,4F\n" en el primer ejemplo, la salida sería como ésta. Valor 0000012.3000 0000045.5764 –000000.0900 –000018.0000 0001232.0100

Raíz cúbica 0000002.3084 0000003.5720 –000000.4481 –000002.6207 0000010.7202

En algunos casos, puede usar justificación a la izquierda para alinear valores verticalmente. Esta técnica se demuestra en la siguiente solución.

Justifique a la izquierda la salida con Formatter Componentes clave Clases

Métodos

java.util.Formatter


Cuando se usa un ancho de campo mínimo, la salida se alinea a la derecha, como opción predeterminada. Sin embargo, esto no es siempre lo que se necesita. Por ejemplo, cuando se forman cadenas dentro de un campo de ancho fijo, a menudo las cadenas necesitan justificarse a la izquierda. Esto es fácil de lograr cuando usa Formatter, porque sólo requiere el uso de la marca de justificación a la izquierda: –.

Paso a paso La justificación a la izquierda de datos incluye estos pasos: 1. Construya un Formatter. 2. Cree un especificador de formato que defina el ancho del campo en que se desplegarán los datos. Use la marca de justificación a la izquierda – para que los datos sigan esa alineación dentro de ese campo. 3. Pase el especificador de formato y los datos a format( ) para crear la salida justificada a la izquierda.

Análisis Para conocer una descripción de los constructores de formato y el método format( ), consulte Revisión general de Formatter, que se presentó al principio de este capítulo.

132


La marca de justificación a la izquierda sólo puede usarse en un especificador de formato que incluye una especificación de ancho mínimo de campo. Aunque la justificación a la izquierda funciona con valores numéricos, suele aplicarse a cadenas cuando se presentan datos en una tabla. Esto permite que las cadenas se alineen verticalmente, justificándose a la izquierda, una sobre otra.

Ejemplo En el siguiente ejemplo se muestra cómo puede usarse la justificación a la izquierda para mejorar el aspecto de una tabla. La tabla presenta una declaración de pérdidas y ganancias muy simple en que la columna de la izquierda describe una categoría de ingresos y la de la derecha muestra la utilidad (o pérdida) de esa categoría. Las cadenas de la primera columna están justificadas a la izquierda. Esto hace que se alineen a la izquierda dentro de un campo de 12 columnas. Observe que los valores de la segunda columna están justificados a la derecha (lo que les permite alinearse verticalmente). // Usa Formatter para alinear cadenas a la izquierda en una tabla. import java.util.*; class Tabla { public static void main(String args[]) { Formatter fmt = new Formatter( ); fmt.format("%–12s %12s\n\n", "Origen", "Perds/Gans"); fmt.format("%–12s fmt.format("%–12s fmt.format("%–12s fmt.format("%–12s fmt.format("%–12s fmt.format("%–12s fmt.format("%–12s

%,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n",

"Menudeo", 1232675); "Almacenes", 23232482); "Rentas", 3052238); "Regal\u00a1as", 329845); "Intereses", 8657); "Inversiones", 1675832); "Patentes", –2011);

// Despliega la tabla formada. System.out.println(fmt); } }

Aquí se muestra la salida: Origen

Perds/Gans

Menudeo Almacenes Rentas Regalías Intereses Inversiones Patentes

1,232,675 23,232,482 3,052,238 329,845 8,657 1,675,832 –2,011

Capítulo 4:

Formato de datos

133

Opciones Para comprender la utilidad de la justificación a la izquierda, haga este experimento; elimine las marcas de justificación a la izquierda de los especificadores de cadena. En otras palabras, cambie las siguientes llamadas a format( ), como se muestra a continuación: fmt.format("%12s %12s\n\n", "Origen", "Perds/Gans"); fmt.format("%12s fmt.format("%12s fmt.format("%12s fmt.format("%12s fmt.format("%12s fmt.format("%12s fmt.format("%12s

%,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n", %,12d\n",

"Menudeo", 1232675); "Almacenes", 23232482); "Rentas", 3052238); "Regal\u00a1as", 329845); "Intereses", 8657); "Inversiones", 1675832); "Patentes", –2011);

Después de hacer estos cambios, la salida tendrá ahora este aspecto: Origen

Perds/Gans

Menudeo Almacenes Rentas Regalías Intereses Inversiones Patentes

1,232,675 23,232,482 3,052,238 329,845 8,657 1,675,832 –2,011

Como verá, los resultados no son tan adecuados.

Forme fecha y hora empleando Formatter Componentes clave Clases

Métodos

java.util.Formatter


java.util.Calendar

static Calendar getInstance( )

java.util.Date

Uno de los especificadores de conversión más poderosos proporcionados por Formatter es %t, que forma información de fecha y hora. Debido a la amplia variedad de formatos en que puede representarse la hora y la fecha, el especificador %t soporta muchas opciones. Por ejemplo, la hora puede representarse empleando un reloj de 12 o 24 horas. La fecha puede mostrarse usando formas

134


cortas, como 15/10/2008, o largas, como miércoles, 15 de octubre, 2008. Las opciones de fecha y hora se especifican empleando uno o más de los sufijos que siguen al formato t. En esta solución se describe el proceso.

Paso a paso Para formar la fecha, la hora, o ambas, siga estos pasos: 1. Cree un objeto de Formatter. 2. Empleando los sufijos mostrados en la tabla 4-3 para indicar el formato preciso, cree un especificador de formato %t que describa la manera en que quiera desplegar la fecha, la hora, o ambos. 3. Obtenga una instancia que contenga la fecha y la hora que desee formar. Esto debe ser un objeto de tipo Calendar, Date, Long o long. 4. Pase el especificador de formato y la hora a format( ) para crear un valor formado.

Análisis Para conocer una descripción de los constructores de Formatter y el método format( ), consulte Revisión general de Formatter, presentada cerca del principio de este capítulo. El especificador %t funciona un poco diferente que otros porque requiere el uso de un sufijo para describir la parte y el formato precisos de la fecha y la hora deseados. Los sufijos se muestran en la tabla 4-3. Por ejemplo, para desplegar minutos, usaría %tM, donde M indica minutos en un campo de dos caracteres. El argumento correspondiente al especificador %t debe ser de tipo Calendar, Date, Long o long. El especificador %t causa que cualquier información alfabética asociada con la fecha y la hora, como los nombres de días o el indicador AM/FM, se desplieguen en minúsculas. Si quiere desplegar estos elementos en mayúsculas, use, en cambio, %T. Como ya se explicó, el argumento que corresponde a %t debe ser una instancia de Calendar, Date, Long o long. Sin embargo, con más frecuencia usará una instancia de Calendar o de Date (que a menudo contendrán la fecha y la hora actuales del sistema). Tanto Calendar como Date están empaquetados en java.util. Para obtener la fecha y la hora actuales usando Calendar, llame al método de fábrica getInstance( ). Aquí se muestra: static Calendar getInstance( ) Devuelve una instancia de Calendar que contiene la fecha y hora en que se creó el objeto. Para obtener la fecha y la hora actuales usando Date, simplemente cree un objeto de Date empleando este constructor: Date( ) Esto crea una instancia de Date( ), que contiene la fecha y la hora actuales del sistema. Como se muestra en la tabla 4-3, Formatter le da un control muy detallado del formato de la información de fecha y hora. La mejor manera de comprender el efecto de cada sufijo consiste en experimentar.

Capítulo 4:

Formato de datos

Sufijo

Se reemplaza con

a

Nombre de día de la semana abreviado

A

Nombre completo de día de la semana

b

Nombre abreviado de mes

B

Nombre completo del mes

c

Cadena de fecha y hora estándar, formada como mes día hh::mm::ss zona año

C

Primeros dos dígitos del año

d

Día del mes como decimal (01-31)

D

mes/día/año

e

Día del mes como decimal (1-31)

F

año-mes-día

h

Nombre del mes abreviado

H

Hora (00 a 23)

I

Hora (01 a 12)

j

Día del año como decimal (001 a 366)

k

Hora (0 a 23)

l

Hora (01 a 12)

L

Milisegundo (000 a 999)

m

Mes como decimal (01 a 13)

M

Minuto como decimal (00 a 59)

N

Nanosegundo (000000000 a 999999999)

p

Equivalente local de AM o PM en minúsculas

Q

Milisegundos desde 1/1/1970

r

hh:mm:ss (formato de 12 horas)

R

hh:mm (formato de 24 horas)

S

Segundos (00 a 60)

s

Segundos desde 1/1/1970 UTC

T

hh:mm:ss (formato de 24 horas)

y

Año en decimales sin siglo (00 a 99)

Y

Año en decimales incluyendo siglo (0001 a 9999)

z

Desplazamiento desde UTC

Z

Nombre de la zona horaria

Tabla 4-3 Los sufijos de formato de fecha y hora

135

136


Ejemplo He aquí un programa que demuestra una variedad de formatos de fecha y hora. Observe algo más en este programa: la última llamada a format( ) usa indizamiento relativo para permitir que el mismo valor de datos sea usado por tres especificadores de formato. Aquí se muestra esta línea: fmt.format("Hora y minuto: %t1:%1$tM %1$Tp", cal);

Debido al indizamiento relativo, el argumento cal sólo necesita pasarse una vez, en lugar de tres veces. // Despliega varios formatos de hora y fecha // empleando el especificador %t con Formatter. import java.util.*; class FechaYHora { public static void main(String args[]) { Formatter fmt = new Formatter( ); // Obtiene la fecha y hora actuales. Calendar cal = Calendar.getInstance( ); // Despliega el formato de 12 horas. fmt.format("Hora usando el reloj de 12 horas: %tr\n", cal); // Despliega el formato de 24 horas. fmt.format("Hora usando el reloj de 24 horas: %tT\n", cal); // Despliega el formato de fecha corta. fmt.format("Formato de fecha corta: %tD\n", cal); // Despliega la fecha usando nombres completos. fmt.format("Formato de fecha larga: "); fmt.format("%tA %1$tB %1$td, %1$tY\n", cal); // Despliega información completa de fecha y hora. // La primera versión usa minúsculas. // La segunda versión usa mayúsculas. // Como se explicó, las mayúsculas se seleccionan // usando %T en lugar de %t. fmt.format("Hora y fecha en min\u00a3sculas: %tc\n", cal); fmt.format("Hora y fecha en may\u00a3sculas: %Tc\n", cal); // Despliega la hora y el minuto, e incluye un indicador // de AM o PM. Observe que se usa %T en mayúsculas. // Esto hace que AM o PM esté en mayúsculas. fmt.format("Hora y minuto: %tl:%1$tM %1$Tp\n", cal);

Capítulo 4:

Formato de datos

137

// Despliega las fechas y horas formadas. System.out.println(fmt); } }

Aquí se muestra la salida: Hora usando el reloj de 12 horas: 06:53:10 PM Hora usando el reloj de 24 horas: 18:53:10 Formato de fecha corta: 03/30/08 Formato de fecha larga: domingo marzo 30, 2008 Hora y fecha en minúsculas: dom mar 30 18:53:10 CST 2008 Hora y fecha en mayúsculas: DOM MAR 30 18:53:10 CST 2008 Hora y minuto: 6:53 PM

Opciones Como ya se mencionó, la hora, la fecha o ambas pueden estar en un objeto de Calendar, Date, Long o long. En el ejemplo se usa un objeto de Calendar, pero puede usar uno de los otros objetos si son más convenientes. Por ejemplo, he aquí una manera de reescribir la primera llamada a format( ): fmt.format("Hora usando el reloj de 12 horas: %tr\n", new Date);

Pasa una instancia de Date, en lugar de una de Calendar. Una versión larga de la fecha y la hora puede obtenerse de Calendar al llamar a getTimeInMillis( ), y de Date al llamar a getTime( ). Si quiere usar algo diferente de la hora y la fecha actuales del sistema, puede usar el método set( ) definido por Calendar para establecer la fecha y la hora. Como opción, puede usar GregorianCalendar, que es una subclase de Calendar. Proporciona constructores que le permiten especificar la fecha y la hora de manera explícita. Por ejemplo, aquí la fecha y la hora se construyen usando GregorianCalendar: fmt.format("Hora y fecha en min\u00a3sculas: %tc\n", new GregorianCalendar(2007, 1, 28, 14, 30, 0));

La fecha se establece en febrero 28, 2007. La hora es 2:30:00 pm. Una opción importante para el formato de fecha y hora es java.text.DateFormat. Ofrece una manera diferente de crear formatos de hora y fecha que pudiera ser más fácil usar en algunos casos. De especial interés es su subclase SimpleDateFormat, que le permite especificar la hora y la fecha al usar un patrón. (Consulte Forme fecha y hora con DateFormat y Forme fecha y hora con patrones empleando SimpleDateFormat).

138


Especifique un idioma local usando Formatter Componentes clave Clases

Métodos

java.util.Formatter

Formatter format (Locale loc, String cadFmt, Object ... args)

java.util.Formatter

Locale. Locale.GERMAN Locale.ITALY

Aunque Formatter usa como opción predeterminada la configuración de región y de idioma predeterminada, es posible especificar explícitamente una propia. Al hacerlo, se le permite formar datos de una manera compatible con otros países e idiomas. La información local está encapsulada dentro de la clase Locale, que se encuentra empaquetada en java.util. Hay dos maneras básicas de especificar un idioma local cuando forma. En primer lugar, puede pasar una instancia de Locale a uno de los constructores de Formatter que habilitan configuración local. (En la revisión general de formato, presentada al principio de este capítulo, se muestran algunos). En segundo lugar, puede usar la forma que soporta idioma local de format( ). Éste es el método que se usa en esta solución.

Paso a paso Para formar datos en relación con una configuración de idioma específica, siga estos pasos: 1. Cree u obtenga un objeto de Locale que representa el idioma local. 2. Cree un objeto de Formatter. 3. Use el método format( ) para formar los datos, especificando el objeto Locale. Esto causa que el formato incorpore automáticamente atributos sensibles a la configuración de idioma.

Análisis Para conocer una descripción de los constructores de Formatter y el método format( ), consulte Revisión general de Formatter, que se presentó cerca del principio de este capítulo. La configuración de región y de idioma local está representada por los objetos de Locale, que describen una región geográfica o cultural. Locale es una de las clases que ayudan a internacionalizar un programa. Contiene información que determina, por ejemplo, los formatos usados para desplegar fechas, horas y números en diferentes países e idiomas. La internacionalización es un tema extenso que se encuentra más allá del alcance de este capítulo. Sin embargo, es fácil usar Locale para adecuar los formatos producidos por Formatter. Los constructores para Locale son: Locale(String idioma) Locale(String idioma, String pais) Locale(String idioma, String pais, String datos)

Capítulo 4:

Formato de datos

139

Estos constructores crean un objeto de Locale para representar un idioma específico y, en el caso de los últimos dos, un país. Estos valores deben contener códigos de idioma y país estándar ISO. (Consulte la documentación de la API de Locale, para conocer información sobre códigos de país e idioma). En los datos puede proporcionar información específica del explorador y el vendedor. En lugar de construir una instancia de Locale usted mismo, a menudo puede usar una de las configuraciones locales predefinidas por Locale, que se muestran a continuación: CANADA

GERMAN

KOREAN

CANADA_FRENCH

PRC

CHINA

ITALIAN

SIMPLIFIED_CHINESE

CHINESE

ITALY

TAIWÁN

ENGLISH

JAPAN

TRADITIONAL_CHINESE

JAPANESE

UK

FRENCH

KOREA

US

Todos estos campos son objetos estáticos de tipo Locale que se han inicializado en el idioma y el país indicados. Por ejemplo, el campo Locale.CANADA representa el objeto Locale para Canadá. El campo LOCALE.JAPANESE representa el objeto Locale para el idioma japonés.

Ejemplo Con el siguiente ejemplo se ilustra el uso de las configuraciones regionales y de idioma cuando se forman la fecha y la hora. Primero muestra el formato de fecha y hora predeterminados (que es español de México en la salida de ejemplo). Luego muestra los formatos para Italia, Alemania y Francia. // Demuestra el formato específico de idioma local. import java.util.*; class DemoFormatoLocal { public static void main(String args[]) { Formatter fmt = new Formatter( ); // Obtiene la fecha y hora actuales. Calendar cal = Calendar.getInstance( ); // Despliega información completa de fecha y hora // para varias configuraciones locales. fmt = new Formatter( ); fmt.format("Idioma predeterminado: %tc\n", cal); fmt.format(Locale.GERMAN, "Para Locale.GERMAN: %tc\n", cal); fmt.format(Locale.ITALY, "Para Locale.ITALY: %tc\n", cal); fmt.format(Locale., "Para Locale.: %tc\n", cal); System.out.println(fmt); } }

140


Aquí se muestra una salida de ejemplo: Idioma predeterminado: dom mar 30 20:17:15 CST 2008 Para Locale.GERMAN: So Mrz 30 20:17:15 CST 2008 Para Locale.ITALY: dom mar 30 20:17:15 CST 2008 Para Locale.: dim. mars 30 20:17:15 CST 2008

Opciones Como se mencionó, puede crear un Formatter específico de la configuración de región y de idioma local. Posteriores llamadas a format( ) tomarán como destino esa configuración local. Puede obtener información específica de la configuración local y de idioma relacionada con monedas empleando la clase java.util.Currency. Por ejemplo, su método getSymbol( ) devuelve una cadena que contiene el símbolo de moneda para la configuración de región y de idioma local (que es $ para México). El método getDefaultFractionDigits( ) devuelve el número de lugares decimales (es decir, dígitos fraccionales) que se despliegan normalmente (que es 2, en español).

Use flujos con Formatter Componentes clave Clases

Métodos

java.util.Formatter

Formatter format(String cadFmt, Object ... args))

Aunque con frecuencia el destino para datos formados será un búfer (por lo general de tipo StringBuilder), también puede crear instancias de Formatter que salgan a un flujo. Esta capacidad le permite escribir salida formada directamente en un archivo, por ejemplo. También puede usar esta característica para escribir salida formada directamente a la consola. En esta solución se muestra el proceso.

Paso a paso Para escribir directamente en un flujo datos formados se requieren estos pasos: 1. Cree un Formatter que esté vinculado con un flujo. 2. Cree el especificador de formato deseado. 3. Pase el especificador de formato y los datos a format( ). Debido a que Formatter está vinculado a un flujo, la salida formada se escribe automáticamente en el flujo.

Análisis Para vincular un Formatter con un flujo, debe usar uno de los constructores que funcionan con flujos de Formatter. Los que se usan aquí son Formatter(OutputStream cadSal) Formatter(PrintStream cadSal)

Capítulo 4:

Formato de datos

141

El parámetro cadSal especifica una referencia a un flujo que recibirá salida. La primera versión funciona con cualquier OutputStream, incluido FileOutputStream. La segunda versión funciona con PrintStream. La clase PrintStream proporciona los métodos print( ) y println( ) que se usan para tipos de datos básicos de Java (como int, String y double) en una forma legible para los seres humanos. Como tal vez ya lo sepa, System.out es una instancia de PrintStream. Por tanto, un Formatter vinculado con System.out escribirá directamente en la consola. Para conocer una descripción del método format( ) definida por Formatter, consulte Revisión general de Formatter, presentada cerca del inicio de este capítulo.

Ejemplo En el siguiente ejemplo se muestra cómo usar Formatter para escribir en la consola y en un archivo. // Escribe la salida formada directamente en la consola. // y en un archivo. import java.io.*; import java.util.*; class FlujosFormatter { public static void main(String args[]) { // Crea un Formatter vinculado con la consola. Formatter fmtCon = new Formatter(System.out); // Crea un Formatter vinculado con un archivo. Formatter fmtArchivo; try { fmtArchivo = new Formatter(new FileOutputStream("prueba.fmt")); } catch(FileNotFoundException exc) { System.out.println("No puede abrir el archivo"); return; } // Primero, escribe en la consola. fmtCon.format("Es un n\u00a3mero negativo: %(.2f\n\n", –123.34); fmtCon.format("%8s %8s\n", "Valor", "Cuadrado"); for(int i=1; i < 20; i++) fmtCon.format("%8d %8d\n", i, i*i); // Ahora, escriba en el archivo. fmtArchivo.format("Es un n\u00a3mero negativo: %(.2f\n\n", –123.34); fmtArchivo.format("%8s %8s\n", "Valor", "Cuadrado");

142

Java: Soluciones de programación for(int i=1; i < 20; i++) fmtArchivo.format("%8d %8d\n", i, i*i); fmtArchivo.close( ); // Usa ioException( ) para revisar errores de archivo. if(fmtArchivo.ioException( ) != null) { System.out.println("Ocurri\u00a2 un error de E/S"); } }

}

Aquí se muestra la salida que se despliega en la consola y se escribe en el archivo: Es un número negativo: (123.34) Valor 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Cuadrado 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361

Opciones Cuando se escriben datos formados en la consola, suele ser más fácil usar el método printf( ) definido por PrintStream. (Consulte Use printf( ) para desplegar datos formados). Cuando se crea un Formatter vinculado con un OutputStream, hay constructores adicionales que le permiten especificar la configuración de región e idioma local y el conjunto de caracteres que definen la correlación entre caracteres y bytes.

Capítulo 4:

Formato de datos

143

Use printf( ) para desplegar datos formados Componentes clave Clases

Métodos

java.io.PrintStream

PrintStream printf(String cadFmt, Object ... args)

java.io.PrintWriter

PrintWriter printf(String cadFmt, Object ... args)

Aunque usar un Formatter vinculado con System.out es una manera fácil de desplegar datos formados en la consola, aún se requieren dos pasos. Primero, debe crearse un Formatter y, después, llamarse a format( ). Aunque ciertamente no hay nada incorrecto con este método, Java proporciona una opción más conveniente: el método printf( ). Este método está definido tanto por PrintStream como por PrintWriter. El método printf( ) usa automáticamente Formatter para crear una cadena formada. Luego da salida a la cadena en el flujo que invoca. Debido a que System.out es una instancia de PrintStream, puede llamarse a printf( ) en él. Por tanto, al llamar a printf( ) en System.out, la salida formada puede desplegarse en la consola en un paso. Por supuesto, printf( ) puede llamarse en cualquier instancia de PrintStream o PrintWriter. Por tanto, también puede usarse para escribir salida formada en un archivo. NOTA El método printf( ) está basado en la función printf( ) de C/C++, y es muy similar. Esto facilita la conversión de código de C/C++ a Java.

Paso a paso El uso de printf( ) incluye estos pasos: 1. Obtenga una referencia a PrintStream o a PrintWriter. 2. Construya la cadena de formato que contiene los especificadores de formato que estará usando. 3. Pase la cadena de formato y los datos correspondientes a printf( ). Los datos formados se escribirán en el flujo que invoca.

Análisis El método printf( ) está definido por PrintStream y PrintWriter. He aquí dos formas de PrintStream: PrintStream printf(String cadFmt, Object ... args) PrintStream printf(Locale loc, String cadFmt, Object ... args)

144


La primera versión escribe args en el flujo que invoca en el formato especificado por cadFmt, empleando la configuración local. El segundo le permite especificar una configuración. Ambas devuelven el PrintStream que invoca. He aquí dos formas de PrintWriter: PrintWriter printf(String cadFmt, Object ... args) PrintWriter printf(Locale loc, String cadFmt, Object ... args) La primera versión escribe args en el flujo que invoca en el formato especificado por cadFmt, empleando la configuración de región e idioma local predeterminada. La segunda le permite especificar una configuración. Ambas devuelven el PrintWriter que invoca. En general, printf( ) trabaja de una manera similar al método format( ) definido por Formatter. La cadFmt consta de dos tipos de elementos. El primer tipo está compuesto por caracteres que simplemente se escriben en el flujo. El segundo tipo contiene especificadores de formato que definen la manera en que argumentos subsecuentes, especificados por args, están formados. (Consulte la revisión general de Formatter que se presentó al principio del capítulo, para conocer más detalles). Se lanzará una IllegalFormatException si un especificador de formato está mal formado, si no coincide con su argumento correspondiente o si hay más especificadores de formato que argumentos. Debido a que System.out es un PrintStream, puede llamar a printf( ) en System.out. Por tanto, printf( ) puede usarse en lugar de println( ) cuando se escribe en la consola cada vez que se desea salida formada. Esto hace que resulte muy fácil desplegar salida formada. Otro muy buen uso de printf( ) es escribir salida formada en un archivo. Sólo envuelva FileOutputStream en un PrintStream, o un FileWriter en un PrintWriter, y luego llame a printf( ) en ese flujo.

Ejemplo En el siguiente ejemplo se usa printf( ) para escribir varios tipos diferentes de datos formados en la consola. // Usa printf( ) para desplegar varios tipos de datos formados. import java.util.*; class DemoImprimir { public static void main(String args[]) { // Primero use el método printf( ) de PrintStream. System.out.printf("Dos d\u00a1gitos decimales: %.2f\n", 10.0/3.0); System.out.printf("Uso de separadores de grupo: %,.2f\n\n", 1546456.87); System.out.printf("%10s %10s %10s\n", "Valor", "Ra\u00a1z", "Cuadrado"); for(double i=1.0; i < 20.0; i++) System.out.printf("%10.2f %10.2f %10.2f\n", i, Math.sqrt(i), i*i); System.out.println( ); Calendar cal = Calendar.getInstance( );

Capítulo 4:

Formato de datos

145

System.out.printf("Hora y fecha actuales: %tc\n", cal); } }

Aquí se muestra la salida: Dos dígitos decimales: 3.33 Uso de separadores de grupo: 1,546,456.87 Valor 1.00 2.00 3.00 4.00 5.00 6.00 7.00 8.00 9.00 10.00 11.00 12.00 13.00 14.00 15.00 16.00 17.00 18.00 19.00

Raíz 1.00 1.41 1.73 2.00 2.24 2.45 2.65 2.83 3.00 3.16 3.32 3.46 3.61 3.74 3.87 4.00 4.12 4.24 4.36

Cuadrado 1.00 4.00 9.00 16.00 25.00 36.00 49.00 64.00 81.00 100.00 121.00 144.00 169.00 196.00 225.00 256.00 289.00 324.00 361.00

Hora y fecha actuales: dom mar 30 21:46:56 CST 2008

Ejemplo adicional Un muy buen uso para printf( ) consiste en crear una estampa de tiempo. Las estampas de tiempo son necesarias en muchas situaciones de programación. Por ejemplo, tal vez quiera imprimir la fecha y la hora en que se generó un reporte, o mantener un archivo de registro que guarde las horas en que ocurrieron los eventos. Cualquiera que sea la razón, la creación de una estampa de tiempo al usar printf( ) es un asunto fácil. En el siguiente ejemplo se muestra una manera de hacerlo. El programa define un método llamado estampaTiempo( ) que da salida a la hora y la fecha actuales (además de un mensaje opcional) al PrintWriter que se pasa. Tome en cuenta la poca cantidad de código que se necesita crear y la salida de una estampa de tiempo. El programa demuestra su uso al escribir estampas de tiempo en un archivo llamado archreg.txt. Una estampa de tiempo se escribe cuando el archivo se abre, y otra cuando se cierra. // Usa printf( ) para crear una estampa de tiempo. import java.io.*; import java.util.*; class EstampaTiempo { // Da salida a una estampa de tiempo al PrintWriter

146

Java: Soluciones de programación // especificado. Puede anteceder la estampa con un mensaje // al pasar una cadena a msj. Si no se desea un mensaje, // pasa una cadena vacía. static void estampaTiempo(String msj, PrintWriter pw) { Calendar cal = Calendar.getInstance( ); pw.printf("%s %tc\n", msj, cal); } public static void main(String args[]) { // Crea un PrintWriter que está vinculado a un archivo. PrintWriter pw; try { pw = new PrintWriter(new FileWriter("archreg.txt", true)); } catch(IOException exc) { System.out.println("No se puede abrir archreg.txt"); return; } estampaTiempo("Archivo abierto", pw); try { Thread.sleep(1000); // inactivo por 1 segundo } catch(InterruptedException exc) { pw.printf("Inactividad interrumpida"); } estampaTiempo("Archivo cerrado", pw); pw.close( ); // Cuando se usa un PrintWriter, busque errores al // llamar a checkError( ). if(pw.checkError( )) System.out.println("Error de E/S."); }

}

Después de que ejecuta este programa, archreg.txt contendrá la hora y fecha en que se abrió y cerró el archivo. He aquí un ejemplo: Archivo abierto lun mar 31 22:30:25 CST 2008 Archivo cerrado lun mar 31 22:30:26 CST 2008

Opciones PrintStream define el método format( ), que es una opción de printf( ). Tiene estas formas generales: PrintStream format(String cadFmt, Object ... args) PrintStream format(Locale loc, String cadFmt, Object ... args) Funciona exactamente como printf( ). PrintWriter también define el método format( ), como se muestra aquí:

Capítulo 4:

Formato de datos

147

PrintWriter format(String cadFmt, Object ... args) PrintWriter format(Locale loc, String cadFmt, Object ... args) También funciona exactamente igual que printf( ).

Forme fecha y hora con DateFormat Componentes clave Clases

Métodos

java.txt.DateFormat

static final DateFormat getDateInstance(int fmt) static final DateFormat getTimeInstance(int fmt) final String format(Date f)

java.util.Date

La clase DateFormat ofrece una opción de las capacidades proporcionadas por Formatter cuando se forma el tiempo y la fecha. DateFormat es sensible a la configuración de región e idioma local, que significa que puede formar información de fecha y hora para varios idiomas y países. DateFormat está empaquetado en java.text. Es una clase abstracta. Sin embargo, proporciona varios métodos de que devuelven objetos de DateFormat, que extiende Format (que es una clase abstracta que define los métodos de formación básicos.) Es una superclase de SimpleDateFormat. NOTA DateFormat también le da la capacidad de analizar sintácticamente cadenas que contienen información de fecha y hora en objetos de Date. Por tanto, tiene capacidades más allá de la simple formación.

Paso a paso Hay varias maneras de formar la fecha usando DateFormat. En esta solución se dan los siguientes pasos: 1. Obtenga una instancia de DateFormat al llamar al método estático getDateInstance( ), especificando el formato de fecha deseado. 2. Obtenga una instancia de Date que contiene la fecha que habrá de formarse. 3. Produzca una cadena que contiene un valor de fecha formado al llamar al método format( ), especificando el objeto de Date.

148


Hay varias maneras de formar la hora al usar DateFormat. En esta solución se dan los siguientes pasos: 1. Obtenga una instancia de DateFormat al llamar al método estático getTimeInstance( ), especificando el formato de hora deseado. 2. Obtenga una instancia de Date que contiene la hora que habrá de formarse. 3. Produzca una cadena que contiene un valor de fecha formado al llamar al método format( ), especificando el objeto de Date.

Análisis Para obtener un objeto de DateFormat adecuado para la formación de fecha, llame al método estático getDateInstance( ). Está disponible en varias formas. La que se usa en esta solución es static final DateFormat getDateInstance(int fmt) Para obtener un objeto de DateFormat, adecuado para formar la hora, use getTimeInstance( ). También está disponible en varias versiones. La que se usa en esta solución es static final DateFormat getTimeInstance(int fmt) Para ambos métodos, el argumento fmt debe tener uno de los siguientes valores: DEFAULT, SHORT, MEDIUM, LONG o FULL. Se trata de constantes int definidas por DateFormat. Hace que se presenten diferentes detalles acerca de la fecha y hora cuando se forman. Los formatos de fecha y hora son sensibles a convenciones de idioma y país. En las versiones de getDateInstance( ) y getTimeInstance( ) que se acaban de mostrar usan la configuración actual de región e idioma local (es decir, predeterminado). Otras versiones le permiten especificar explícitamente la configuración local. A continuación, obtenga un objeto de java.util.Date que contiene la fecha o la hora que habrá de obtenerse. Una manera es crear un objeto de Date al usar este constructor: Date( ) Esto crea un objeto de Date que contiene la fecha y hora actuales del sistema. Una vez que haya obtenido las instancias de DateFormat y Date, puede formar una fecha u hora al llamar a format( ). Hay varias formas de este método. Aquí se muestra el que usaremos: final String format(Date f) El argumento es un objeto de Date que habrá de desplegarse. El método devuelve una cadena que contiene la información formada.

Ejemplo En el siguiente ejemplo se muestra cómo formar información de fecha y hora. Empieza con la creación de un objeto de Date. Esto captura la información de fecha y hora actuales. Luego da salida a las formas corta y larga de la fecha y la hora para la configuración de región e idioma local (que es México en la salida de ejemplo). // Despliega formatos de fecha y hora cortos y largos. import java.text.*; import java.util.*;

Capítulo 4:

Formato de datos

149

class DemoFormatoFecha { public static void main(String args[]) { Date fecha = new Date( ); DateFormat df; df = DateFormat.getDateInstance(DateFormat.SHORT); System.out.println("Forma corta: " + df.format(fecha)); df = DateFormat.getDateInstance(DateFormat.LONG); System.out.println("Forma larga: " + df.format(fecha)); System.out.println( ); df = DateFormat.getTimeInstance(DateFormat.SHORT); System.out.println("Forma corta: " + df.format(fecha)); df = DateFormat.getTimeInstance(DateFormat.LONG); System.out.println("Forma larga: " + df.format(fecha)); } }

Aquí se muestra la salida de ejemplo: Forma corta: 31/03/08 Forma larga: 31 de marzo de 2008 Forma corta: 11:35 PM Forma larga: 11:35:45 PM CST

Opciones Hay formas adicionales de getDateInstance( ) y getTimeInstance( ). Puede usar el formato y la configuración de región e idioma local predeterminados al llamar a estas versiones: static final DateFormat getDateInstance( ) static final DateFormat getTimeInstance( ) Puede especificar el formato y la configuración de región y de idioma local al llamar a estas versiones: static final DateFormat getTimeInstance(int fmt, Locale local) static final DateFormat getDateInstance(int fmt, Locale local) El parámetro fmt es como se describió antes. El parámetro local se usa para especificar una configuración de región y de idioma local que regirá la conversión. En el programa de ejemplo, puede especificar explícitamente que la fecha habrá de formarse para Estados Unidos al sustituir esta llamada a getDateInstance( ): df = DateFormat.getDateInstance(DateFormat, SHORT, Locale.US);

Para formar la fecha para Japón, puede usar df = DateFormat.getDateInstance(DateFormat, SHORT, Locale.JAPAN);

Para conocer un análisis de la creación de objetos de Locale, consulte Especifique un idioma local usando Formatter. Si estará formando la hora y la fecha, puede usar getDateTimeInstance( ) para obtener un

150


objeto de DateFormat que puede usarse para ambos. Tiene estas tres versiones: static final DateFormat getDateTimeInstance( ) static final DateFormat getDateTimeInstance(int fmtFecha, int fmtHora) static final DateFormat getDateTimeInstance(int fmtFecha, int fmtHora, Locale local) Aquí, fmtFecha especifica el formato de fecha y fmtHora especifica el formato de hora. La configuración de región y de idioma local se especifica con local. Si no se usan argumentos, entonces se aplican las opciones predeterminadas del sistema. Por ejemplo, al insertar la siguiente secuencia en el programa de ejemplo se causa que se desplieguen la fecha y la hora actuales en los formatos predeterminados: df = DateFormat.getDateTimeInstance( ); System.out.println("Forma predeterminada de fecha y hora: " + df.format(fecha));

He aquí una salida de ejemplo: Forma predeterminada de fecha y hora: 1/04/2008 12:49:16 AM

Otra manera de formar la fecha y hora consiste en usar la clase java.text.SimpleDateFormat. Se trata de una subclase concreta de DateFormat. Una ventaja de esta clase es que le permite crear un patrón que describe cuáles piezas de la fecha u hora quiere desplegar. Esto le permite crear fácilmente formatos predeterminados de hora y fecha. (Consulte Forme fecha y hora con patrones empleando SimpleDateFormat). Por supuesto, también puede formar la fecha y hora empleando Formatter, o al llamar al método printf( ). (Consulte Forme fecha y hora empleando Formatter y Use printf( ) para desplegar datos formados).

Forme fecha y hora con patrones empleando SimpleDateFormat Componentes clave Clases

Métodos

java.text.SimpleDateFormat

final String format(Date f)

java.util.Date

void close()

java.text.SimpleDateFormat es una subclase concreta de DateFormat. Le permite definir sus propios patrones de formación que se usan para desplegar información de fecha y hora. Como tal, representa una opción interesante a DateFormat y Formatter.

Capítulo 4:

Formato de datos

151

Paso a paso Para formar la fecha y la hora usando SimpleDateFormat, se requieren los pasos siguientes: 1. Cree un patrón que describa el formato de fecha y hora deseado. 2. Cree una instancia de SimpleDateFormat, que especifique el patrón. 3. Obtenga una instancia de Date que contiene la fecha que habrá de formarse. 4. Produzca una cadena que contiene el valor de fecha formado al llamar al método format( ), especificando el objeto de Date.

Análisis SimpleDateFormat define varios constructores. Aquí se muestra el que usaremos aquí: SimpleDateFormat(String cadFmt) El argumento cadFmt describe un patrón que muestra cómo se desplegará la información de fecha y hora. Un patrón consta de un conjunto de símbolos que determina la información que se desplegará. En la tabla 4-4 se muestran estos símbolos y se da una descripción de cada uno. Símbolo

Descripción

a

AM o PM

d

Día del mes (1-31)

h

Hora en AM/PM (1-12)

k

Horas de un día (1-24)

m

Minutos de una hora (0-59)

s

Segundos de un minuto (0-59)

w

Semanas de un año (1-52)

y

Año

z

Zona horaria

D

Día del año (1-366)

E

Día de la semana (por ejemplo, martes)

F

Día de la semana de un mes

G

Era, es decir (AC o DC)

H

Hora del día (0-23)

K

Hora en AM/PM (0-11)

M

Mes

S

Milisegundos de un segundo

W

Semana del mes (1-5)

Z

Zona horaria en formato RFC822

Tabla 4-4 Símbolos de formato para SimpleDateFormat

152


En casi todos los casos, el número de veces que se repite un símbolo determina la manera en que se presentarán los datos. La información de texto se despliega en forma abreviada si la letra del patrón se repite menos de cuatro veces. De otra manera, se usa la forma no abreviada. Por ejemplo, un patrón zzzz despliega Hora estándar central y el patrón zzz despliega CST. En el caso de números, el número de veces que se repite la letra del patrón determina cuántos dígitos se presentan. Por ejemplo, hh:mm:ss puede presentar 01:51:15, pero h:m:s despliega el mismo valor como 1:51:15, M o MM causa que el mes se despliegue con uno o dos dígitos. Sin embargo, tres o más repeticiones de M causan que el mes se despliegue como una cadena de texto. He aquí un ejemplo de patrón: "dd MMM yyy hh:mm:ss"

Este patrón incorpora el día del mes, el nombre del mes, el año y la hora (usando un reloj de 12 horas). He aquí un ejemplo de la salida que producirá: 08 Feb 2007 10:12:33 Observe que se usan dos dígitos para el día del mes y cuatro para el año. Además, tome nota de la forma corta del nombre del mes. Una vez que haya construido un SimpleDateFormat con el patrón deseado, obtenga una instancia de Date que contenga la fecha deseada y luego use format( ) para crear la salida formada. (Consulte Forme fecha y hora con DateFormat para conocer los detalles de la creación de una Date y el empleo de format( )).

Ejemplo En el siguiente programa se muestran varios patrones de fecha y hora. // Demuestra SimpleDateFormat. import java.text.*; import java.util.*; public class DemoSDF { public static void main(String args[]) { Date fecha = new Date( ); SimpleDateFormat fechaSimple; // Hora en formato de 12 horas. fechaSimple = new SimpleDateFormat("hh:mm:ss a"); System.out.println(fechaSimple.format(fecha)); // Hora en formato de 24 horas. fechaSimple = new SimpleDateFormat("kk:mm:ss"); System.out.println(fechaSimple.format(fecha)); // Fecha y hora con mes como número. fechaSimple = new SimpleDateFormat("dd MMM yyyy hh:mm:ss a"); System.out.println(fechaSimple.format(fecha));

Capítulo 4:

Formato de datos

153

// Fecha y hora con día y mes completamente escritos. fechaSimple = new SimpleDateFormat("EEEE MMMMM dd yyyy kk:mm:ss"); System.out.println(fechaSimple.format(fecha)); } }

Aquí se muestra una salida de ejemplo: 01:52:18 AM 01:52:18 01 abr 2008 01:52:18 AM martes abril 01 2008 01:52:18

Opciones Aunque la capacidad de SimpleDateFormat de usar patrones es una característica excelente, a menudo Formatter es una mejor opción porque permite que una fecha u hora formada se integre fácilmente en una cadena formada más larga. Puede localizar el formato de fecha y hora al usar este constructor de SimpleDateFormat: SimpleDateFormat(String cadFmt, Locale loc) Aquí, loc especifica la configuración de región e idioma local. (Consulte Especifique un idioma local usando Formatter para conocer más detalles acerca de Locale).

Forme valores numéricos con NumberFormat Componentes clave Clases

Métodos

java.text.NumberFormat

static final NumberFormat getInstance( ) void setMaximumFractionDigits( int numDigitos) void setMinimumFractionDigits( int numDigitos) void setGroupingUsed( boolean usoGrupo) final String format(double val)

Como se mencionó antes, algunas de las preguntas más frecuentes planteadas por los principiantes se relacionan con la formación de valores numéricos. La razón es fácil de comprender: el formato numérico predeterminado es muy simple, no hay separadores de grupo, y no se tiene control sobre el número de lugares decimales desplegados o la manera en que se representan los valores negativos.

154


Además, en muchos casos querrá representar valores monetarios en un formato de moneda, que es, por supuesto, sensible a la configuración de región e idioma local. Por fortuna, Java proporciona varias maneras diferentes de formar valores numéricos, incluida la clase Formatter descrita antes. Sin embargo, en algunas situaciones, sobre todo las relacionadas con monedas, java.text.NumberFormat ofrece una opción útil. En esta solución se muestra el procedimiento básico requerido para usarlo. NumberFormat es una clase abstracta. Sin embargo, proporciona varios métodos de fábrica que devuelven objetos de NumberFormat. Esta clase extiende Format (que es una clase abstracta que define los métodos básicos de formación). Es una superclase de ChoiceFormat y DecimalFormat. NOTA NumberFormat también le da la capacidad de analizar sintácticamente cadenas numéricas en valores numéricos. Por tanto, tiene posibilidades mayores que las de la simple formación.

Paso a paso Para formar un valor numérico mediante NumberFormat se requieren estos pasos: 1. Obtenga una instancia de NumberFormat al llamar a getInstance( ). 2. Ajuste el formato al llamar a varios métodos definidos por NumberFormat. 3. Produzca una cadena que contenga el valor formado al llamar al método format( ) definido por NumberFormat.

Análisis Para obtener un objeto de NumberFormat, llame al método estático getInstance( ). Hay dos formas definidas por NumberFormat. La más simple (y la que usaremos) se muestra a continuación: static final NumberFormat getInstance( ) Devuelve una instancia de NumberFormat para la configuración actual de región y de idioma local. NumberFormat define varios métodos que le permiten determinar cómo se forma un valor numérico. Aquí se muestran los que usaremos: void setMaximumFractionDigits(int numDigitos) void setMinimumFractionDigits(int numDigitos) void setGroupingUsed(boolean usoGrupo) Para establecer el número máximo de dígitos desplegados a la derecha del punto decimal, llame a setMaximumFractionDigits( ), pasando el número de dígitos a numDigitos. Para establecer el número mínimo de dígitos desplegados a la derecha del punto decimal, llame a setMinimumFractionDigits( ), pasando el número de dígitos a numDigitos. Por ejemplo, para asegurar que siempre se desplieguen dos lugares decimales, utilizaría esta secuencia de llamadas (donde nf es una referencia a un objeto de NumberFormat); nf.setMinimumFractionDigits(2); nf.setMaximumFractionDigits(2);

Capítulo 4:

Formato de datos

155

Cuando el número de dígitos fraccionales es menor de los contenidos en el valor, el resultado se redondea Como opción predeterminada, el separador de grupo (que es una coma en español de México) se inserta cada tres dígitos a la izquierda del punto decimal. Puede eliminar el separador de grupo al llamar a setGroupingUsed( ), que se muestra aquí, con un argumento falso: void setGroupingUsed(boolean usoGrupos) Una vez que haya configurado la instancia de NumberFormat, puede formar un valor al llamar a format( ). Hay varias formas de este método. Aquí se muestra el que usaremos: final String format(double val) Devuelve una versión legible para el ser humano del valor pasado a val en el formato que haya especificado.

Ejemplo Con el siguiente ejemplo se demuestra la formación de valores numéricos mediante la clase NumberFormat. // Usa java.text.NumberFormat para formar algunos valores numéricos. import java.text.NumberFormat; class DemoFormatoNumero { public static void main(String args[]) { NumberFormat nf = NumberFormat.getInstance( ); System.out.println("Formato predeterminado: " + nf.format(1234567.678)); // Establece el formato en dos lugares decimales. nf.setMinimumFractionDigits(2); nf.setMaximumFractionDigits(2); System.out.println("Formato con dos lugares decimales: " + nf.format(1234567.678)); nf.setGroupingUsed(false); System.out.println("Formato sin agrupamientos: " nf.format(1234567.678));

+

// Observe que se proporcionan dos lugares // decimales, aunque no todos los dígitos // están presentes en estos casos. System.out.println("Observe dos lugares decimales: " + nf.format(10.0) + ", " + nf.format(–1.8)); } }

156


Aquí se muestra la salida para este programa: Formato Formato Formato Observe

predeterminado: 1,234,567.678 con dos lugares decimales: 1,234,567.68 sin agrupamientos: 1234567.68 dos lugares decimales: 10.00, –1.80

Opciones Para obtener un control más detallado sobre la formación, incluida la capacidad de especificar un patrón de formato, pruebe la clase DecimalFormat, que es una subclase de NumberFormat (Consulte Forme valores numéricos con patrones empleando DecimalFormat). El método format( ) usado por la solución forma valores de punto flotante. Puede formar valores enteros empleando esta versión de format( ): final String format(long val) Aquí, val es el valor que habrá de formarse. Hay otras versiones de format( ) que le permiten especificar un StringBuffer para escribir la salida y una posición de campo. Puede formar en relación con una configuración de región e idioma local empleando esta versión de getInstance( ): static NumberFormat getInstance(Locale loc) Esta configuración se pasa vía loc. (Locale está descrita en Especifique un idioma local usando Formatter.) Puede formar valores en su formato monetario estándar empleando getCurrencyInstance( ). (Consulte Forme valores monetarios usando NumberFormat). Puede formar valores como porcentajes empleando getPercentInstance( ).

Forme valores monetarios usando NumberFormat Componentes clave Clases

Métodos

java.text.NumberFormat

static final NumberFormat getCurrencyInstance( ) final String format(double val)

Una de las características especialmente útiles de NumberFormat es la capacidad de formar valores monetarios. Para ello, simplemente obtenga un objeto de NumberFormat al llamar a getCurrencyInstance( ) en lugar de getInstance. Subsecuentes llamadas a format( ) darán como resultado el valor que se forme con las convenciones de moneda de la configuración regional y de idioma local (o especificada).

Capítulo 4:

Formato de datos

157

Paso a paso Para formar valores monetarios empleando NumberFormat se requieren estos pasos: 1. Obtenga una instancia de NumberFormat al llamar a getCurrencyInstance( ). 2. Produzca una cadena que contenga el valor formado al llamar al método format( ).

Análisis Para formar un valor como moneda, use getCurrencyInstance( ) para obtener un objeto de NumberFormat. Tiene dos formas. La usada aquí es static final NumberFormat getCurrencyInstance( ) Devuelve un objeto que representa la moneda de la configuración actual de región y de idioma local. Cuando se forman monedas, los dígitos fraccionales, agrupamiento y símbolos de moneda se proporcionan automáticamente. (¡Realmente es así de fácil!). Una vez que haya configurado la instancia de NumberFormat, puede formar un valor al llamar a format( ), lo que se describió en la solución anterior.

Ejemplo En el siguiente ejemplo se muestra cómo formar valores como moneda al usar la clase NumberFormat. // Usa java.text.NumberFormat para formar un valor de moneda. import java.text.NumberFormat; import java.util.*; class DemoFormatoMoneda { public static void main(String args[]) { NumberFormat nf = NumberFormat.getCurrencyInstance( ); System.out.println("1989.99 y –210.5 en formato de moneda: " + nf.format(1989.99) + " " + nf.format(–210.5)); } }

Aquí se muestra la salida de este programa: 1989.99 y –210.5 en formato de moneda: $1,989.99 ($210.50)

Opciones Puede formar en relación con la configuración regional y de idioma al usar esta versión de getCurrencyInstance( ): static NumberFormat getCurrencyInstance(Locale loc) La configuración se pasa mediante loc. (Locale se describe en Especifique un idioma local usando Formatter).

158


Forme valores numéricos con patrones empleando DecimalFormat Componentes clave Clases

Métodos

java.text.DecimalFormat

final String format(double val)

java.text.DecimalFormat es una subclase concreta de NumberFormat. Le permite definir sus propios patrones de formación que se usan para desplegar información numérica, incluidos valores enteros y de punto flotante. Como tales, ofrecen una opción interesante a NumberFormat y Formatter.

Paso a paso Para formar un valor numérico empleando DecimalFormat se requieren los pasos siguientes: 1. Cree un patrón que describa el formato numérico deseado. 2. Cree una instancia de DecimalFormat, especificando el patrón. 3. Produzca una cadena que contenga un valor formado al llamar al método format( ), especificando el valor que habrá de formarse.

Análisis DecimalFormat define tres constructores. Aquí se muestra el que se usará: DecimalFormat(String cadFmt) El argumento cadFmt describe un patrón que muestra cómo habrá de desplegarse un valor numérico. Un patrón consta de símbolos que determinan la manera en que se desplegará el valor. En la tabla 4-5 se muestran los símbolos y se da una descripción de cada uno. Símbolo

Descripción

.

Punto decimal

,

Separador de grupo

#

Dígito, no se muestran los ceros al final

0

Dígito, se muestran los ceros al final

–

Menos

%

Muestra el valor como porcentaje (en otras palabras, multiplica el valor por 100)

E

La E en notación científica

‘

Convierte en cita un símbolo para usarlo como un carácter normal

\u00a4

Símbolo de moneda apropiado para la configuración de región y de idioma local

/u2030

Muestra el valor en términos de miles (en otras palabras, multiplica el valor por 1000)

Tabla 4-5 Una muestra de símbolos de formación para DecimalFormat

Capítulo 4:

Formato de datos

159

Todos los patrones de DecimalFormat constan de dos subpatrones: uno para valores positivos y otro para negativos. Sin embargo, el subpatrón negativo debe especificarse de manera explícita. Si no está presente, entonces el patrón negativo consta del patrón positivo con un prefijo de signo menos. Los dos subpatrones están separados por un punto y coma (;). Una vez que se ha especificado un patrón, toda la salida numérica se formará para que coincida con el patrón. He aquí un ejemplo: "#,###.00;(#,###.00)"

Esto crea un patrón que usa separadores de grupo cada tres dígitos y muestra ceros al final. También muestra valores negativos dentro de paréntesis. Una vez que haya construido un DecimalFormat con el patrón deseado, use format( ) (heredado de NumberFormat) para crear la salida formada. (Consulte Forme valores numéricos con NumberFormat para conocer más detalles).

Ejemplo En el siguiente ejemplo se demuestra DecimalFormat. // Demuestra DecimalFormat. import java.text.*; public class DemoDF { public static void main(String args[]) { DecimalFormat df; // Usa separadores de grupo y muestra ceros al final. // Los valores negativos se muestran entre paréntesis. df = new DecimalFormat("#,###.00;(#,###.00)"); System.out.println(df.format(7123.00)); System.out.println(df.format(–7123.00)); // No muestra ceros al final. df = new DecimalFormat("#,###.##;(#,###.##)"); System.out.println(df.format(7123.00)); System.out.println(df.format(–7123.00)); // Despliega un porcentaje. df = new DecimalFormat("#%"); System.out.println(df.format(0.19)); System.out.println(df.format(–0.19)); // Despliega un valor de moneda. df = new DecimalFormat("\u00a4#,##0.00"); System.out.println(df.format(4232.19)); System.out.println(df.format(–4232.19)); } }

160


Aquí se muestra la salida: 7,123.00 (7,123.00) 7,123 (7,123) 19% –19% $4,232.19 –$4,232.19

Opciones Aunque la capacidad de DecimalFormat para usar patrones puede facilitar algunos tipos de formato, a menudo Formatter es una mejor opción porque permite que un valor formado se integre fácilmente en una cadena formada más larga. NumberFormat, que es la superclase de DecimalFormat, ofrece varios formatos estándar que funcionan bien para muchas aplicaciones y que puede configurarse automáticamente para idiomas específicos. En muchos casos, esto será más conveniente que construir patrones manualmente. (Consulte Forme valores numéricos con NumberFormat).

5

CAPÍTULO

Trabajo con colecciones

L

a estructura o marco conceptual de colecciones (Collections Framework) es, presumiblemente, el subsistema más poderoso en la API de Java, porque proporciona versiones listas para usar de las estructuras de datos de uso más amplio en programación. Por ejemplo, proporciona soporte a pilas, colas, matrices dinámicas y listas vinculadas. También define árboles, tablas de hash y mapas. Estos "motores de datos" facilitan el trabajo con grupos (es decir, colecciones) de datos. No es necesario, por ejemplo, escribir sus propias rutinas de listas vinculadas. Puede simplemente usar la clase LinkedList proporcionada por la estructura de colecciones. La estructura de colecciones tiene un profundo efecto sobre la manera en que están escritos los programas de Java. Debido a la facilidad con que puede emplearse una de las clases de la colección, apenas es necesario crear su propia solución personalizada. Mediante el uso de una colección estándar, se obtienen tres ventajas importantes: 1. El tiempo de desarrollo se reduce porque las colecciones están completamente probadas y listas para usarse. No necesita dedicar tiempo a desarrollar sus propias implementaciones personalizadas. 2. Las colecciones estándar están implementadas eficientemente. Como regla general, hay pocos beneficios (en caso de que los haya) en crear una implementación personalizada. 3. Su código es más fácil de mantener. Debido a que las colecciones estándar son parte de la API de Java, la mayoría de los programadores están familiarizados con ellas y con la manera en que operan. Por tanto, cualquier persona que trabaje con su código comprenderá un método basado en colecciones. Debido a estas ventajas, las colecciones se han vuelto una parte integral de muchos programas de Java. Las colecciones son un tema extenso. Ningún capítulo único puede demostrar todas sus características o explorar todos sus detalles. Como resultado, el enfoque de este capítulo está en las soluciones que demuestran varias técnicas clave, como el uso de un comparador, la iteración de una colección, la creación de colecciones sincronizadas, etc. El capítulo empieza con una revisión general de las clases e interfaces que abarcan el núcleo de la estructura de colecciones. He aquí las soluciones de este capítulo: • Técnicas básicas de colecciones • Trabaje con listas • Trabaje con conjuntos

161

162

Java: Soluciones de programación • Use Comparable para almacenar objetos en una colección ordenada • Use un Comparator con una colección • Itere en una colección • Cree una cola o una pila empleando Deque • Invierta, gire y ordene al azar una List • Ordene una List y busque en ella • Cree una colección comprobada • Cree una colección sincronizada • Cree una colección inmutable • Técnicas básicas de Map • Convierta una lista de Properties en un HashMap

NOTA Aunque este capítulo presenta una revisión general de la estructura de colecciones que es suficiente para las soluciones de este capítulo, no se analiza el marco conceptual de manera detallada. Puede encontrarse una cobertura adicional de las colecciones en mi libro Java: Manual de referencia, séptima edición.

Revisión general de las colecciones Las colecciones no siempre han sido parte de Java. Originalmente, Java dependía de clases como Dictionary, HashTable, Vector, Stack y Properties para proporcionar las estructuras básicas de datos. Aunque estas clases son muy útiles, no eran parte de un todo unificado. Para remediar esta situación, Java 1.2 agregó el marco conceptual de colecciones, que estandarizó la manera en que su programa maneja los grupos de objetos. Cada versión subsecuente de Java ha agregado y mejorado esta importante API. El núcleo del marco conceptual de colecciones está empaquetado en java.util. Contiene las interfaces que definen colecciones y proporciona varias implementaciones concretas de estas interfaces. Se trata de colecciones que los programadores normalmente consideran cuando usan el término "Collections Framework" y son el eje de este capítulo. Además de las colecciones definidas en java.util, hay otras varias colecciones en java.util. concurrent. Estas colecciones son relativamente nuevas y se agregaron en Java 5. Soportan programación concurrente, pero operan de manera diferente de las demás colecciones. Debido a que la programación concurrente es un tema en sí mismo, no se incluyen las colecciones concurrentes en este capítulo. (Consulte el capítulo 7 para conocer soluciones que usan java.util. concurrent). La estructura de colecciones se define con tres características principales • Un conjunto de interfaces estándar que definen la funcionalidad de una colección • Implementaciones concretas de las interfaces • Algoritmos que operan en las colecciones Las interfaces de la colección determinan las características de ésta. En la parte superior de la jerarquía de la interfaz está Collection, que define las características comunes a todas las colecciones. Las subinterfaces agregan atributos relacionados a tipos específicos de colecciones. Por ejemplo, la interfaz Set especifica la funcionalidad de un conjunto, que es una colección de

Capítulo 5:


163

elementos únicos (es decir, no duplicados). Varias clases, como ArrayList, HashSet y LinkedList proporcionan implementaciones concretas de las interfaces de la colección. Estas implementaciones concretas proporcionan soluciones "integradas" a la mayor parte de las tareas de almacenamiento y recuperación de datos. Los algoritmos son métodos estáticos definidos dentro de la clase Collections que operan sobre las colecciones. Por ejemplo, hay algoritmos que buscan, ordenan o revierten colecciones. En esencia, los algoritmos proporcionan medios estándar de manipulación de colecciones. Cuando trabaja con una colección, a menudo querrá recorrer en bucle sus elementos. Una manera de hacerlos es con un iterador, que está definido por la interfaz Iterator. Un iterador ofrece una manera estandarizada y general de acceder a los elementos de una colección, de una en una. En otras palabras, un iterador proporciona un medio para enumerar el contenido de una colección. Debido a que cada colección implementa Iterator, puede usarse un iterador para recorrer en bucle los elementos de cualquier clase de la colección. Otra característica definida por la estructura de colecciones es el mapa. Un mapa almacena pares clave/valor, aunque los mapas son parte de la estructura de colecciones, no son "colecciones" en el estricto sentido del término, porque no implementan la interfaz Collection. Sin embargo, puede obtener una vista de colección de un mapa. Esa vista contiene los elementos del mapa almacenados en una colección. Por tanto, puede procesar el contenido de un mapa como una colección, si lo decide.

Tres cambios recientes Como tal vez lo sepa, el lenguaje Java experimentó un cambio sustancial cuando se agregaron varias características nuevas en Java 5. Tres de estas características tuvieron un profundo impacto en la estructura de colecciones: elementos genéricos, autoencuadre y el estilo for-each del bucle for. Aunque estas características son ahora una parte establecida de la programación en Java, no todos los programadores están conscientes de la manera en que han impactado a las colecciones. Debido a que las soluciones de este capítulo hacen uso de estas características, es necesario un breve análisis. Con la versión de Java 5, toda la API de Java, incluida la estructura de colecciones, experimentó una reingeniería para adecuarse a los elementos genéricos. Como resultado, hoy en día todas las colecciones son genéricas, y muchos de los métodos que operan en colecciones toman parámetros de tipo genérico. Los elementos genéricos mejoran las colecciones al agregar seguridad de tipo. Antes de los elementos genéricos, todas las colecciones se almacenaban en las referencias a Object, lo que significa que cualquier colección podría almacenarse en cualquier tipo de objeto. Por tanto, era posible almacenar por accidente tipos incompatibles en una colección. Al hacer esto daba como resultado errores de falta de correspondencia de tipo en tiempo de ejecución. Con los elementos genéricos, el tipo de datos que se está almacenado se especifica explícitamente, y pueden evitarse la falta de correspondencia de tipo en tiempo de ejecución. Las características de autoencuadre/desencuadre facilitan el almacenamiento de tipos primitivos en colecciones. Una colección sólo puede almacenar referencias, no tipos primitivos. En el pasado, si quería almacenar un tipo primitivo en una colección, tenía que incluirlo manualmente en su envoltura de tipo. Por ejemplo, para almacenar un valor int, necesitaba crear un objeto Integer que contenía ese valor. Cuando se recuperaba el valor, necesitaba desencuadrarse manualmente (usando una conversión explícita) en su tipo primitivo apropiado. Debido al autoencuadre/desencuadre, Java puede ahora realizar en forma automática el encuadre y el desencuadre apropiados necesarios cuando se almacenan o recuperan tipos primitivos. No es necesario realizar manualmente estas operaciones. Esto facilita mucho el almacenamiento de tipos primitivos en una colección. Todas las clases de colecciones implementan ahora la interfaz Iterable. Esto permite que se recorra una colección en bucle mediante el uso del estilo for-each del bucle for. En el pasado. La iteración

164


de una colección requería el uso de un iterador. Aunque los iteradores aún son necesarios para algunos usos, en muchos casos los bucles basados en iterador pueden reemplazarse con bucles for. RECUERDE Debido a que los ejemplos de código usan de manera extensa estas características más recientes, debe usar JDK 5 o posterior para compilarlos y ejecutarlos.

Las interfaces de Collection La estructura de colecciones está definida por un conjunto de interfaces, que se muestran en la tabla 5-1. En la parte superior de la jerarquía de las interfaces se encuentra una Collection. Todas las colecciones deben implementarla. De Collection se derivan varias subinterfaces, como List y Set, que definen tipos específicos de colecciones, como listas y conjuntos. Además de las interfaces de colección, las colecciones también usan las interfaces Comparator, RandomAccess, Iterator y ListIterator. Comparator define la manera en que dos objetos se comparan. Iterator y ListIterator enumeran los objetos dentro de una colección. Al implementar RandomAccess, una lista indica que soporta eficiente, aleatorio a sus elementos. La estructura de colecciones soporta colecciones modificables e inmutables. Para permitir esto, las interfaces de colección permiten métodos que modifican una colección para que sea opcional. Si se trata de usar uno de estos métodos en una colección inmutable, se lanza una UnedOperationException. Todas las colecciones integradas son modificables, pero es posible obtener una vista inmutable de una colección. (La obtención de una colección inmutable se describe en Cree una colección inmutable).

La interfaz Collection La interfaz Collection especifica la funcionalidad común a todas las colecciones, y cualquier clase que defina una colección debe implementarla. Collection es una interfaz genérica que tiene esta declaración: Interface Collection<E> Interfaz

Descripción

Collection

Le permite trabajar con grupos de objetos. Collection se encuentra en la parte superior de la jerarquía de colecciones, y todas las clases de la colección deben implementarla.

Deque

Extiende Queue para manejar una cola de doble final.

List

Extiende Collection para que maneje secuencias (listas de objetos).

NavigableSet

Extiende SortedSet para manejar la recuperación de elementos basados en búsquedas de las coincidencias más cercanas.

Queue

Extiende Collection para manejar tipos especiales de listas en que los elementos sólo se eliminan de la cabeza.

Set

Extiende Collection para manejar conjuntos, que deben contener elementos únicos.

SortedSet

Extiende Set para manejar conjuntos ordenados.

Tabla 5-1 Las interfaces de Collection

Capítulo 5:


165

Aquí, E especifica el tipo de objetos que contendrá la colección. Collection extiende la interfaz Iterable. Esto significa que todas las colecciones pueden recorrerse en bucle mediante el uso del estilo for-each del bucle for. (Sólo las clases que implementan Iterable puede iterarse con for). Los métodos declarado por Collection se resumen en la tabla 5-2. Son posibles varias excepciones. Una UnedOperationException se lanza si se hace un intento de modificar una colección inmutable. Una ClassCastExcepction se genera cuando un objeto es incompatible con otro, como cuando se hace un intento por agregar un objeto incompatible a una colección. Se lanza una NullPointerException si se hace un intento de almacenar un objeto null y no se permiten elementos null en la colección. Una IllegalArgumentException se lanza si se usa un argumento no válido. Una IllegalStateException se lanza si se hace un intento de agregar un elemento a una columna de longitud fija que está llena. Método

Descripción

boolean add(E obj)

Agrega obj a la colección que invoca. Devuelve verdadero si se agregó obj a la colección. Devuelve falso si obj ya es miembro de la colección y ésta no permite duplicados.

boolean addAll(Collection col)

Agrega todos los elementos de col a la colección que invoca. Devuelve verdadero si la operación tuvo éxito (es decir, se agregaron los elementos). De otra manera, devuelve falso.

void clear( )

Elimina todos los elementos de la colección que invoca.

boolean contains(Object obj)

Devuelve verdadero si obj es un elemento de la colección que invoca. De otra manera, devuelve falso.

boolean containsAll(Collection col)

Devuelve verdadero si la colección que invoca contiene todos los elementos de col. De otra manera, devuelve falso.

boolean equals(Object obj)

Devuelve verdadero si la colección que invoca y obj son iguales. De otra manera, devuelve falso. El significado preciso de "igualdad" puede diferir de una colección a otra. Por ejemplo, puede implementarse equals( ) para que compare los valores de elementos almacenados en la colección. Como opción, equals( ) podría comparar referencias a esos elementos.

int hashCode( )

Devuelve el código de hash para la colección que invoca.

boolean isEmpty( )

Devuelve verdadero si la colección que invoca está vacía. De otra manera, devuelve falso.

Iterator<E> iterator( )

Devuelve un iterador para la colección que invoca.

boolean remove(Object obj)

Elimina un elemento que coincide con obj de la colección que invoca. Devuelve verdadero si se eliminó el elemento. De otra manera, devuelve falso.

boolean removeAll(Collection col)

Elimina todos los elementos de col de la colección que invoca. Devuelve verdadero si la colección cambió (es decir, se eliminaron elementos). De otra manera, devuelve falso.

Tabla 5-2 El método definido por Collection

166


Método

Descripción

boolean reatainAll(Collection col)

Elimina todos los elementos de la colección que invoca, excepto los de col. Devuelve verdadero si la colección cambió (es decir, se eliminaron elementos). De otra manera, devuelve false.

int size( )

Devuelve el número de elementos contenidos en la colección que invoca.

Object[ ] toArray( )

Devuelve una matriz que contiene todos los elementos almacenados en la colección que invoca. Los elementos de la matriz son copias de los elementos de la colección.

T[ ] toArray(T matriz[ ])

Devuelve una matriz que contiene los elementos de la colección que invoca. Los elementos de la matriz son copias de los de la colección. Si el tamaño de la matriz es igual al número de elementos, se devuelven en matriz. Si el tamaño de la matriz es menor que el número de elementos, se asigna una nueva matriz del tamaño necesario y se devuelve. Si el tamaño de la matriz es mayor que el número de elementos, el elemento de la matriz que sigue al último elemento de la colección se establece en null. Se lanza una ArrayStoreException si cualquier elemento de la colección tiene un tipo que no es un subtipo de la matriz.

Tabla 5-2 El método definido por Collection (continuación)

La interfaz List La interfaz List extiende Collection y declara el comportamiento de una colección que almacena una secuencia de elementos. Los elementos pueden insertarse (o es posible acceder a ellos) por su posición en la lista, empleando un índice basado en el cero. Una lista puede contener elementos duplicados. List es una interfaz genérica que tiene esta declaración: interface List<E> Aquí, E especifica el tipo de objetos que contendrá la lista. Además de los métodos definidos por Collection, List define algunos propios, que se resumen en la tabla 5-3. Ponga especial atención a los métodos get( ) y set( ). Proporcionan a los elementos de la lista mediante un índice. El método get( ) obtiene el objeto almacenado en una ubicación específica, y set( ) asigna un valor al elemento especificado en la lista. List especifica que el método equals( ) debe comparar el contenido de dos listas, devolviendo verdadero sólo si son exactamente iguales. (En otras palabras, deben contener los mismos elementos, en la misma secuencia). Si no, equals( ) devuelve falso. Por tanto, cualquier colección que implementa List también implementa equals( ) de esta manera. Varios de estos métodos lanzarán una UnedOperationException si se hace un intento por modificar una colección inmutable, y se genera una ClassCastException cuando un objeto es incompatible con otro, como cuando se hace un intento por agregar un objeto incompatible a una colección. Se lanza una NullPointerException si se hace un intento de almacenar un objeto null y no se permiten elementos null en la lista. Se lanza una IllegalArgumentException si se usa un argumento no válido.

Capítulo 5:


167

Método

Descripción

void add(int ind, E obj)

Inserta obj en la lista que invoca en el índice pasado en ind. Cualquier elemento existente en el punto de inserción o más allá se desplaza hacia arriba. Por tanto, no se sobrescriben elementos.

boolean addAll(int ind, Collection c)

Inserta todos los elementos de c en la lista que invoca en el índice pasado en ind. Cualquier elemento existente en el punto de inserción o más allá se desplaza hacia arriba. Por tanto, no se sobrescriben elementos. Devuelve verdadero si la lista que invoca cambia y devuelve falso, de otra manera.

E get (int ind)

Devuelve el objeto almacenado en el índice especificado dentro de la colección que invoca.

int indexOf(Object obj)

Devuelve el índice de la primera instancia de obj en la lista que invoca. Si obj no es un elemento de la lista, se devuelve –1.

int lastIndexOf(Object obj)

Devuelve el índice de la última instancia de obj en la lista que invoca. Si obj no es un elemento de la lista, se devuelve –1.

ListIterator<E> listIterator( )

Devuelve un iterador al principio de la lista que invoca.

ListIterator<E> listIterator(int ind)

Devuelve un iterador a la lista que empieza en el índice especificado.

E remove(int ind)

Elimina el elemento en la posición ind de la lista que invoca y devuelve el elemento eliminado. La lista resultante se compacta. Es decir, los índices de elementos subsecuentes disminuyen en uno.

E set(int ind, E obj)

Asigna obj a la ubicación especificada por ind dentro de la lista que invoca.

List<E> subList(int inicio, int final)

Devuelve una lista que incluye elementos de inicio a fin –1 en la lista que invoca. Los elementos en la lista devuelta también hacen referencia al objeto que invoca.

Tabla 5-3 Los métodos definidos por List

La interfaz Set La interfaz Set define un conjunto. Extiende Collection y declara el comportamiento de una colección que no permite elementos duplicados. Por tanto, el método add( ) devuelve falso si se hace un intento por agregar elementos duplicados a un conjunto. No define métodos adicionales propios. Set es una interfaz genérica que tiene esta declaración: Interface Set<E> Aquí, E especifica el tipo de objeto que contendrá el conjunto. Set especifica que el método equals( ) debe comparar el contenido de dos conjuntos, devolviendo verdadero sólo si ambos contienen los mismos elementos. Si no, entonces equals( ) devuelve falso. Por tanto, cualquier colección que implemente Set, implementa equals( ) de esta manera.

168


La interfaz SortedSet La interfaz SortedSet extiende Set y declara el comportamiento de un conjunto ordenado en orden ascendente. SortedSet es una interfaz genérica que tiene esta declaración: Interface SortedSet<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. Además de los métodos definidos por Set, la interfaz SortedSet declara los métodos resumidos en tabla 5-4. Estos métodos hacen que el procesamiento sea más conveniente. Varios métodos lanzan NoSuchElementException cuando no hay elementos en el conjunto que invoca. Se lanza una ClassCastException cuando un objeto es incompatible con los elementos de un conjunto. Se lanza una NullPointerException si se hace un intento de usar un objeto null y no se permiten elementos null en el conjunto. Se lanza una IllegalArgumentException si se usa un argumento no válido.

La interfaz NavigableSet Una reciente adición a la estructura de colecciones es NavigableSet. Se añadió en Java 6 y extiende SortedSet. NavigableSet declara el comportamiento de una colección que da soporte a la recuperación de elemento con base en una coincidencia más cercana a un valor o varios valores determinados. NavigableSet es una interfaz genérica que tiene esta declaración: Interface NavigableSet<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. Además de los métodos que hereda de SortedSet, NavigableSet agrega los resumidos en la tabla 5-5. Se lanza una ClassCastException cuando un objeto es incompatible con los elementos de un conjunto. Se lanza una NullPointerException si se hace un intento de usar un objeto null y no se permiten elementos null en el conjunto. Se lanza una IllegalArgumentException si se usa un argumento no válido. Método

Descripción

Comparator comparator( )

Devuelve el comparador de un conjunto ordenado. Si se usa el ordenamiento natural para este conjunto, se devuelve null.

E first( )

Devuelve el primer elemento del conjunto ordenado que invoca.

SortedSet<E> headSet(E fin)

Devuelve un SortedSet que contiene esos elementos menos que final que está contenido en el conjunto ordenado que invoca. Éste último también hace referencia a los elementos en el conjunto ordenado devuelto.

E last( )

Devuelve el último elemento en el conjunto ordenado que invoca.

SortedSet<E> subSet(E inicio, E fin)

Devuelve un SortedSet que incluye los elementos que se encuentran entre inicio y fin–1. El objeto que invoca también hace referencia a los elementos en la colección devuelta.

SortedSet<E> tailSet(E inicio)

Devuelve un SortedSet que incluye los elementos mayores o iguales a inicio que están contenidos en el conjunto ordenado. El objeto que invoca también hace referencia a elementos en el conjunto devuelto.

Tabla 5-4 Los métodos definidos por SortedSet

Capítulo 5:


169

Método

Descripción

E ceiling(E obj)

Busca en el conjunto el elemento más pequeño e tal que e >= obj. Si se encuentra ese elemento, se devuelve. De otra manera, se devuelve null.

Iterator<E> descendingIterator( )

Devuelve un iterador que va del mayor al menor. En otras palabras, devuelve un iterador inverso.

NavigableSet<E> descendingSet( )

Devuelve un NavigableSet que es lo inverso del conjunto que invoca. El conjunto resultante está respaldado por el conjunto que invoca.

E floor(E obj)

Busca en el conjunto el elemento más grande e tal que e <= obj. Si se encuentra ese elemento, se devuelve. De otra manera, se devuelve null.

NavigableSet<E> headSet(E limiteSuperior, boolean incl)

Devuelve un NavigableSet que incluye todos los elementos del conjunto que invoca que es menor que limiteSuperior. Si incl es true, entonces se incluye un elemento igual a limiteSuperior. El conjunto resultante está respaldado por el conjunto que invoca.

E higher(E obj)

Busca en el conjunto el elemento más pequeño e tal que e > obj. Si se encuentra ese elemento, se devuelve. De otra manera, se devuelve null.

E lower(E obj)

Busca en el conjunto el elemento más grande e tal que e < obj. Si se encuentra ese elemento, se devuelve. De otra manera, se devuelve null.

E pollFirst( )

Devuelve el primer elemento, eliminando el elemento en el proceso. Debido a que el conjunto está ordenado, es el elemento con el valor menor. Se devuelve null si el conjunto está vacío.

E pollLast( )

Devuelve el último elemento, eliminando el elemento en el proceso. Debido a que el conjunto está ordenado, es el elemento con el valor mayor. Se devuelve null si el conjunto está vacío.

NavigableSet<E> subSet(E limiteInferior, boolean inclbajo, E, limiteSuperior, boolean inclalto)

Devuelve un NavigableSet que incluye todos los elementos del conjunto que invoca que son mayores que limiteInferior y menores que limiteSuperior. Si inclbajo es verdadero, entonces se incluye un elemento igual a limiteInferior. Si inclalto es verdadero, entonces se incluye un elemento igual a limiteSuperior. El conjunto resultante es respaldado por el conjunto que invoca.

NavigableSet<E> tailSet(E limiteInferior, boolean incl)

Devuelve un NavigableSet que incluye todos los elementos del conjunto que invoca que son mayores que limiteInferior. Si incl es verdadero, entonces se incluye un elemento igual a limiteInferior. El conjunto resultante es respaldado por el conjunto que invoca.

Tabla 5-5 Los métodos definidos por NavigableSet

170


La interfaz Queue La interfaz Queue extiende Collection y declara el comportamiento de una cola. Las colas son a menudo listas primero en entrar primero en salir, pero hay tipos de colas en que el orden está basado en otros criterios. Queue es una interfaz genérica que tiene esta declaración: interface Queue<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. Además de los métodos que hereda Queue de Collection, define varios de su propiedad. Se muestran en la tabla 5-6. Varios métodos lanzan una ClassCastException cuando un objeto es incompatible con los elementos de la cola. Se lanza una NullPointerException si se hace un intento de almacenar un objeto null y no se permiten elementos null en la cola. Una IllegalArgumentException se lanza si se usa un argumento no válido. Se lanza una IllegalStateException si se hace un intento por agregar un elemento a una cola de longitud fija que está llena. Algunos métodos lanzan una NoSuchElementException si se hace un intento por eliminar un elemento de una cola vacía. Queue tiene varias características interesante. En primer lugar, los elementos sólo pueden eliminarse desde la cabeza de la cola. En segundo lugar, hay dos métodos que obtienen y eliminan elementos: poll( ) y remove( ). La diferencia entre ellos es que poll( ) devuelve null si la cola está vacía, pero remove( ) lanza una excepción NoSuchElementException. En tercer lugar, hay dos métodos, element( ) y peek( ), que obtienen, pero no eliminan el elemento en la cabeza de la cola. Sólo difieren en que element( ) lanza una excepción NoSuchElementException si la cola está vacía, pero peek( ) devuelve null. Por último, tome nota de que offer( ) sólo trata de agregar un elemento a una cola. Debido a que las colas de longitud fija son permitidas y ese tipo de cola podría estar lleno, offer( ) puede fallar. Si lo hace, offer( ) devuelve falso. Esto difiere de add( ) (heredado de Collection), que lanzará una IllegalStateException si se hace un intento por agregar un elemento a una cola llena, de longitud fija. Por tanto, Queue le da dos maneras de manejar estados de cola llena y vacía cuando realiza operaciones de cola: al manejar excepciones o al monitorear valores de devolución. Debe elegir el método más apropiado para su aplicación. Método

Descripción

E element( )

Devuelve el elemento en la cabeza de la cola. El elemento no se elimina. Lanza NoSuchElementException, si la cola está vacía.

boolean offer(E obj)

Trata de agregar obj a la cola. Devuelve verdadero si se agregó obj y falso de otra manera.

E peek( )

Devuelve el elemento a la cabeza de la cola. Devuelve null si la cola está vacía. El elemento no se elimina.

E poll( )

Devuelve el elemento a la cabeza de la cola, eliminando éste en el proceso. Devuelve null si la cola está vacía.

E remove( )

Elimina el elemento a la cabeza de la cola, devolviendo el elemento en el proceso. Lanza NoSuchElementException, si la cola está vacía.

Tabla 5-6 Los métodos definidos por Queue

Capítulo 5:


171

La interfaz Deque Otra adición reciente a la estructura de colecciones es Deque. Se agregó en Java 6 y extiende Queue. Deque declara el comportamiento de una cola de doble extremo. Las colas de doble extremo funcionan como colas primero en entrar primero en salir, o como pilas último en entrar primero en salir. Deque es una interfaz genérica que tiene esta declaración: interface Deque<E> Aquí, E especifica el tipo de objetos que contendrá Deque. Además de los métodos que hereda de Queue, Deque agrega estos métodos resumidos en la tabla 5-7. Varios métodos lanzan una ClassCastException cuando un objeto es incompatible con los elementos en la cola de doble extremo. Se lanza una NullPointerException si se hace un intento por almacenar un objeto null y no se permiten elementos null en la cola de doble extremo. Se lanza una IllegalArgumentException si se usa un argumento no válido. Se lanza una IllegalStateException si se hace un intento de agregar un elemento a una cola de doble extremo de longitud fija que está llena. Se lanza una NoSuchElementException si se hace un intento por eliminar un elemento de una cola de doble extremo vacía. Tal vez las características más importantes de Deque son push( ) y pop( ). Estos métodos suelen usarse para habilitar el funcionamiento de Deque como una pila. Para poner un elemento en la parte superior de la pila, se llama a push( ). Para eliminar el elemento superior, se llama a pop( ). Además, observe el método descendingIterator( ). Devuelve un iterador que devuelve elementos en orden inverso. En otras palabras, devuelve un iterador que va del final de la colección al principio. Método

Descripción

void addFirst(E obj)

Agrega obj a la cabeza de la cola de doble extremo. Lanza una IllegalStateException si una cola de doble extremo de capacidad restringida se queda sin espacio.

void addLast(E obj)

Agrega obj al final de la cola de doble extremo. Lanza una IllegalStateException si una cola de doble extremo de capacidad restringida se queda sin espacio.

Iterator<E> descendingIterator( )

Devuelve un iterador que va del final a la cabeza de la cola de doble extremo. En otras palabras, devuelve un iterador inverso.

E getFirst( )

Devuelve el primer elemento en la cola de doble extremo. El objeto no se elimina de la cola de doble extremo. Lanza una NoSuchElementException si la cola de doble extremo está vacía.

E getLast( )

Devuelve el último elemento en la cola de doble extremo. El objeto no se elimina de la cola de doble extremo. Lanza una NoSuchElementException si la cola de doble extremo está vacía.

boolean offerFirst(E obj)

Trata de agregar obj a la cabeza de la cola de doble extremo. Devuelve verdadero si se agregó obj y falso, de otra manera. Por tanto, este método devuelve falso cuando se hace un intento por agregar obj a una cola de doble extremo llena, de capacidad restringida.

boolean offerLast(E obj)

Trata de agregar obj al final de la cola de doble extremo. Devuelve verdadero si se agregó obj y falso, de otra manera.

Tabla 5-7 Los métodos definidos por Deque

172


Método

Descripción

E peekFirst( )

Devuelve el elemento que se encuentra a la cabeza de la cola de doble extremo. Devuelve null si la cola de doble extremo está vacía. No se elimina el objeto.

E peekLast( )

Devuelve el elemento que se encuentra al final de la cola de doble extremo. Devuelve null si la cola de doble extremo está vacía. No se elimina el objeto.

E pollFirst( )

Devuelve el elemento que se encuentra a la cabeza de la cola de doble extremo, eliminando el elemento en el proceso. Devuelve null si la cola de doble extremo vacía.

E pollLast( )

Devuelve el elemento que se encuentra al final de la cola de doble extremo, eliminando el elemento en el proceso. Devuelve null si la cola de doble extremo está vacía.

E pop( )

Devuelve el elemento que se encuentra a la cabeza de la cola de doble extremo, eliminándolo en el proceso. Lanza NoSuchElementException si la cola de doble extremo está vacía.

void push(E obj)

Agrega obj a la cabeza de la cola de doble extremo. Lanza una IllegalStateException si una cola de doble extremo de capacidad restringida se queda sin espacio.

E removeFirst( )

Devuelve el elemento a la cabeza de la cola de doble extremo, eliminando el elemento en el proceso. Lanza NoSuchElementException si la cola de doble extremo está vacía.

boolean removeFirstOcurrence(Object obj)

Elimina la primera presentación de obj de la cola de doble extremo. Devuelve verdadero si tiene éxito y falso si la cola de doble extremo no contiene obj.

E removeLast( )

Devuelve el elemento que se encuentra al final de la cola de doble extremo, eliminando el elemento en el proceso. Lanza NoSuchElementException si la cola de doble extremo está vacía.

boolean removeLastOcurrence(Object obj)

Elimina la última presentación de obj de la cola de doble extremo. Devuelve verdadero si tiene éxito y falso si la cola de doble extremo no contiene obj.

Tabla 5-7 Los métodos definidos por Deque (continuación)

Una implementación de Deque puede tener capacidad restringida, lo que significa que sólo puede agregarse a la cola un número limitado de elementos. Cuando éste es el caso, puede fallar un intento de agregar un elemento a la cola de doble extremo. Deque le permite manejar esta falla de dos maneras. En primer lugar, métodos como push( ), addFirst( ) y addLast( ) lanzan una IllegalStateException si una cola de doble extremo de capacidad restringida está llena. En segundo lugar, otros métodos, como offerFirst( ) y offerLast( ), devuelven falso si el elemento no puede agregarse. Tiene la opción de seleccionar el método más adecuado para su aplicación.

Capítulo 5:


173

Una situación similar ocurre en la eliminación de elementos de una cola de doble extremo. Métodos como pop( ) y removeFirst( ) lanzan una NoSuchElementException si se llaman en una colección vacía. Métodos como pollFirst( ) o pollLast( ) devuelven null si la colección está vacía. Una vez más, elija el método más compatible con su aplicación.

Las clases de la colección Las clases de la colección implementan las interfaces de la colección. Algunas de las clases proporcionan implementaciones completas que pueden usarse tal como están. Otras son abstractas, proporcionando esqueletos de implementaciones que se usan como puntos de partida para crear colecciones concretas. Las clases de la colección definidas en java.util están resumidas en la tabla siguiente. Las soluciones de este capítulo usan varias de esas clases. A continuación se presenta una breve revisión general de cada colección concreta. Clase

Descripción

AbstractCollection

Implementa la mayor parte de la interfaz Collection. Es una superclase para todas las clases de la colección concreta.

AbstractList

Extiende AbstractCollection e implementa la mayor parte de la interfaz List.

AbstractQueue

Extiende AbstractCollection e implementa la mayor parte de la interfaz Queue.

AbstractSequentialList

Extiende AbstractList para que lo use una colección que emplee secuencial en lugar de aleatorio de sus elementos.

AbstractSet

Extiende AbstractCollection e implementa la mayor parte de la interfaz Set.

ArrayDeque

Implementa una cola de doble extremo al extender AbstractCollection e implementa la interfaz Deque.

ArrayList

Implementa una matriz dinámica al extender AbstractList.

EnumSet

Extiende AbstractSet para que se use con elementos enum.

HashSet

Extiende AbstractSet para que se use con una tabla de hash.

LinkedHashSet

Extiende HashSet para permitir la iteración de inserción de orden.

LinkedList

Implementa una lista vinculada al extender AbstractSequentialList. También implementa la interfaz Deque.

PriorityQueue

Extiende AbstractQueue para que soporte una cola basada en prioridad.

TreeSet

Implementa un conjunto almacenado en un árbol. Extiende AbstractSet e implementa la interfaz SortedSet.

La clase ArrayList ArrayList da soporte a matrices dinámicas que pueden crecer o reducirse de acuerdo con lo necesario. En otras palabras, puede aumentarse o reducirse el tamaño de una ArrayList en tiempo de ejecución. Una ArrayList se creó con un tamaño inicial. Cuando se excede este tamaño, la colección se alarga automáticamente. Cuando se eliminan los objetos, la matriz puede reducirse.

174


ArrayList extiende AbstractList e implementa la interfaz List. (También implementa RandomAccess para indicar que da soporte a rápido aleatorio a sus elementos). Es una clase genérica que tiene esta declaración: Class ArrayList<E> Aquí, E especifica el tipo de objetos que contendrá la lista. ArrayList define estos constructores: ArrayList( ) ArrayList(Collection col) ArrayList(int capacidad) El primer constructor elabora una lista de matrices vacías. El segundo, construye una lista de matrices que se inicializan con los elementos de la colección col. El tercero, una lista de matrices que tienen la capacidad inicial especificada. La capacidad es el tamaño de la matriz que se usa para almacenar los elementos y crece automáticamente a medida que se agregan elementos a la lista de matrices. En los casos en que sabe que cierto número mínimo de elementos habrá de almacenarse, puede establecer la capacidad inicial de antemano. Esto evita reasignaciones subsecuentes, que son costosas en cuanto a tiempo. ArrayList representa una opción útil a las matrices normales de Java. En este lenguaje, las matrices tienen una longitud fija. Después de que se ha creado una matriz, no puede crecer o reducirse, lo que significa que debe saber de antemano cuántos elementos contendrá una matriz. Sin embargo, en ocasiones esto no es posible. Por ejemplo, tal vez quiera usar una matriz que contendrá una lista de valores (como números de ID de producto) recibidos vía una conexión de Internet en que la lista termina con un valor especial. Por tanto, el número de valores no es conocido hasta que se haya recibido el terminador. En tal caso, ¿de qué tamaño hará la matriz que recibirá los valores? ArrayList ofrece una solución a este tipo de problema. Además del método definido por las interfaces que implementa, ArrayList define dos métodos propios: ensureCapacity( ) y trimToSize( ). Aquí se muestran: void ensureCapacity(int cap) void trimToSize( ) El método ensureCapacity( ) le permite aumentar manualmente la capacidad de una ArrayList, que es el número de elementos que puede contener antes de que sea necesario agrandar la lista. La nueva capacidad se especifica con cap. Como opción, trimToSize( ) le permite reducir el tamaño de una ArrayList de modo que se adecue de manera precisa al número de elementos que contiene.

La clase LinkedList LinkedList proporciona una estructura de datos de lista vinculada. Extiende AbstractSequentialList e implementa las interfaces List y Deque. Debido a que usa una lista doblemente vinculada, una LinkedList crecerá automáticamente cuando se agregue un elemento a la lista y se reducirá cuando se elimine uno. Las listas vinculadas son especialmente útiles en situaciones en que los elementos se insertan o eliminan de la parte media de la lista. Los nuevos elementos simplemente se vinculan en ellas. Cuando se elimina un elemento, los vínculos a viejos elementos se reemplazan con vínculos a los elementos que anteceden y siguen al elemento eliminado. La reorganización de vínculos suele ser más eficiente que la compactación o expansión física de una matriz, por ejemplo. LinkedList es una clase genérica que tiene esta declaración: Class LinkedList<E>

Capítulo 5:


175

Aquí, E especifica el tipo de objetos que contendrá la lista. LinkedList tiene los dos constructores que se muestran aquí: LinkedList( ) LinkedList(Collection col) El primer constructor crea una lista vinculada vacía. El segundo, una que se inicializa con los elementos de la colección col.

La clase HashSet HashSet crea una colección que usa una tabla de hash para almacenamiento. Una tabla de hash almacena información a la que se le ha aplicado hash. En este proceso, se usa el contenido informativo de una clave para determinar un valor único, llamado código de hash. Éste se emplea después como el índice en que se almacenan los datos relacionados con la clave. La transformación de la clave en su código de hash se realiza automáticamente (nunca ve el propio código de hash). Además, su código no puede indizar directamente la tabla de hash. La ventaja de la aplicación de hash es que permite que el tiempo de ejecución de add( ), contains( ), remove( ) y size( ) permanezca constante aun en conjuntos grandes. No se permiten elementos duplicados en un HashSet. HashSet extiende AbstractSet e implementa una interfaz Set. Se trata de una clase genérica que tiene esta declaración: class HashSet<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. HashSet define los siguientes constructores: HashSet( ) HashSet(Collection col) HashSet(int capacidad) HashSet(int capacidad, float relRelleno) La primera forma construye un conjunto de hash predeterminado. La segunda, inicializa el conjunto de hash al usar los elementos de colección. La tercera, inicializa la capacidad del conjunto de hash en capacidad. La cuarta, inicializa la capacidad y la relación de relleno (también denominada capacidad de carga) del conjunto de hash. La relación de relleno debe estar entre 0.0 y 1.0, y determina cuán lleno puede estar el conjunto de hash antes de que puede aumentarse su tamaño. Específicamente, cuando el número de elementos es mayor que la capacidad del conjunto de hash multiplicado por su relación de relleno, el conjunto de relleno se expande. En el caso de constructores que no toman una relación de relleno, se usa 0.75. He aquí un punto clave relacionado con HashSet: los elementos no se encuentran en ningún orden determinado. Por ejemplo, no están ordenados, ni se almacenan en un orden de inserción. Esto se debe a que el proceso de hash no tiende en sí mismo a la creación de conjuntos ordenados. Por tanto, no está especificado el orden en que se obtienen los elementos cuando se enumera la colección mediante un iterador o un estilo for-each del bucle for.

La clase LinkedHashSet LinkedHashSet usa una tabla de hash para almacenamiento, pero también mantiene una lista de doble vínculo de los elementos de la colección. Esta lista se encuentra en el orden en que se insertan los elementos en la colección. Esto permite la iteración del orden de inserción en el conjunto. Es decir, cuando se recorre un LinkedHashSet empleando un iterador o un estilo for-each del bucle

176


for, los elementos se devolverán en el orden en que se insertaron. Sin embargo, aún se conservan los beneficios de búsqueda rápida de los elementos con hash. LinkedHashSet extiende HashSet y no agrega propios. Es una clase genérica que tiene esta declaración: class LinkedHashSet<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. LinkedhashSet define los siguientes constructores: LinkedHashSet( ) LinkedHashSet(Collection col) LinkedHashSet(int capacidad) LinkedHashSet(int capacidad, float relRelleno) Funcionan igual que sus equivalentes correspondientes en HashSet.

La clase TreeSet TreeSet crea una colección ordenada que usa un árbol para almacenamiento. Los objetos se almacenan en orden ascendente. Debido a la estructura del árbol, los tiempos de y recuperación son muy rápidos. Esto hace que TreeSet sea una excelente opción para rápido a grandes cantidades de información ordenada. La única restricción es que no se permiten elementos duplicados en el árbol. TreeSet extiende AbstractSet e implementa la interfaz NavigableSet. Se trata de una clase genérica que tiene esta declaración: class TreeSet<E> Aquí, E especifica el tipo de objetos que contendrá el conjunto. TreeSet tiene los siguientes constructores: TreeSet( ) TreeSet(Collection col) TreeSet(Comparator comp) TreeSet(SortedSet<E> ss) La primera forma construye un conjunto de árbol vacío que se ordenará de manera ascendente, de acuerdo con el orden natural de sus elementos. La segunda, construye un conjunto de árbol que contiene los elementos de col. La tercera, un conjunto vacío que estará ordenado de acuerdo con el comparador especificado por comp. La cuarta, uno que contiene los elementos de ss.

La clase PriorityQueue PriorityQueue crea una cola en que los elementos se almacenan de acuerdo con su prioridad. Como opción predeterminada, la prioridad se basa en el orden natural de los elementos. Sin embargo, puede modificar este comportamiento al especificar un comparador cuando se construye la PriorityQueue. PriorityQueue extiende AbstractQueue e implementa la interfaz Queue. Es una clase genérica que tiene esta declaración: class PriorityQueue<E>

Capítulo 5:


177

Aquí, E especifica el tipo de objetos almacenados en la cola. Las colas de PriorityQueue son dinámicas, y crecen conforme sea necesario. PriorityQueue define los seis constructores que se muestran aquí: PriorityQueue( ) PriorityQueue(int capacidad) PriorityQueue(int capacidad, Comparator comp) PriorityQueue(Collection col) PriorityQueue(PriorityQueue col) PriorityQueue(SortedSet col) El primer constructor construye una cola vacía, con una capacidad inicial de 11. El segundo, construye una cola que tiene la capacidad inicial especificada. El tercero, una cola con una capacidad especificada y un comparador. Los últimos tres constructores crean colas que están inicializadas con los elementos de la colección pasados en col. En todos los casos, la capacidad crece automáticamente a medida que se agregan elementos. Si se especifica un comprador cuando se construye una PriorityQueue, entonces se usa el comparador predeterminado para el tipo de datos almacenados en la cola. El comparador predeterminado ordenará la cola de manera ascendente. Por tanto, la cabeza de la cola será el valor más pequeño. Sin embargo, al proporcionar un comparador predeterminado, puede especificar un esquema de orden diferente. Por ejemplo, cuando se almacenan elementos que incluyen una estampa de tiempo, puede priorizar la cola de tal manera que los elementos más antiguos sean los primeros de la cola. Consulte Use un Comparator con una colección para conocer un ejemplo. Además de los métodos especificados por las interfaces que implementa, PriorityQueue define un método adicional: comparator( ). Devuelve una referencia al comparador usado por una PriorityQueue en orden de prioridad; debe llamar a poll( ) o remove( ).

La clase ArrayDeque ArrayDeque se agregó en Java 6, lo que la hace una adición reciente a la estructura de colecciones. Crea una matriz dinámica basada en la interfaz Deque. Esto hace que resulte especialmente útil para implementar pilas y colas cuyos tamaños no se conocen de antemano. Además de implementar Deque, ArrayDeque extiende AbstractCollection. ArrayDeque es una clase genérica que tiene esta declaración: class ArrayDeque<E> Aquí, E especifica el tipo de objetos almacenados en la colección: ArrayDeque define los siguientes constructores: ArrayDeque( ) ArrayDeque(int tam) ArrayDeque(Collection col)

178


El primer constructor crea una cola vacía con una capacidad inicial de 16. El segundo, construye una cola de doble extremo que tiene la capacidad inicial especificada. El tercero, crea una cola de doble extremo que se inicializa cuando los elementos de la colección pasados en col. En todos los casos, la capacidad crece conforme sea necesario para manejar los elementos agregados a la colección.

La clase EnumSet EnumSet es una colección específicamente diseñada para usarla con valores del tipo enum. Extiende AbstractSet e implementa Set. Es una clase genérica que tiene esta declaración: class EnumSet<E extends Enum<E>> Aquí, E especifica los elementos. Observe que E debe extender Enum<E>, que impone el requisito de que los elementos deben ser del tipo enum especificado. EnumSet no define constructores. En cambio, usa métodos de fábrica, como allOf( ) o range( ), para obtener una instancia de EnumSet.

Revisión general de los mapas Los mapas son parte de la estructura de colecciones pero no son, en sí mismos, colecciones, porque no implementan la interfaz Collection. En lugar de almacenar grupos de objetos, los mapas almacenan pares clave/valor. Una característica que define a los mapas es la capacidad de recuperar un valor dando su clave. En otras palabras, si se da una clave, puede encontrar su valor. Esto hace que un mapa sea una excelente opción en muchas aplicaciones basadas en búsqueda. Por ejemplo, podría usar un mapa para almacenar nombres y números telefónicos. Los nombres son claves y los números son valores. Podría encontrar un número dando el nombre de una persona. En un mapa, tanto claves como valores son objetos. No pueden ser tipos primitivos. Más aún, todas las claves deben ser únicas. Esto tiene sentido porque una clave se usa para encontrar un valor. Por tanto, no puede tener la misma clave asignada a dos valores diferentes. Sin embargo, dos claves diferentes pueden tener asignado el mismo valor. Por tanto, las claves deben ser únicas, pero los valores pueden estar duplicados. Los mapas no implementan la interfaz Iterable. Esto significa que no puede recorrer en bucle un mapa empleando un estilo for-each del bucle for. Tampoco puede obtener un iterador para un mapa. Sin embargo, puede obtener una vista de colección de un mapa, que le permite el uso de su bucle for o un iterador.

Las interfaces de Map Los mapas están definidos por el mismo conjunto de interfaz que se muestra aquí: Interfaz

Descripción

Map

Asigna claves únicas a valores.

Map.Entry

Describe un elemento (un par clave/valor) en un mapa. Es una clase interna de Map.

NavigableMap

Extiende SortedMap para manejar la recuperación de entradas basadas en las búsquedas de la coincidencia más cercana.

SortedMap

Extiende Map para que las claves se mantengan en orden ascendente.

A continuación, se examina cada interfaz.

Capítulo 5:


179

La interfaz Map La interfaz Map vincula claves únicas con valores. Cada par clave/valor constituye una entrada en el mapa. Por tanto, dados una clave y un valor, puede almacenar una entrada en un Map. Después de que la entrada se ha almacenado, puede recuperar su valor usando su clave. Map es genérica y se declara de la siguiente manera: interface Map Aquí, C especifica el tipo de claves y V especifica el tipo de valores. Los métodos declarados por Map se resumen en la tabla 5-8. Preste especial atención a get( ) y put( ). Para almacenar un valor en un mapa, use put( ), especificando la clave y el valor. Para obtener un valor, llame a get( ), pasando la clave como argumento. Se devuelve el valor. Por tanto, get( ) y put( ) definen los métodos fundamentales de almacenamiento y recuperación usados por todas las implementaciones de Map. Método

Descripción

void clear( )

Elimina todos los pares clave/valor del mapa que invoca.

boolean containsKey(Object c)

Devuelve verdadero si el mapa que invoca contiene una c como clave. De otra manera, devuelve falso.

boolean containsValue(Object v)

Devuelve verdadero si el mapa contiene v como valor. De otra manera, devuelve falso.

Set<Map.Entry > entrySet( )

Devuelve un Set que contiene las entradas del mapa. El conjunto contiene objetos de tipo Map.Entry. Por tanto, este método proporciona una vista de conjunto del mapa que invoca.


Devuelve verdadero si obj es un Map y contiene las mismas entradas. De otra manera, devuelve falso.

V get (Object c)

Devuelve el valor asociado con la clave c. Devuelve null si no se encuentra la clave.

int hashCode( )

Devuelve el código de hash para el mapa que invoca.

boolean isEmpty( )

Devuelve verdadero si el mapa que invoca está vacío. De otra manera, devuelve falso.

Set keySet( )

Devuelve un Set que contiene las claves del mapa que invoca. Este método proporciona una vista de conjunto de las claves en el mapa que invoca.

V put(C c, V v)

Pone una entrada en el mapa que invoca, sobrescribiendo cualquier valor anterior asociado con la clave. La clave y el valor son c y v, respectivamente. Devuelve null si la clave aún no existe. De otra manera, se devuelve el valor previo vinculado con la clave.

void putAll(Map m)

Pone todas las entradas desde m hacia este mapa.

V remove(Object c)

Elimina la entrada cuya clave es igual a c. Devuelve el valor eliminado, o null si la clave no se encuentra en el mapa.

int size( )

Devuelve el número de pares clave/valor en el mapa.

Collection values( )

Devuelve una colección que contiene los valores del mapa. Este método proporciona una vista de colección de los valores en el mapa.

Tabla 5-8 Los métodos definidos por Map

180


Varios métodos lanzan una ClassCastException cuando un objeto es incompatible con los elementos de un mapa. Una NullPointerException se lanza si se hace un intento de usar un objeto null y no se permite este tipo de objeto en el mapa. Una UnedOperationExeption se lanza cuando se hace un intento de cambiar un mapa no modificable. Se lanza una IllegalArgumentException si se usa un argumento no válido.

La interfaz SortedMap La interfaz SortedMap extiende Map. Las entradas en el mapa se mantienen y ordenan de acuerdo con las claves. Los mapas ordenados permiten manipulaciones muy eficientes de submapas (en otras palabras, subconjuntos de un mapa). SortedMap es genérica y se declara como se muestra aquí: interface SortedMap Aquí, C especifica el tipo de claves y V especifica el tipo de valores. Además de los métodos especificados por Map, SortedMap agrega varios propios, que se resumen en la tabla 5-9. Varios métodos lanzan un NoSuchElementException cuando no hay elementos en el mapa que invoca. Una ClassCastException se lanza cuando un objeto es incompatible con los elementos de un mapa. Una NullPointerException se lanza si se hace un intento de usar un objeto null y no se permite este tipo de objeto en el mapa. Se lanza una IllegalArgumentException si se usa un argumento no válido.

La interfaz NavigableMap La interfaz NavigableMap es una adición reciente a la estructura de colecciones (se agregó en Java 6). Extiende SortedMap y declara el comportamiento de un mapa que soporta la recuperación de entradas basadas en la coincidencia más cercana a una clave o varias claves dadas. NavigableMap es una interfaz genérica que tiene esta declaración: interface NavigableMap Aquí, C especifica el tipo de claves y V el tipo de valores asociados con las claves. Método

Descripción

Comparator comparator( )

Devuelve el comparador del mapa ordenado. Si se usa orden natural para el mapa que invoca, se devuelve null.

C firstKey( )

Devuelve la primera clave en el mapa que invoca.

SortedMap heap(C final)

Devuelve un mapa ordenado para las entradas de mapa con claves que son menores que final.

C lastKey( )

Devuelve la última clave en el mapa que invoca.

SortedMap subMap(C inicio, C final)

Devuelve un mapa que contiene las entradas con claves que son mayores o iguales a inicio y menores que final.

SortedMap tailMap(C inicio)

Devuelve un mapa que contiene las entradas con claves que son mayores o iguales a inicio.

Tabla 5-9 Los métodos definidos por SortedMap

Capítulo 5:


181

Además de los métodos que hereda de SortedMap, NavigableMap agrega los resumidos en la tabla 5-10. Varios métodos lanzan una ClassCastException cuando un objeto es incompatible con las claves del mapa. Se lanza un NullPointerException si se hace un intento de usar un objeto null y no se permiten claves null en el mapa. Se lanza una IllegalArgumentException si se usa un argumento no válido.

Método

Descripción

Map, Entry ceilingEntry(C obj)

Busca en el mapa la clave c más pequeña, tal que c >= obj. Si se encuentra esa clave, se devuelve su entrada. De otra manera, se devuelve null.

C ceilingKey(C obj)

Busca en el mapa la clave c más pequeña, tal que c >= obj. Si se encuentra esa clave, se devuelve. De otra manera, se devuelve null.

NavigableSet descendingKeySet( )

Devuelve un NavigableSet que contiene las claves en el mapa que invoca en orden inverso. Por tanto, devuelve una vista de conjunto inverso de las claves. El conjunto resultante es respaldado por el mapa.

NavigableMap descendingMap( )

Devuelve un NavigableMap que es inverso al mapa que invoca. El mapa resultante es respaldado por aquel.

Map.Entry firstEntry( )

Devuelve la primera entrada del mapa. Se trata de la entrada con el clave menor.

Map.Entry floorEntry(C obj)

Busca en el mapa la clave más grande c tal que c <= obj. Si se encuentra, se devuelve su entrada. De otra manera, se devuelve null.

C floorKey(C obj)

Busca en el mapa la clave más grande c tal que c <= obj. Si se encuentra, se devuelve. De otra manera, se devuelve null.

NavigableMap heap(C limiteSuperior, boolean incl)

Devuelve un NavigableMap que incluye todas las entradas del mapa que invoca que tienen claves que son menores que limiteSuperior. Si incl es verdadero, se incluye un elemento igual a limiteSuperior. El mapa resultante es respaldado por aquel.

Map.Entry higherEntry(C obj)

Busca en el conjunto la clave más grande c tal que c > obj. Si se encuentra, se devuelve su entrada. De otra manera, se devuelve null.

C higherKey(C obj)

Busca en el conjunto la clave más grande c tal que c > obj. Si se encuentra, se devuelve. De otra manera, se devuelve null.

Tabla 5-10 Los métodos definidos por NavigableMap (continúa)

182


Método

Descripción

Map.Entry lastEntry( )

Devuelve la última entrada del mapa. Es la entrada con la clave más grande.

Map.Entry lowerEntry(C obj)

Busca en el conjunto la clave más grande c tal que c < obj. Si se encuentra, se devuelve su entrada. De otra manera, se devuelve null.

C lowerKey(C obj)

Busca en el conjunto la clave más grande c tal que c < obj. Si se encuentra, se devuelve. De otra manera, se devuelve null.

NavigableSet navigableKeySet( )

Devuelve un NavigableSet que contiene las claves del mapa que invoca. El conjunto resultante es respaldado por éste.

Map.Entry pollFirstEntry( )

Devuelve la primera entrada, eliminando ésta en el proceso. Debido a que el mapa está ordenado, es la entrada con el valor de clave inferior. Se devuelve null si el mapa está vacío.

Map.Entry pollLastEntry( )

Devuelve la última entrada, eliminando ésta en el proceso. Debido a que el mapa está ordenado, es la entrada con el valor de clave mayor. Se devuelve null si el mapa está vacío.

NavigableMap subMap(C limiteInferior, boolean inclBajo, C limiteSuperior, boolean inclAlto)

Devuelve un NavigableMap que incluye todas las entradas del mapa que invoca y que tiene claves mayores que limiteInferior y menores que limiteSuperior. Si inclBaja es verdadero, entonces se incluye un elemento igual a limiteInferior. Si inclAlto es verdadero, entonces se incluye un elemento igual a limiteSuperior. El mapa resultante está respaldado por el mapa que invoca.

NavigableMap tailMap(C limiteInferior, boolean incl)

Devuelve un NavigableMap que incluye todas las entradas del mapa que invoca y que tiene claves mayores que limiteInferior. Si incl es verdadero, entonces se incluye un elemento igual a limiteInferior. El mapa resultante está respaldado por el mapa que invoca.

Tabla 5-10 Los métodos definidos por NavigableMap (continuación)

La interfaz Map.Entry La interfaz Map.Entry le permite trabajar con una entrada de mapa. El método entrySet( ) declarado por la interfaz Map da como resultado un Set que contiene las entradas del mapa. Cada uno de estos elementos del conjunto es un objeto de Map.Entry, que es genérico y se declara así: interface Map.Entry

Capítulo 5:


183

Método

Descripción


Devuelve verdadero si obj es un Map.Entry con clave y valor iguales a las del objeto que invoca.

C getKey( )

Devuelve la clave para esta entrada del mapa.

V getValue( )

Devuelve el valor para esta entrada del mapa.

int hashCode( )

Devuelve el código de hash para esta entrada del mapa.

V setValue(V v)

Establece el valor de esta entrada del mapa en v. Se lanza una ClassCastException si v no es el tipo correcto del mapa. Se lanza una IllegalArgumentException si hay un problema con v. Se lanza una NullPointerException si v es null y el mapa no permite claves null. Se lanza una UnedOperationException si no puede cambiarse el mapa.

Tabla 5-11 Los métodos definidos por Map.Entry

Aquí, C especifica el tipo de claves y V el tipo de valores. En la tabla 5-11 se resumen los métodos declarados por Map.Entry.

Las clases de Map Varias clases proporcionan implementaciones de las interfaces de mapa. Aquí se muestran las definidas en java.util. Clase

Descripción

AbstractMap

Implementa la mayor parte de la interfaz de Map. Es una superclase de todas las implementaciones de mapa concretas.

EnumMap

Extiende AbstractMap para usar con claves de enum.

HashMap

Extiende AbstractMap para usar una tabla de hash.

TreeMap

Extiende AbstractMap para usar un árbol. También implementa NavigableMap.

WeakHashMap

Extiende AbstractMap para usar una tabla de hash con claves débiles, las cuales permiten que un elemento en un mapa sea recolectado con la basura cuando su clave no se usa de otra manera.

LinkedHashMap

Extiende HashMap para permitir las iteraciones de inserción de orden.

IdentityHashMap

Extiende AbstractMap y usa igualdad de referencia cuando se comparan entradas. Esta clase no es para uso general.

WeakHashMap e IdentityHashMap son mapas de uso especial y no se analizarán más aquí. Las otras clases de mapas se describirán en las siguientes secciones.

184


La clase HashMap HashMap usa una tabla de hash para almacenar el mapa. Extiende AbstractMap e implementa la interfaz Map. HashMap es una clase genérica que tiene esta declaración: class HashMap Aquí, C especifica el tipo de claves y V el de valores. Se definen los siguientes constructores: HashMap( ) HashMap(Map m) HashMap(int capacidad) HashMap(int capacidad, float relRelleno) La primera forma construye un mapa de hash predeterminado. La segunda, inicializa el mapa de hash al usar los elementos de m. la tercera, inicializa la capacidad del mapa de hash en capacidad. La cuarta forma inicializa la capacidad y la relación de relleno del mapa de hash al usar sus argumentos. El significado de capacidad y relación de relleno es el mismo que para HashSet, descrito antes. Debido a que HashMap usa una tabla de hash, sus elementos no están en ningún orden particular. Por tanto, el orden en que se agregan los elementos a un mapa de hash no es necesariamente el orden en que los lee el iterador, ni están ordenados.

La clase TreeMap TreeMap usa un árbol para contener un mapa. Un TreeMap proporciona un medio eficiente de almacenar pares clave/valor en orden y permite una rápida recuperación. TreeMap extiende AbstractMap e implementa la interfaz NavigableMap. Es una clase genérica que tiene esta declaración: class TreeMap Aquí, C especifica el tipo de claves y V el de valores. Están definidos los siguientes constructores de TreeMap: TreeMap( ) TreeMap(Comparator comp) TreeMap(Map m) TreeMap(SortedMap sm) La primera forma construye un mapa de árbol vacío que se ordenará al usar el orden natural de sus claves. La segunda forma construye un mapa basado en árbol vacío que se ordenará al usar el Comparator comp. La tercera forma inicializa un mapa de árbol con las entradas desde m, que se ordenará al usar el orden natural de las claves. La cuarta forma inicializa un mapa de árbol con las entradas de sm, que se ordenará en el mismo orden que sm.

La clase LinkedHashMap LinkedHashMap mantiene una lista vinculada de las entradas en el mapa, en el oren en que se insertaron. Esto permite la iteración en el orden de inserción en el mapa. Es decir, cuando se itera a través de una vista de colección de un LinkedHashMap, los elementos se devolverán en el orden

Capítulo 5:


185

en que se insertaron. También puede crear un LinkedHashMap que devuelve sus elementos en el orden en que se accedieron por última vez. LinkedHashMap extiende HashMap. Es una clase genérica que tiene esta declaración: Class LinkedHashMap>C, V> Aquí C especifica los tipos de clave y V los de valores. LinkedHashMap define los siguientes constructores: LinkedHashMap( ) LinkedHashMap(Map m) LinkedHashMap(int capacidad) LinkedHashMap(int capacidad, float relRelleno) LinkedHashMap(int capacidad, float relRelleno, boolean Orden) La primera forma construye en forma predeterminada una LinkedHashMap. La segunda, inicializa la LinkedHashMap con los elementos de m. La tercera inicializa la capacidad y la relación de relleno. El significado de capacidad. La cuarta inicializa la capacidad y relación de relleno son los mismos que para HashMap. La última forma le permite especificar si los elementos se almacenarán en la lista vinculada en el orden de inserción o el orden del último . Si Orden es verdadero, entonces se usa el orden de . Si es falso, entonces se usa el de inserción.

La clase EnumMap EnumMap es específicamente para uso con claves de un tipo enum. Extiende AbstractMap e implementa Map. EnumMap es una clase genérica que tiene esta declaración: class EnumMap , V> Aquí, C especifica el tipo de clave y V el tipo de valor. Observe que C debe extender Enum , que impone el requisito de que las claves deben ser de un tipo enum. EnumMap define los siguientes constructores: EnumMap(Class tipoC) EnumMap(Map m) EnumMap(EnumMap em) El primer constructor crea una EnumMap vacía de tipo tipoC. El segundo crea un mapa EnumMap que contiene las mismas entradas que m. El tercero crea una EnumMap inicializada con los valores en em.

Algoritmos La estructura de colecciones proporciona muchos algoritmos que operan en colecciones y mapas. Estos algoritmos se declaran como métodos estáticos dentro de la clase Collections. Su descripción está fuera del alcance de este libro. Sin embargo, se usan varios en las soluciones y se describen en las soluciones en que se usan.

186


Técnicas básicas de colecciones Componentes clave Clases e interfaces

Métodos

java.util.Collection<E>

boolean add(E obj) boolean addAll(Collection col) void clear( ) boolean contains(Object obj) boolean containsAll(Collection col) boolean isEmpty( ) boolean remove (Object obj) boolean removeAll(Collection col) boolean retainAll(Collection col) int size( ) T[ ] toArray (T matriz[ ])

java.util.ArrayList>E>

Debido a que todas las clases de colecciones implementan la interfaz Collection, todas las colecciones comparten una funcionalidad común. Por ejemplo, todas las colecciones le permiten agregar elementos a la colección, determinar si el objeto es parte de la colección, u obtener el tamaño de la colección. En esta solución se demuestra esta funcionalidad común al mostrar cómo • Crear una colección. • Agregar elementos a una colección. • Determinar el tamaño de una colección. • Determinar si una colección contiene un elemento específico. • Recorrer en bucle una colección con un estilo for-each del bucle for. • Eliminar elementos. • Determinar si una colección está vacía. • Crear una matriz que contiene la colección. En esta solución se usa la colección ArrayList, pero sólo se usan los métodos definidos por Collection, de modo que algunos principios generales pueden aplicarse a cualquier clase de colección. NOTA Los iteradores también tienen soporte en todas las colecciones, pero se describen por separado. Consulte Itere en una colección.

Capítulo 5:


187

Paso a paso Para crear y usar una colección se requieren estos pasos: 1. Cree una instancia de la colección deseada. En esta solución, se usa ArrayList, pero podría seleccionarse cualquier otra colección (excepto por EnumSet, que está específicamente diseñada para usar con los tipos enum). 2. Realice varias operaciones en la colección al usar los métodos definidos por Collection, como se describe en los siguientes pasos. 3. Agregue elementos a la colección al llamar a add( ) o addAll( ). 4. Obtenga el número de elementos en la colección al llamar a size( ). 5. Determine si una colección contiene uno o más elementos específicos al llamar a contains( ) o containsAll( ). 6. Determine si la colección está vacía (es decir, no contiene elementos) al llamar a isEmpty( ). 7. Elimine elementos de la colección al llamar a remove( ), removeAll( ) o reatainAll( ). 8. Elimine todos los elementos de una colección al llamar a clear( ). 9. Itere en los elementos de la colección al usar el estilo for-each del bucle for. 10. Obtenga una matriz que contiene los elementos de la colección al llamar a toArray( ).

Análisis Los métodos definidos por Collection se mostraron en la tabla 5-1, que se encuentra en Revisión general de las colecciones, al principio de este capítulo. He aquí una breve descripción de su operación. Los objetos se agregan a una colección al llamar a add( ). Observe que add( ) toma un argumento de tipo E, lo que significa que los objetos agregados a una colección deben ser compatibles con el tipo de datos esperados por la colección. Puede agregar todo el contenido de una colección a otra al llamar addAll( ). Por supuesto, ambos deben contener elementos compatibles. Puede eliminar un objeto al usar remove( ). Para eliminar un grupo de objetos, llame a removeAll( ). Puede eliminar todos los elementos, excepto los de un grupo especificado al llamar a retainAll( ). Para vaciar una colección, llame a clear( ). Puede determinar si una colección contiene un objeto específico al llamar a contains( ). Para determinar si una colección contiene todos los de otro, llame a containsAll( ). Puede determinar cuándo una colección está vacía al llamar a isEmpty( ). El número de elementos que se conservan en una colección se determina al llamar a size( ). El método toArray( ) devuelve una matriz que contiene los elementos de la colección que invoca. Hay dos versiones de toArray( ). La primera devuelve una matriz de Object. La segunda devuelve una matriz de elementos que contiene el mismo tipo que la matriz especificada como parámetro. Por lo general, la segunda forma es más conveniente porque devuelve el tipo de matriz deseado, y ésta es la versión usada en esta solución. El método toArray( ) es útil porque proporciona una ruta entre colecciones y matrices. Esto le permite procesar una colección empleando la sintaxis de matriz estándar. En el ejemplo que sigue se usa ArrayList para que contenga la colección. En Revisión general de las colecciones, que se presentó cerca del principio de este capítulo, se describen sus constructores. El usado por la solución es su constructor predeterminado, que crea una colección vacía.

188


Ejemplo Con el siguiente ejemplo se demuestran las técnicas básicas de colecciones recién descritas. // Demuestra técnicas de colecciones básicas. import java.util.*; class BasesColecciones { public static void main(String args[ ]) { // Crea una colección. ArrayList col = new ArrayList ( ); // Muestra el tamaño inicial. System.out.println("Tama\u00a4o inicial: " + col.size( )); // Almacena algunos objetos en la colección. for(int i=0; i<10; i++) col.add(i + 10); // Muestra adiciones después del tamaño. System.out.println("Tama\u00a4o tras las adiciones: " + col.size( )); // Usa un bucle for-each para mostrar la colección. System.out.println("Contenido de col: "); for(int x : col) System.out.print(x + " "); System.out.println("\n"); // Ve si la colección contiene un valor. if(col.contains(12)) System.out.println("col contiene el valor 12"); if(col.contains(−9)) System.out.println("col contiene el valor −9"); System.out.println( ); // Crea otra colección y luego la agrega a la primera. ArrayList col2 = new ArrayList ( ); col2.add(100); col2.add(200); col2.add(8); col2.add(−10); // Muestra col2. System.out.println("Contenido de col2: "); for(int x : col2) System.out.print(x + " "); System.out.println("\n");

Capítulo 5:


// Agrega col2 a col. col.addAll(col2); // Muestra la colección resultante. System.out.println("Contenido de col tras agregar col2: "); for(int x : col) System.out.print(x + " "); System.out.println("\n"); // Usa containsAll( ) para confirmar que col ahora contiene // todo col2. if(col.containsAll(col2)) System.out.println("col contiene todo lo de col2."); System.out.println( ); // Ahora elimina objetos de la colección. col.remove((Integer)10); col.remove((Integer)200); // Muestra la colección resultante. System.out.println("Contenido de col tras eliminar elementos: "); for(int x : col) System.out.print(x + " "); System.out.println("\n"); // Ahora elimina toda la colección col2. col.removeAll(col2); // Muestra la colección resultante. System.out.println("Contenido de col tras eliminar col2: "); for(int x : col) System.out.print(x + " "); System.out.println("\n"); // Agrega col2 a col una vez más, y llama a retainAll( ). col.addAll(col2); // agrega col2 a col // Elimina todos los elementos excepto los de col2. col.retainAll(col2); // Muestra la colección resultante. System.out.println("Contenido de col tras retener col2: "); for(int x : col) System.out.print(x + " "); System.out.println("\n"); // Obtiene una matriz de una colección. Integer[ ] matrizi = new Integer[col.size( )]; matrizi = col.toArray(matrizi);

189

190

Java: Soluciones de programación // Despliega el contenido de la matriz. System.out.println("Contenido de matrizi: "); for(int i=0; i<matrizi.length; i++) System.out.print(matrizi[i] + " "); System.out.println("\n"); // Elimina todos los elementos de la colección. System.out.println("Eliminando todos los elementos de col."); col.clear( ); if(col.isEmpty( )) System.out.println("col est\u00a0 vac\u00a1a."); }

}

Aquí se muestra la salida: Tamaño inicial: 0 Tamaño tras las adiciones: 10 Contenido de col: 10 11 12 13 14 15 16 17 18 19 col contiene el valor 12 Contenido de col2: 100 200 8 –10 Contenido de col tras agregar col2: 10 11 12 13 14 15 16 17 18 19 100 200 8 –10 col contiene todo lo de col2. Contenido de col tras eliminar elementos: 11 12 13 14 15 16 17 18 19 100 8 –10 Contenido de col tras eliminar col2: 11 12 13 14 15 16 17 18 19 Contenido de col tras retener col2: 100 200 8 –10 Contenido de matrizi: 100 200 8 –10 Eliminando todos los elementos de col. col está vacía.

Opciones Aunque ArrayList se usó para demostrar las técnicas de colecciones básicas, pudo usarse cualquiera de las clases de colecciones (excepto EnumSet, que es específicamente para tipos enum).

Capítulo 5:


191

Por ejemplo, trate de sustituir ArrayList con LinkedList en el ejemplo. El programa se compilará y ejecutará adecuadamente. La razón es, por supuesto, que todas las colecciones implementan la interfaz Collection, y sólo los métodos definidos por Collection se usan en el ejemplo. Más aún, debido a que todas las colecciones implementan Iterable, todas las colecciones pueden recorrerse en bucle usando la versión for-each de for, como se muestra en el ejemplo. Aunque un for-each de for suele ser el método más conveniente para recorrer en bucle los elementos de una colección, también puede emplearse un iterador. Esta técnica se describe en Itere en una colección.

Trabaje con listas Componentes clave Clases e interfaces

Métodos

java.io.FileInputStream

void add(int ind, E obj) E get(int ind) int indexOf(Object obj) int LastIndexOf(Object obj) E remove(int ind) E set(int ind, E obj)

java.util.ArrayList<E>

void ensureCapacity(int capacity)

java.util.LinkedList<E>

Tal vez las colecciones de uso más común sean las basadas en la interfaz List, que extiende Collection y define una colección de propósito general que almacena una secuencia. En casi todos los casos, una lista puede contener elementos duplicados. Una lista también permite que se acceda a los elementos por posición de índice. El paquete java.util define varias implementaciones concretas de List. Las primeras dos son ArrayList y LinkedList. ArrayList implementa las interfaces List y RandomAccess y agrega dos métodos propios. LinkedList implementa las interfaces List y Deque. List también es implementada por las clases heredades Vector y Stack, pero no se recomienda su uso en nuevo código. En esta solución se demuestran las listas. En ella se usan tanto ArrayList como LinkedList.

Paso a paso El uso de una lista incluye los pasos siguientes: 1. Cree una implementación concreta de List. En el caso de operaciones parecidas a matrices, use ArrayList. Para una implementación de propósito general, use LinkedList.

192

Java: Soluciones de programación 2. Agregue elementos a la lista. Los elementos pueden agregarse al final o insertarse en un índice específico al llamar a add( ). 3. Los elementos de la lista pueden accederse mediante los métodos definidos por Collection y List. Por ejemplo, puede obtener el elemento en un índice específico al llamar a get( ) o establecer el valor de un elemento al llamar a set( ).

Análisis En la solución anterior se describieron las operaciones básicas de colecciones definidas por Collection (que son heredadas por List). La interfaz List también especifica varios métodos propios. Se muestran en la tabla 5-3, en la sección Revisión general de las colecciones. Aquí se muestran las usadas en esta solución: void add(int ind, E obj) E get(int ind) int indexOf(Object obj) int LastIndexOf(Object obj) E remove(int ind) E set(int ind, E obj) Esta versión de add( ) inserta obj en la colección en el índice especificado por ind. El método get( ) devuelve el elemento en ind. indexOF( ) devuelve el índice de la primera aparición de obj; lastIndexOf( ) devuelve el de la última aparición. Ambos devuelven –1 si el objeto no se encuentra en la lista. El método remove( ) elimina el elemento de ind y devuelve el elemento eliminado. Para establecer el elemento en un índice especificado, llame a set( ). El índice se pasa vía ind, y el nuevo objeto se pasa en obj. Devuelve el elemento anterior a ese índice. Cuando use una ArrayList, puede especificar una capacidad inicial al llamar a ensureCapacity( ), que se muestra aquí: void ensureCapacity(int cap) La capacidad es el número de elementos que pede contener una ArrayList antes de que necesite agrandarse. La capacidad se especifica con cap. En casos en que sabe que un cierto número mínimo de elementos se almacenará, puede establecer la capacidad inicial de antemano. Esto evita posteriores reasignaciones, que son costosas en tiempo. Con la excepción de ensureCapacity( ), y de trimToSize( ) descrito al final de esta solución, una LinkedList tiene las mismas opciones que una ArrayList. La diferencia es la implementación. Aunque una LinkedList permite el a un elemento mediante un índice (como se mostrará en el ejemplo), ese será menos eficiente que el de una ArrayList. Sin embargo, las inserciones y eliminación de una LinkedList son muy eficientes, porque los vínculos simplemente se reorganizan. No es necesario compactar ni expandir una matriz. En general, una LinkedList debe usarse para aplicaciones en que se necesitan listas arbitrariamente largas y en que se eliminarán o insertarán elementos con frecuencia. Una ArrayList debe usarse cuando se requiere una matriz dinámica.

Ejemplo En el siguiente ejemplo se demuestra List, empleando ArrayList y LinkedList: // Demuestra List. import java.util.*;

Capítulo 5:


class DemoList { public static void main(String args[ ]) { System.out.println("Creando una ArrayList llamada al."); ArrayList al = new ArrayList ( ); // Agrega elementos. al.add(‘A’); al.add(‘B’); al.add(‘D’); System.out.println("al en orden de \u00a1ndice: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n"); // Ahora, inserta un elemento en el índice 2. al.add(2, ‘C’); System.out.println("al tras agregar C: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n"); // Elimina B. al.remove(1); System.out.println("al tras eliminar B: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n"); // Establece el valor del último elemento. al.set(al.size( )–1, ‘X’); System.out.println("al tras establecer el \u00a3ltimo elemento: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n"); // Agrega otro C. al.add(‘C’); System.out.println("al tras agregar otro C: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n");

193

194

Java: Soluciones de programación System.out.println("El \u00a1ndice del primer C: " + al.indexOf(‘C’)); System.out.println("El \u00a1ndice del \u00a3ltimo C: " + al.lastIndexOf(‘C’)); System.out.println(""); // Limpia la lista. al.clear( ); // Asegura una capacidad de por lo menos 26. al.ensureCapacity(26); // Agrega de la letra a a la z. for(int i=0; i < 26; i++) al.add(i, (char) (‘a’ + i)); System.out.println("al tras limpiar, " + "asegurar capacidad,\n" + "y luego agregar de la a a la z: "); for(int i=0; i < al.size( ); i++) System.out.print(al.get(i) + " "); System.out.println("\n"); // Ahora se crea una lista vinculada desde al. System.out.println("Creando una LinkedList llamada ll."); LinkedList ll = new LinkedList (al); // LinkedList sostiene las mismas operaciones, excepto // ensureCapacity( ) y trimToSize( ), que ArrayList. // Por ejemplo, puede iterar en el contenido de // una LinkedList usando el método get( ): System.out.println("Contenido de ll:"); for(int i=0; i < ll.size( ); i++) System.out.print(ll.get(i) + " "); System.out.println( ); }

}

Aquí se muestra la salida: Creando una ArrayList llamada al. al en orden de índice: A B D al tras agregar C: A B C D al tras eliminar B: A C D

Capítulo 5:


195

al tras establecer el último elemento: A C X al tras agregar otro C: A C X C El índice del primer C: 1 El índice del último C: 3 al tras limpiar, asegurar capacidad, y luego agregar de la a a la z: a b c d e f g h i j k l m n o p q r s t u v w x y z Creando una LinkedList llamada ll. Contenido de ll: a b c d e f g h i j k l m n o p q r s t u v w x y z

Opciones En el ejemplo se usa indización explícita para iterar en el contenido de una lista. Sin embargo, todas las implementaciones de List pueden iterarse con el estilo for-each del bucle for, como se muestra en la solución anterior, o mediante un iterador. El uso de un iterador se describe en Itere en una colección. LinkedList implementa la interfaz Deque, que da a LinkedList a todos los métodos definidos por Deque. Consulte Cree una cola o una pila empleando Deque para conocer un ejemplo. ArrayList le permite reducir el tamaño de una colección al mínimo necesario para conservar el número de elementos actualmente almacenados. Esto se hace al llamar a trimToSize( ). Aquí se muestra: void trimToSize( )

Trabaje con conjuntos Componentes clave Clases e interfaces

Métodos

java.util.Set<E>

java.util.Set<E>

java.util.SortedSet<E>

E first( ) E last( )

java.util.NavigableSet<E>

E higher(E obj) E lower(E obj)

java.util.HashSet<E> java.util.TreeSet<E>

196


Como List, Set es una subinterfaz de Collection. La interfaz Set difiere de List de una manera muy importante: una implementación de Set no permite elementos duplicados. Set no agrega métodos a los heredados de Collection. Sin embargo, es necesario que add( ) devuelva falso si se hace un intento de agregar un elemento duplicado. La interfaz Set no requiere que la colección se mantenga en orden. Sin embargo, SortedSet, que extiende Set, sí lo requiere. Por tanto, si quiere un conjunto ordenado, entonces usará una colección que implemente la interfaz SortedSet. A partir de Java 6, NavigableSet también extiende Set. El paquete java.util define dos implementaciones concretas de Set: HashSet y LinkedHashSet. También proporciona TreeSet, que es una implementación concreta de SortedSet y NavigableSet. En esta solución se demuestran los conjuntos. Usa HashSet y TreeSet.

Paso a paso El uso de un conjunto incluye los pasos siguientes: 1. Cree una implementación concreta de Set. En el caso de operaciones básicas con conjuntos, use HashSet o LinkedHashSet. En el caso de un conjunto ordenado, al igual que uno navegable, use TreeSet. 2. Agregue elementos al conjunto. Recuerde que no se permiten duplicados. 3. Se tiene a todas las instancias de Set mediante los métodos definidos por Collection. Cuando se usa un TreeSet, también puede usar los métodos definidos por SortedSet y NavigableSet.

Análisis Las operaciones básicas con colecciones definidas por Collection (que son heredadas por Set) se describen en Técnicas básicas de colecciones. Cuando trabaje con un SortedSet (como un TreeSet), puede usar los métodos definidos por Set, pero también los proporcionados por SortedSet. Los usados en esta solución son first( ), que devuelve una referencia al primer elemento del conjunto, y last( ), que devuelve una al último. Aquí se muestran estos métodos: E first( ) E last( ) Cada uno obtiene el elemento indicado. NavigableSet, que es implementada por TreeSet, define varios métodos que le permiten buscar el conjunto de coincidencias más cercanas. En esta solución se usan ambos métodos. El primero es higher( ), que obtiene el primer elemento que es mayor a un valor especificado. El segundo es lower( ), que obtiene el primer elemento que es menor a un valor especificado. Aquí se muestran: E higher(E obj) E lower(E obj) Cada uno obtiene el elemento indicado. NOTA

NavigableSet Se agregó en Java 6. Por tanto, es necesario usar una versión moderna de Java.

Capítulo 5:


197

Ejemplo En el siguiente ejemplo se demuestran las colecciones basadas en Set, SortedSet y NavigableSet. Usa la conversión predeterminada proporcionada por toString( ) para convertir un conjunto en una cadena para darle salida. // Demuestra Set. import java.util.*; class DemoSet { public static void main(String args[ ]) { HashSet<String> hs = new HashSet<String>( ); // Agrega elementos. hs.add("uno"); hs.add("dos"); hs.add("tres"); // Despliega el conjunto usando la conversión predeterminada toString( ). System.out.println("He aqu\u00a1 el HashSet: " + hs); // Trata de agregar de nuevo tres. if(!hs.add("tres")) System.out.println("Intento de agregar un duplicado. " + "Set no se modifica: " + hs); // Ahora usa TreeSet, que implementa // SortedSet y NavigableSet. TreeSet ts = new TreeSet ( ); // Agrega elementos. ts.add(8); ts.add(19); ts.add(–2); ts.add(3); // Observe que este conjunto está ordenado. System.out.println("\nHe aqu\u00a1 el TreeSet: " + ts); // Usa first( ) y last( ) de SortedSet. System.out.println("El primer elemento en ts: " + ts.first( )); System.out.println("El \u00a3ltimo elemento en ts: " + ts.last( )); // Usa higher( ) y lower( ) de NavigableSet. System.out.println("Primer elemento > 15: " + ts.higher(15)); System.out.println("Primer elemento < 15: " + ts.lower(15)); } }

198


Aquí se muestra la salida: He aquí el HashSet: [tres, uno, dos] Intento de agregar un duplicado. Set no se modifica: [tres, uno, dos] He aquí el TreeSet: [–2, 3, 8, 19] El primer elemento en ts: –2 El último elemento en ts: 19 Primer elemento > 15: 19 Primer elemento < 15: 8

Observe cómo el contenido de los conjuntos se muestra usando sus conversiones predeterminadas toString( ). Cuando una colección se convierte en una cadena empleando toString( ), los elementos se muestran dentro de corchetes, y los elementos están separados por comas.

Ejemplo adicional Debido a que Set no permite elementos duplicados, puede usarse para definir las operaciones de conjunto básicas definidas por la teoría de los conjuntos. Se trata de: • Unión • Intersección • Diferencia • Diferencia simétrica • Es un subconjunto • Es un superconjunto El significado de cada operación se describe aquí. Para comprender mejor el análisis, suponemos los siguientes conjuntos: Conjunto1: A, B, C, D Conjunto2: C, D, E, F La unión de los dos conjuntos produce un conjunto que contiene todos los elementos de ambos conjuntos. Por ejemplo, la unión de Conjunto1 y Conjunto2 es A, B, C, D, E, F Observe que sólo se incluye un caso de C y de D porque no se permiten duplicados en un conjunto. La intersección de dos conjuntos produce uno nuevo que contiene sólo los elementos comunes para ambos. Por ejemplo, la intersección de Conjunto1 y Conjunto2 produce el siguiente conjunto: C, D Debido a que C y D son los únicos elementos que ambos conjuntos comparten, son los únicos elementos en la intersección. La diferencia entre los dos conjuntos produce un nuevo conjunto que contiene los elementos del primer conjunto que no aparecen en el segundo. Por ejemplo, Conjunto1 – Conjunto2 produce el siguiente conjunto: A, B

Capítulo 5:


199

Debido a que C y D son de Conjunto2, se restan del Conjunto1 y no son, por tanto, parte del conjunto resultante. La diferencia simétrica entre dos conjuntos está compuesta por los elementos que se encuentran en un conjunto o en otro, pero no en ambos. Por ejemplo, la diferencia simétrica de Conjunto1 y Conjunto2 es A, B, E, F C y D no son parte del resultado porque son de ambos conjuntos. Dados dos conjuntos ConjuntoX y ConjuntoY, el primero es un subconjunto del segundo sólo si todos sus elementos son también elementos del otro. ConjuntoX es un superconjunto de ConjuntoY sólo si todos los elementos de ConjuntoY también son elementos de ConjuntoX. En el siguiente programa se implementan las operaciones de conjuntos que se acaban de definir. // Este programa crea una clase llamada OpsCjt que define // métodos que realizan las siguientes operaciones de conjuntos: // // unión // intersección // diferencia // diferencia simétrica // es subconjunto // es superconjunto import java.util.*; // Una clase que da soporte a varias operaciones con conjuntos. class OpsCjt { // Unión public static Set union(Set cjtA, Set cjtB) { Set tmp = new TreeSet (cjtA); tmp.addAll(cjtB); return tmp; } // Intersección public static Set intersection(Set cjtA, Set cjtB) { Set tmp = new TreeSet ( ); for(T x : cjtA) if(cjtB.contains(x)) tmp.add(x); return tmp; } // Diferencia public static Set difference(Set cjtA, Set cjtB) { Set tmp = new TreeSet (cjtA); tmp.removeAll(cjtB); return tmp; } // Diferencia simétrica public static Set symDifference(Set cjtA, Set cjtB) {

200

Java: Soluciones de programación Set tmpA; Set tmpB; tmpA = union(cjtA, cjtB); tmpB = intersection(cjtA, cjtB); return difference(tmpA, tmpB); } // Devuelve verdadero si CjtA is es un subconjunto de CjtB public static boolean isSubset(Set cjtA, Set cjtB) { return cjtB.containsAll(cjtA); } // Devuelve verdadero si CjtA is es un superconjunto de CjtB public static boolean isSuperset(Set cjtA, Set cjtB) { return cjtA.containsAll(cjtB); }

} // Demuestra las operaciones de conjuntos. class DemoOpsCjt { public static void main(String args[ ]) { TreeSet cjt1 = new TreeSet ( ); TreeSet cjt2 = new TreeSet ( ); cjt1.add(‘A’); cjt1.add(‘B’); cjt1.add(‘C’); cjt1.add(‘D’); cjt2.add(‘C’); cjt2.add(‘D’); cjt2.add(‘E’); cjt2.add(‘F’); System.out.println("cjt1: " + cjt1); System.out.println("cjt2: " + cjt2); System.out.println( ); System.out.println("Uni\u00a2n: " + OpsCjt.union(cjt1, cjt2)); System.out.println("Intersecci\u00a2n: " + OpsCjt.intersection(cjt1, cjt2)); System.out.println("Diferencia (cjt1 – cjt2): " + OpsCjt.difference(cjt1, cjt2)); System.out.println("Diferencia simetrica: " + OpsCjt.symDifference(cjt1, cjt2)); System.out.println( ); // Ahora, demuestra isSubset( ) y isSuperset( ). TreeSet cjt3 = new TreeSet (cjt1);

Capítulo 5:


201

cjt3.remove(‘D’); System.out.println("cjt3: " + cjt3); System.out.println("\u00a8Es cjt1 un subconjunto de cjt2? " OpsCjt.isSubset(cjt1, cjt3)); System.out.println("\u00a8Es cjt1 un subconjunto de cjt2? " OpsCjt.isSuperset(cjt1, cjt3)); System.out.println("\u00a8Es cjt3 un subconjunto de cjt1? " OpsCjt.isSubset(cjt3, cjt1)); System.out.println("\u00a8Es cjt3 un superconjunto de cjt1? OpsCjt.isSuperset(cjt3, cjt1));

+ + + " +

} }

Aquí se muestra la salida: cjt1: [A, B, C, D] cjt2: [C, D, E, F] Unión: [A, B, C, D, E, F] Intersección: [C, D] Diferencia (cjt1 – cjt2): [A, B] Diferencia simetrica: [A, B, E, F] cjt3: [A, B, C] ¿Es cjt1 un subconjunto de cjt2? false ¿Es cjt1 un subconjunto de cjt2? true ¿Es cjt3 un subconjunto de cjt1? true ¿Es cjt3 un superconjunto de cjt1? false

Opciones Otra implementación de Set proporcionada por la estructura de colecciones es LinkedHashSet. Usa una tabla de hash para almacenar los elementos del conjunto, pero también mantiene una lista vinculada de los elementos en el orden en que se agregaron al conjunto. Un iterador para LinkedHashSet iterará en los elemento al seguir los vínculos. Esto significa que el iterador devolverá elementos en el orden de su inserción en el conjunto. Consulte Itere en una colección para conocer más detalles.

Use Comparable para almacenar objetos en una colección ordenada Componentes clave Clases e interfaces

Métodos

java.lang.Comparable

int compareTo(T obj2)

java.util.TreeSet>E>

202


En general, una colección puede almacenar cualquier tipo de objeto. Sin embargo, las colecciones ordenadas, como PriorityQueue o TreeSet, colocan una condición en esos objetos: deben implementar la interfaz Comparable. He aquí por qué: la interfaz Comparable define el método compareTo( ), que determina el "orden natural" de los objetos de la clase. Como se usa aquí, orden natural significa el orden que normalmente se esperaría. Por ejemplo, el orden natural de las cadenas es alfabético; en el caso de valores numéricos, es el orden numérico. (En otras palabras, la A antes de la B, el 1 antes del 2, etc.). Las colecciones ordenadas usan el orden natural definido por una clase para determinar el orden de los objetos. Por tanto, si quiere almacenar objetos en una colección ordenada, su clase debe implementar Comparable. En esta solución se muestra el procedimiento general. (El mismo método general también se aplica a mapas ordenados).

Paso a paso Para almacenar objetos de clases que se crean en una colección ordenada, se requieren los siguientes pasos: 1. Cree la clase cuyos objetos se almacenarán en la colección ordenada. La clase debe implementar la interfaz Comparable. 2. Implemente el método compareTo( ) especificado por la interfaz Comparable para definir el orden natural de la clase. 3. Si es necesario, sobrescriba equals( ) para que sea consistente con los resultados producidos por compareTo( ). 4. Construya una colección ordenada, especificando su clase como un argumento de tipo. 5. Agregue objetos de su clase a la colección. El método compareTo( ) determina el orden en que se almacenarán los elementos.

Análisis Si un objeto se almacenará en una colección o mapa ordenado, su clase debe implementar la interfaz Comparable, que define una manera estándar en que dos objetos de la misma clase habrán de compararse. Está implementada por muchas clases de API de Java, incluidas Byte, Character, Double, Float, Long, Short, String e Integer. Comparable es genérica y se declara así: interface Comparable Aquí, T representa el tipo de objeto que habrá de compararse. Comparable especifica sólo un método: compareTo( ). Compara dos objetos y devuelve el resultado. La salida de esta comparación determina el orden natural de las instancias de una clase. Aquí se muestra el método compareTo( ): int compareTo(T obj) Este método compara el objeto que invoca con obj. Se devuelve 0 si los valores son iguales. Se devuelve un valor negativo si el objeto que invoca tiene un valor menor. De otra manera, se devuelve un valor positivo. Por supuesto, usted determina la manera en que tiene lugar la comparación cuando implementa compareTo( ). Se lanzará una ClassCastException si los dos objetos no son compatibles. Hay una regla que normalmente debe seguirse cuando se implementa Comparable para una clase (en especial si los objetos de esa clase se almacenarán en SortedSet o SortedMap). La salida de compareTo( ) debe ser consistente con la de equals( ). En otras palabras, para cada

Capítulo 5:


203

caso en que equals( ) devuelva true, compareTo( ) debe devolver 0. Esto es importante porque SortedSet no permite elementos duplicados. Debido a que la implementación predeterminada de equals( ) proporcionada por Object usa igualdad de referencias, a menudo querrá sobreescribir equals( ) para que sus resultados sean consistentes con su implementación de compareTo( ).

Ejemplo En el siguiente ejemplo se muestra cómo puede usarse Comparable para definir el orden natural de un objeto de modo que pueda almacenarse en una colección ordenada. Usa un TreeSet para almacenar objetos de tipo Producto, que encapsula información de un producto, incluido su nombre e ID. El método compareTo( ) ordena instancias de Producto con base en el nombre. Por tanto, la colección se ordenará por el nombre del producto. // // // // // //

Demuestra Comparable con una colección ordenada. Si un objeto se almacenará en una colección o un mapa ordenado, su clase debe implementar la interfaz Comparable, que define el "orden natural" de la clase.

import java.util.*; // Esta clase encapsula el nombre y el número de ID // de un producto. Implementa Comparable de modo // que el orden natural esté determinado por el // nombre de los productos. class Producto implements Comparable { String nombreProd; int idProd; Producto(String cad, int id) { nombreProd = cad; idProd = id; } // Compara dos productos con base en sus nombres. public int compareTo(Producto p2) { return nombreProd.compareToIgnoreCase(p2.nombreProd); } // Sobreescribe equals( ) para que sea consistente con compareTo( ). public boolean equals(Object p2) { return nombreProd.compareToIgnoreCase(((Producto)p2).nombreProd)==0; } } // Demuestra la interfaz Comparable. class DemoComp { public static void main(String args[ ]) {

204

Java: Soluciones de programación // Crea un TreeSet que usa el orden natural. TreeSet listaProd = new TreeSet ( ); // Agrega algunos listaProd.add(new listaProd.add(new listaProd.add(new listaProd.add(new

productos a listaProd. Producto("Estante", 13546)); Producto("Teclado", 04762)); Producto("Escritorio", 12221)); Producto("Archivero", 44387));

// Despliega los productos, ordenados por nombre. System.out.println("Productos ordenados por nombre:\n"); for(Producto p : listaProd) System.out.printf("%–14s ID: %d\n", p.nombreProd, p.idProd); } }

Aquí se muestra la salida: Productos ordenados por nombre: Archivero Escritorio Estante Teclado

ID: ID: ID: ID:

44387 12221 13546 2546

Opciones La implementación de Comparable es la mejor manera de especificar el orden que se usará para los objetos de una clase, pero es una opción que resulta útil en algunos casos. Puede crear un comparador personalizado que determine la manera en que se comparan los objetos. Este comparador se pasa al constructor de la colección cuando se crea. Luego el comparador se usa para comparar dos objetos. En la siguiente solución encontrará un ejemplo. Su implementación de compareTo( ) no necesita ordenar elementos en orden ascendente. Al revertir la salida de la comparación, los elementos pueden organizarse en orden inverso. Por ejemplo, trate de cambiar el método compareTo( ) en el ejemplo, como se muestra aquí. Llama a compareToIgnoreCase( ) en p2 en lugar de hacerlo en el objeto que invoca. Por tanto, la salida de la comparación se invierte. // Invierte la salida de una comparación entre dos productos. public int compareTo(Producto p2) { return p2.nombreProd.compareToIgnoreCase(nombreProd);

Después de hacer este cambio, la colección se ordenará a la inversa. Por cierto, observe que la comparación inversa aún es consistente con la sobreescritura de equals( ). Sólo ha cambiado el orden. Cualquier objeto que esté usando como clave en un mapa ordenado (como TreeMap) también debe implementar Comparable. Use el mismo procedimiento básico que se acaba de describir.

Capítulo 5:


205

Use un Comparator con una colección Componentes clave Clases e interfaces

Métodos


int compare(T obj1, T obj2)

java.util.PriorityQueue<E>

boolean add(E obj) E poll( )

Como se explicó en la solución anterior, los objetos almacenados en una colección ordenada (como TreeSet o PriorityQueue) siguen el orden natural, como opción predeterminada. Este orden se determina por la salida del método compareTo( ) definida por la interfaz Comparable. Si quiere ordenar elementos de una manera distinta al orden natural del objeto, tiene dos opciones. En primer lugar, puede cambiar la implementación de compareTo( ). Sin embargo, al hacerlo se cambiará el orden natural de su clase, lo que afectará a todos los usos de su clase. Además, tal vez quiera cambiar el orden de las clases, para lo que no tiene al código fuente. Por estas razones, la segunda opción suele ser mejor. Puede crear un comparador que defina el orden deseado. Un comparador es un objeto que implementa la interfaz Comparator. El comparador puede pasarse a una colección ordenada cuando se crea la colección, y se usa para determinar el orden de los elementos dentro de la colección. En esta solución se muestra cómo crear y usar un comparador personalizado. En el proceso, se demuestra PriorityQueue.

Paso a paso Para usar un comparador personalizado que controle el orden de los objetos dentro de una colección se requieren estos pasos: 1. Cree una clase que implemente Comparator para el tipo de datos que se almacenará en la colección. 2. Codifique el método compare( ) para que ordene los datos de la manera deseada. Si es necesario, debe ser consistente con la salida de equals( ) cuando se usa en los mismos objetos. 3. Cree una colección ordenada (como TreeSet o PriorityQueue), especificando el comparador para el constructor. Esto hace que la colección use el comparador para ordenar los elementos de la colección, en lugar de utilizar el orden natural.

Análisis Comparator está empaquetada en java.util y es una interfaz genérica que tiene esta declaración: interface Comparator Aquí, T especifica el tipo de objeto que se está comparando.

206


La interfaz Comparator define dos métodos compare( ) y equals( ). El método compare( ), que se muestra aquí, compara el orden de dos elementos: int compare(T obj1, T obj2) Aquí, obj1 y obj2 son los objetos que se compararán. Este método devuelve cero si los objetos son iguales. Devuelve un valor positivo si obj1 es mayor que obj2. De otra manera, se devuelve un valor negativo. El método puede lanzar una ClassCastException si los tipos de los objetos no son compatibles para la comparación. Su implementación de compare( ) determina la manera en que se ordenan los objetos. Por ejemplo, para usar un orden inverso, puede crear un comparador que invierta la salida de una comparación. El método equals( ), que se muestra aquí, prueba si un objeto es igual al comparador que invoca: boolean equals(Object objct) Aquí, obj es el objeto cuya igualdad se probará. El método devuelve verdadero si obj y el objeto que invoca son objetos de Comparator y usan el mismo orden. De otra manera, devuelve falso. Por lo general es innecesario sobreescribir equals( ), y comparadores más simples no lo harán. (Nota: esta versión de equals( ) no compara dos objetos de tipo T. Compara dos comparadores.) Cuando crea un comparador para usarlo con SortedSet (o cualquier colección que requiera elementos únicos), la salida de compare( ) debe ser consistente con el resultado de equals( ), cuando se usa en los dos mismos objetos. En otras palabras, dada una clase X, entonces la implementación de X de equals( ) debe devolver el mismo resultado que compare( ) definido por Comparator<X> cuando dos objetos X son iguales. La razón para este requisito es que un SortedSet no puede contener elementos duplicados. Después de que ha creado un comparador, puede pasarlo al constructor de las colecciones ordenadas. En el ejemplo siguiente se usa una PriorityQueue. He aquí el constructor que se usa: PriorityQueue(int capacidad, Comparator comp) Aquí, capacidad especifica la capacidad inicial de la cola y comp especifica el comparador. Cuando se usa una PriorityQueue, agregará elementos a la cola usando add( ) u offer( ). Cualquiera de ellos insertará el elemento en el orden determinado por el orden natural de éste, o por el comparador especificado cuando se construyó PriorityQueue (que es el caso con esta solución). Para obtener elementos de una PriorityQueue en orden de prioridad, debe usar poll( ). (No puede usar un iterador para este fin, porque los elementos no se devolverán en orden de prioridad.) El método poll( ) se muestra a continuación: E poll( ) Elimina y devuelve el siguiente elemento de la cola en orden de prioridad. Devuelve null si la cola está vacía.

Ejemplo En el siguiente ejemplo se usa un comparador para crear una lista de mensajes ordenados por prioridad. Cada mensaje es un objeto de tipo Mensaje, que es una clase que encapsula una cadena y el código de prioridad. Los niveles de prioridad se especifican por una enum llamada NivelP, que define tres prioridades: Baja, Media y Alta. Mensaje implementa Comparable, que define el orden natural de los elementos. Es el orden definido por NivelP, que va de alta a baja. La clase

Capítulo 5:


207

ComparadorMsjInv crea un comparador para objetos de Mensaje que invierte el orden natural. Por tanto, cuando se usa ComparadorMsjInv, los mensajes se organizan de bajo a alto. Luego se crean dos PriorityQueue. La primera usa el orden natural de Mensaje para ordenar los mensajes. La segunda usa ComparadorMsjInv para el mismo fin. Como lo muestra la salida, el orden de los mensajes en la segunda cola es el inverso del de la primera. Un tema adicional es que, debido a que Mensaje está diseñado para usarse con PriorityQueue, no es necesario sobreescribir equals( ) para que sea consistente con compare( ) en Mensaje o compareTo( ) en ComparadorMsjInv. La implementación predeterminada proporcionada por Object es suficiente. En realidad, tratar de hacer equals( ) consistente con compare( ) o compareTo( ) sería incorrecto en este caso, porque las comparaciones están basadas en la prioridad de un mensaje, no en su contenido. NOTA PriorityQueue se agregó en Java 5. Por tanto, debe estar usando una versión moderna de Java para compilar y ejecutar el siguiente ejemplo. // Usa un Comparator para crear una PriorityQueue para mensajes. import java.util.*; // Esta clase encapsula un mensaje ordenado por prioridad. // Implementa Comparable, que define su "orden natural". class Mensaje implements Comparable<Mensaje> { String msj; // Esta enumeración define los niveles de prioridad. enum NivelP { Alta, Media, Baja } NivelP prioridad; Mensaje(String cad, NivelP pri) { msj = cad; prioridad = pri; } // Compara dos mensajes con base en sus prioridades. public int compareTo(Mensaje msj2) { return prioridad.compareTo(msj2.prioridad); } } // Un comparador inverso para Mensaje. class ComparadorMsjInv implements Comparator<Mensaje> { public int compare(Mensaje msj1, Mensaje msj2) { return msj2.prioridad.compareTo(msj1.prioridad); } }

208


// Demuestra Comparadores con PriorityQueue. class DemoCMsjPri { public static void main(String args[ ]) { Mensaje m; // Crea una cola de prioridad que usa el orden natural. PriorityQueue<Mensaje> pq = new PriorityQueue<Mensaje>(3); // Agrega algún mensaje a pq. pq.add(new Mensaje("Junta en las oficinas principales a las 3pm", Mensaje.NivelP.Baja)); pq.add(new Mensaje("Fuego en la bodega.", Mensaje.NivelP.Alta)); pq.add(new Mensaje("Informe vencido del martes", Mensaje.NivelP.Media)); // Despliega los mensajes en el orden natural de prioridad. System.out.println("Mensajes en orden natural de prioridad: "); while((m = pq.poll( )) != null) System.out.println(m.msj + " Prioridad: " + m.prioridad); System.out.println( ); // Ahora, crea una cola de prioridad que almacena // los mensajes en orden inverso. PriorityQueue<Mensaje> pqInv = new PriorityQueue<Mensaje>(3, new ComparadorMsjInv( )); // Agrega los mismos mensajes a pqInv. pqInv.add(new Mensaje("Junta en las oficinas principales a las 3pm", Mensaje.NivelP.Baja)); pqInv.add(new Mensaje("Fuego en la bodega.", Mensaje.NivelP.Alta)); pqInv.add(new Mensaje("Informe vencido del martes", Mensaje.NivelP.Media)); // Despliega los mensajes en el orden inverso de prioridad. System.out.println("Mensajes en orden inverso de prioridad: "); while((m = pqInv.poll( )) != null) System.out.println(m.msj + " Prioridad: " + m.prioridad); } }

Aquí se muestra la salida: Mensajes en orden natural de prioridad: Fuego en la bodega. Prioridad: Alta Informe vencido del martes Prioridad: Media Junta en las oficinas principales a las 3pm Prioridad: Baja

Capítulo 5:


209

Mensajes en orden inverso de prioridad: Junta en las oficinas principales a las 3pm Prioridad: Baja Informe vencido del martes Prioridad: Media Fuego en la bodega. Prioridad: Alta

Opciones Una de las principales ventajas de Comparator es que puede definir un comparador para una clase en que no tenga código fuente. Por ejemplo, puede almacenar cadenas en orden inverso al usar el siguiente comparador: // Un comparador inverso para String. class ComparadorMsjInv implements Comparator<String> { public int compare(String cad1, String cad2) { return cad2.compareTo(cad1); } }

Algo interesante es que este comparador también es consistente con equals( ), como se definió con String. Es una manera muy fácil de obtener un comparador inverso para un tipo de datos específico: llamar al algoritmo reverseOrder( ) definido por Collections. Devuelve un Comparator que realiza una comparación inversa. Aquí se muestra: static Comparator reverseOrder( ) Entre otras cosas, un comparador inverso puede usarse para ordenar una colección de manera descendente. El mismo procedimiento básico usado para crear un comparador para una colección también se aplica para usar una con un mapa ordenado, como TreeMap. Cuando se ordena un mapa, su orden se basa en sus claves.

Itere en una colección Componentes clave Interfaces

Métodos

java.util.Iterator<E>

boolean hasNext( ) E next( ) void remove( )

java.util.ListIterator<E>

boolean hasNext( ) boolean hasPrevious( ) E next( ) E previous( ) void remove( )

java.util.Collection<E>

Iterator<E> iterator( )

java.util.List<E>

ListIterator<E> listIterator( )

210


Una de las operaciones más comunes realizadas en una colección es iterar en sus elementos. Por ejemplo, tal vez quiera desplegar cada elemento o realizar alguna transformación en él. Una manera de recorrer en bucle los elementos de una colección consiste en emplear un iterador, que es un objeto que implementa la interfaz Iterator o ListIterator. Iterator le permite iterar en una colección, obteniendo o eliminando elementos. ListIterator extiende Iterator para permitir el recorrido bidireccional de una lista, además de la modificación de elementos. En esta solución se muestra el procedimiento general para usar ambos tipos de iteradores.

Paso a paso Para iterar en una colección empleando un iterador, siga estos pasos: 1. Obtenga un iterador para la colección al llamar al método iterator( ) de la colección. 2. Configure un bucle que hace una llamada a hasNext( ). 3. Dentro del bucle, obtenga cada elemento al llamar a next( ). 4. Haga que el bucle itere siempre y cuando hasNext( ) devuelve verdadero. En el caso de colecciones que implementan List, puede usar ListIterator para recorrer en bucle la lista. Para ello, siga estos pasos: 1. Obtenga un iterador para la colección al llamar al método listIterator( ) de la colección. 2. Dentro de un bucle, use hasNext( ) para determinar si la colección tiene un elemento posterior. Use hasPrevious( ) para determinar si la colección tiene un elemento anterior. 3. Dentro del bucle, obtenga el siguiente elemento al llamar next( ) u obtenga el elemento anterior al llamar a previous( ). 4. Detenga la iteración cuando no haya disponible un elemento siguiente o anterior.

Análisis Iterator y ListIterator son interfaces genéricas que se declaran como se muestra aquí: interface Iterator<E> interface ListIterator<E> Aquí, E especifica el tipo de objetos que se está iterando. La interfaz Iterator declara los siguientes métodos: Método

Descripción

boolean hasNext( )

Devuelve verdadero si hay más elementos. De otra manera, devuelve falso.

E next( )

Devuelve el siguiente elemento. Lanza NoSuchElementException si no hay un elemento siguiente.

void remove( )

Elimina el elemento actual. Lanza IllegalStateException si se hace un intento por llamar a remove( ) que no es antecedido por una llamada a next( ). Se lanza una UnedOperationException si la colección es inmutable.

Capítulo 5:


211

Los métodos definidos por Iterator permiten que una colección se recorra en bucle de manera estrictamente secuencial, de principio a fin. Un Iterator no puede recorrerse hacia atrás. ListIterator extiende Iterator y agrega varios métodos propios. Los usados por esta solución se muestran aquí. Método

Descripción

boolean hasPrevious( )

Devuelve verdadero si hay un elemento anterior. De otra manera, devuelve falso.

E previous( )

Devuelve el elemento anterior. Se lanza una NoSuchElementException si no hay un elemento previo.

Como puede ver, ListIterator agrega la capacidad de moverse hacia atrás. Por tanto, un ListIterator puede obtener el siguiente elemento de la colección, o el anterior. Antes de que pueda acceder a una colección a través de un iterador, debe obtener uno. Esto se hace al llamar al método iterator( ), que devuelve un iterador al inicio de la colección. Este método está especificado por la interfaz Iterable, que es heredado por Collection. Por tanto, todas las colecciones proporcionan el método iterator( ). Aquí se muestra: Iterator<E> iterator( ) Al usar el iterador devuelto por iterator( ), puede acceder a todos los elementos de la colección, de principio a fin, de elemento en elemento. En el caso de colecciones que implementan List, también puede obtener un iterador al llamar a listIterator( ), que es especificado por List. Hay dos versiones de listIterator( ), que se muestran aquí: ListIterator<E> listIterator( ) ListIterator<E> listIterator(int ind) La primera versión devuelve un iterador de listas al principio de la lista. La segunda devuelve un iterador de listas que inician en el índice especificado. El índice pasado mediante ind debe estar dentro del rango de la lista. De otra manera, se lanza una IndexOutOfBoundsException. Como se explicó, un iterador de listas le da la capacidad de acceder a la colección en dirección hacia delante o hacia atrás y le permite modificar un elemento.

Ejemplo En el siguiente ejemplo se demuestran un iterador y un iterador de listas. Crea una lista telefónica simple que está almacenada en LinkedList. Despliega la lista en dirección hacia delante mediante un Iterator. Luego, despliega la lista en orden inverso, al usar ListIterator. // // // // //

Usa un Iterador para recorrer en bucle una colección en dirección hacia delante. Usa un ListIterator para recorrer en bucle una colección en dirección inversa.

import java.util.*;

212


// Esta clase encapsula un nombre y un número telefónico. class EntradaTelefono { String nombre; String numero; EntradaTelefono(String n, String num) { nombre = n; numero = num; } } // Demuestra Iterator y ListIterator. class DemoItr { public static void main(String args[ ]) { LinkedList<EntradaTelefono> agenda = new LinkedList<EntradaTelefono>( ); agenda.add(new EntradaTelefono("Ernesto", "555–3456")); agenda.add(new EntradaTelefono("Carlos", "555–3976")); agenda.add(new EntradaTelefono("Karen", "555–1010")); // Usa un Iterador para mostrar la lista. Iterator<EntradaTelefono> itr = agenda.iterator( ); EntradaTelefono et; System.out.println("Itera en la lista en " + "direcci\u00a2n hacia delante:"); while(itr.hasNext( )) { et = itr.next( ); System.out.println(et.nombre + ": " + et.numero); } System.out.println( ); // Usa un ListIterator para mostrar la lista en orden inverso. ListIterator<EntradaTelefono> litr = agenda.listIterator(agenda.size( )); System.out.println("Itera en la lista en " + "direcci\u00a2n inversa:"); while(litr.hasPrevious( )) { et = litr.previous( ); System.out.println(et.nombre + ": " + et.numero); } } }

Capítulo 5:


213

Aquí se muestra la salida:

Itera en la lista en dirección hacia delante: Ernesto: 555–3456 Carlos: 555–3976 Karen: 555–1010 Itera en la lista en dirección inversa: Karen: 555–1010 Carlos: 555–3976 Ernesto: 555–3456

Opciones El estilo for-each del bucle for ofrece una opción a un iterador en situaciones en que no modificará el contenido de una colección u obtendrá elementos en orden inverso. El for-each de for funciona con cualquier colección porque el for puede iterar en cualquier objeto que implemente la interfaz Iterable. Debido a que todas las clases de las columnas implementan esta interfaz, todas pueden ser iteradas por el for. Aunque en el ejemplo anterior se usó un Iterator para recorrer en bucle la lista de la agenda en dirección hacia delante, esto sólo se hizo para el ejemplo. Cuando se usa una LinkedList (o cualquier colección que implementa la interfaz List), puede usar un ListIterator para recorrer en bucle la colección en cualquier dirección. Por ejemplo, la parte del programa anterior que despliega la lista hacia delante puede reescribirse como se muestra aquí para que use ListIterator. // Usa un ListIterador para mostrar la lista en dirección // hacia delante. ListIterator<EntradaTelefono> itr = agenda.listIterator( ); EntradaTelefono et; System.out.println("Itera en la lista en " + "direcci\u00a2n hacia delante:"); while(itr.hasNext( )) { et = itr.next( ); System.out.println(et.nombre + ": " + et.numero); }

Este código es funcionalmente equivalente a la misma secuencia del ejemplo. La única diferencia es que se usa un ListIterator en lugar de un Iterator. ListIterator también especifica el método set( ), que puede usarse para cambiar el valor de un elemento obtenido al llamar a next( ) o previous( ). Aquí se muestra: void set(E obj) Aquí, obj reemplaza el último elemento iterado. El método set( ) permite actualizar el valor de una lista mientras se está iterando.

214


Cree una cola o una pila empleando Deque Componentes clave Clases e interfaces

Métodos

java.util.Collection

boolean isEmpty( )

java.util.Deque<E>

boolean add(E obj) E pop( ) void push(E obj) E remove( )

java.util.ArrayDeque<E>

A partir de Java 6, la estructura de colecciones ha proporcionado la interfaz Deque, que define las características de una cola de doble extremo. Hereda la interfaz Queue, que especifica los métodos para colas de un solo extremo (que son las colas en que los elementos se agregan o eliminan en un solo extremo). Deque agrega métodos a Queue que permiten que se añadan o eliminen elementos en cualquier extremo. Esto permite que implementaciones de Deque se usen como colas tipo primero en entrar primero en salir (FIFO, First-In First-Out) o pilas tipo último en entrar primero en salir (LIFO, Last-In First-Out). En esta solución se muestra este proceso. Deque se implementa con LinkedList y ArrayDeque. En esta solución se usa ArrayDeque para demostrar la creación de colas y pilas, pero el procedimiento general se aplica a cualquier implementación de Deque. NOTA Aunque Java aún proporciona java.util.Stack, es una clase heredada que se ha vuelto obsoleta con las implementaciones de Deque. Debe evitarse su uso en nuevo código. En cambio, debe usarse ArrayDeque o LinkedList cuando se necesite una pila.

Paso a paso He aquí una manera de implementar una cola tipo primero en entrar primero en salir basada en ArrayDeque: 1. Cree una ArrayDeque, especificando el tipo de objetos que se almacenará. 2. Agregue objetos al final de la cola al llamar a add( ). 3. Elimine objetos de la cabeza de la cola, al llamar a remove( ). 4. Puede determinar si la cola está vacía al llamar a isEmpty( ). Esto resulta útil cuando se eliminan objetos de la cola. He aquí una manera de implementar una pila tipo último en entrar primero en salir basada en ArrayDeque: 1. Cree una ArrayDeque, especificando el tipo de objetos que se almacenará. 2. Agregue objetos a la parte superior de la pila al llamar a push( ).

Capítulo 5:


215

3. Elimine objetos de la parte superior de la pila, al llamar a pop( ). 4. Puede determinar si la pila está vacía al llamar a isEmpty( ). Esto resulta útil cuando se eliminan objetos de la pila.

Análisis ArrayDeque es una implementación concreta de Deque que da soporte a una matriz dinámica. Por tanto, crece a medida que se agregan elementos. Da soporte a tres constructores. Aquí se muestra el usado en las soluciones: ArrayDeque( ) Crea una ArrayDeque con una capacidad inicial de 16. Por supuesto, esta colección crecerá a medida que se agreguen elementos. En Revisión general de las colecciones, que se presenta casi al principio del capítulo, se encuentra una descripción de otros constructores de ArrayDeque. Con el uso de Deque, hay varias maneras en que se puede implementar una cola. El método usado en la solución depende de add( ) y remove( ). Aquí se muestran: boolean add(E obj) E remove( ) El método add( ) agrega obj al final de la cola. Devuelve verdadero si se ha agregado el elemento y falso si no puede agregarse, por alguna razón. Lanzará una IllegalStateException si se hace un intento de agregar un elemento a una cola llena, de capacidad restringida. (ArrayDeque crea una matriz dinámica que no tiene capacidad restringida). El método remove( ) devuelve el elemento que se encuentra a la cabeza de la cola. También elimina ese elemento. Lanza NoSuchElementException si la cola está vacía. También hay varias maneras de implementar una pila empleando Deque. El método usado por esta solución emplea push( ) y pop( ). Aquí se muestran: void push(E obj) E pop( ) El método push( ) agrega un elemento a la parte superior de la pila. Lanzará una IllegalStateException si se hace un intento de agregar un elemento a una pila llena, de capacidad restringida. El método pop( ) elimina y devuelve el elemento que se encuentra en la parte superior de la pila. Lanzará una NoSuchElementException si la pila está vacía. Una manera fácil de evitar que se genere una NoSuchElementException cuando se eliminan objetos de una pila o una cola es llamar al método isEmpty( ). Este método está especificado por Collection y, por tanto, está disponible para todas las colecciones. NOTA Las implementaciones de capacidad restringida de Deque están permitidas. En una Deque de capacidad restringida, los métodos add( ) y push( ) lanzarán una IllegalStateException si la colección está llena. Ninguna de las dos implementaciones de Deque proporcionadas por java.util, ArrayDeque o LinkedList, tienen capacidad restringida.

216


Ejemplo En el siguiente ejemplo se muestra la manera de implementar una pila y una cola al usar Deque. Usa la colección ArrayDeque, pero el programa también funcionará si la sustituye con una LinkedList, porque ambas implementan la interfaz Deque. // Crea una pila y una cola usando ArrayDeque. import java.util.*; class DemoPiCo { public static void main(String args[ ]) { // Crea dos ArrayDeques. Una para la pila // y otra para la cola. ArrayDeque<String> pila = new ArrayDeque<String>( ); ArrayDeque<String> cola = new ArrayDeque<String>( ); // Demuestra la pila. System.out.println("Empujando pila.push("A"); System.out.println("Empujando pila.push("B"); System.out.println("Empujando pila.push("C"); System.out.println("Empujando pila.push("D");

A"); B"); C"); D");

System.out.print("Sacando de la pila: "); while(!pila.isEmpty( )) System.out.print(pila.pop( ) + " "); System.out.println("\n"); // Demuestra la cola. System.out.println("Agregando cola.add("A"); System.out.println("Agregando cola.add("B"); System.out.println("Agregando cola.add("C"); System.out.println("Agregando cola.add("D");

A"); B"); C"); D");

System.out.print("Consumiendo la cola: "); while(!cola.isEmpty( )) System.out.print(cola.remove( ) + " "); System.out.println( ); } }

Capítulo 5:


217

Aquí se muestra la salida: Empujando A Empujando B Empujando C Empujando D Sacando de la pila: D C B A Agregando A Agregando B Agregando C Agregando D Consumiendo la cola: A B C D

Opciones Como se mencionó, hay muchas maneras de implementar una pila o una cola empleando Deque. Una opción utiliza un segundo conjunto de métodos que agregan o eliminan elementos de una cola o pila. A diferencia de add( ) y push( ), que lanzarán una excepción cuando no pueda agregarse un elemento a una Deque de capacidad restringida, o remove( ) y pop( ), que lanzarán una excepción cuando se haga un intento de obtener un elemento de una Deque vacía, los métodos alternos no lo hacen. En cambio, devuelven valores que indican su éxito o falla. Aquí se muestran los métodos alternos para el comportamiento parecido al de una cola. boolean offerLast(E obj)

Agrega obj al final de la cola. Devuelve verdadero si se tiene éxito y falso de otra manera.

E poll( )

Devuelve el siguiente elemento de la cola o null si la cola está vacía.

Los métodos alternos para un comportamiento parecido al de una pila son: boolean offerFirst(E obj)

Agrega obj a la cabeza de la pila. Devuelve verdadero si se tiene éxito y falso de otra manera.

E poll( )

Devuelve el siguiente elemento de la cola o null si la cola está vacía.

Tome en cuenta que poll( ) puede usarse con pilas y colas porque ambas eliminan el siguiente elemento de la cabeza de la cola. La diferencia entre una pila y una cola es el lugar en que se agrega el elemento. Por ejemplo, he aquí otra manera de escribir la parte del ejemplo que pone elementos en la pila y luego los elimina. System.out.println("Empujando A"); pila.offerFirst("A"); System.out.println("Empujando B"); pila.offerFirst("B");

218


System.out.println("Empujando C"); pila.offerFirst("C"); System.out.println("Empujando D"); pila.offerFirst("D"); System.out.print("Sacando de la pila: "); String tmp; while((tmp = pila.poll( )) != null) System.out.print(tmp + " ");

Observe el bucle que extrae elementos de la pila. Debido a que poll( ) devuelve null cuando no hay más elementos, su valor devuelto puede usarse para controlar el bucle while. (Personalmente, prefiero usar push( ) y pop( ) porque son nombres tradicionales para operaciones de pila y usan isEmpty( ) para evitar que la pila se quede vacía. Por supuesto, algunas situaciones obtendrán beneficios de poll( ), porque no lanza una excepción cuando la pila está vacía). Otra manera de evitar la generación de una NoSuchElementException cuando se llama a remove( ) o pop( ) consiste en usar peek( ). Aquí se muestra: E peek( ) Este método devuelve pero no elimina el elemento que se encuentra en la cabeza de la cola, que es el siguiente elemento que devolverá remove( ) o pop( ). (Recuerde que la diferencia entre una pila y una cola es el lugar en que se agrega el elemento, no en que se elimina). El método peek( ) devolverá null si la colección está vacía. Por tanto, puede usar peek( ) para determinar si la cola o la pila está vacía.

Invierta, gire y ordene al azar una List Componentes clave Clases e interfaces

Métodos

java.util.Collections

static void reverse(List col) static void rotate(List col, int n) static void shuffle(List col)

En esta solución se demuestra el uso de tres algoritmos relacionados, definidos por la clase Collections: reverse( ), rotate( ) y shuffle( ). Se relacionan entre sí porque cada uno cambia el orden de la colección a la que se aplica. El algoritmo reverse( ) invierte una lista, rotate( ) gira una lista (es decir, quita un elemento de un extremo de una lista y lo pone en el otro) y shuffle( ) dispone los elementos en un orden al azar. Sólo pueden aplicarse a colecciones que implementan la interfaz List.

Capítulo 5:


219

Paso a paso Para invertir, girar o desordenar una colección, siga estos pasos: 1. La colección que habrá de afectarse debe implementar la interfaz List. 2. Después de que se han almacenado los objetos en la lista, llame a Collections.reverse( ) para invertir la colección, Collections.rotate( ) para girar la colección, o Collections.shuffle( ) para ordenar al azar la colección.

Análisis Para invertir una lista, use el algoritmo reverse( ). Aquí se muestra: static void reverse(List col) Revierte la colección pasada a col. Para girar una lista, use el algoritmo rotate( ). Aquí se muestra: static void rotate(List col, int n) Gira la colección pasada a col, n lugares a la derecha. Para girar a la izquierda, use un valor negativo para n. Para ordenar al azar los elementos de una lista, use shuffle( ). Tiene dos formas. La usada aquí es static void shuffle(List col) Ordena al azar la colección pasada a col.

Ejemplo En el siguiente ejemplo se muestran los efectos de reverse( ), rotate( ) y shuffle( ). // Usa reverse( ), rotate( ) y shuffle( ). import java.util.*; class DemoIGO { public static void main(String args[ ]) { LinkedList ll = new LinkedList ( ); // Agrega de la A a la F a la lista. for(char n=’A’; n <= ‘F’; n++) ll.add(n); // Despliega la lista antes de ordenarla al azar. System.out.println("La lista original: "); for(Character x : ll) System.out.print(x + " "); System.out.println("\n");

220

Java: Soluciones de programación // Invierte la lista. Collections.reverse(ll); // Despliega la lista invertida. System.out.println("La lista invertida: "); for(Character x : ll) System.out.print(x + " "); System.out.println("\n"); // Gira la lista. Collections.rotate(ll, 2); // Despliega la lista girada. System.out.println("La lista tras girarla 2 " + "lugares a la derecha: "); for(Character x : ll) System.out.print(x + " "); System.out.println("\n"); // Ordena al azar la lista. Collections.shuffle(ll); // Despliega la lista ordenada al azar. System.out.println("La lista ordenada al azar:"); for(Character x : ll) System.out.print(x + " "); System.out.println("\n"); }

}

Aquí se muestra la salida: La lista original: A B C D E F La lista invertida: F E D C B A La lista tras girarla 2 lugares a la derecha: B A F E D C La lista ordenada al azar: F B A E D C

Opciones Hay una segunda forma de shuffle( ) que le permite especificar un generador de números aleatorios. Aquí se muestra esta versión: static void shuffle(List col, Random genAlea) Aquí, genAlea es el generador de números aleatorios que se usará para ordenar la lista. Debe ser una instancia de Random, que está definida en java.lang.

Capítulo 5:


221


Métodos


static int binarySearch(List> col, T val) static > void sort(List col)

java.util.List<E>

E get(int ind)

Casi ninguna de las colecciones proporcionadas por java.util almacena elementos en orden. La excepción es TreeSet, que mantiene un árbol ordenado. Sin embargo, al usar el algoritmo sort( ) proporcionado por Collections, puede ordenar cualquier colección que implemente la interfaz List. Una vez que haya ordenado la colección, puede realizar búsquedas muy rápidas en ella al llamar a binarySearch( ), que es otro algoritmo definido por Collections. En esta solución se muestra el procedimiento básico.

Paso a paso Para ordenar una colección, siga estos pasos: 1. La colección que se está ordenando debe implementar la interfaz List. Además, el tipo de objeto almacenado en la colección debe implementar la interfaz Comparable. 2. Después de que se han almacenado todos los objetos de la lista, llame a Collections.sort( ) para ordenar la colección. Para realizar una búsqueda rápida de una colección ordenada, siga estos pasos: 1. La colección en que se está buscando debe implementar la interfaz List y ordenarse como se describió. 2. Llame a Collections.binarySearch( ) para encontrar un elemento. 3. Utilizando el índice devuelto por binarySearch( ), puede obtener el elemento al llamar a get( ), que se especifica por List.

Análisis Para ordenar una lista, use el algoritmo sort( ) definido por Collections. Tiene dos versiones. Aquí se muestra la usada por la solución. static > void sort(List col) Ordena la colección pasada a col. La colección debe implementar la interfaz List y sus elementos deben implementar la interfaz Comparable. Cuando este método regresa, col está ordenado. Resulta importante comprender que la colección sólo permanece ordenada hasta que se modifica de

222


alguna manera que afecte el orden. Por ejemplo, si se agrega un elemento al final de una colección ordenada, por lo general la colección se desordenará (a menos que el elemento sea en realidad el último elemento ordenado). Por tanto, ordenar una colección no significa que permanecerá ordenada. Una vez que se ha ordenado una lista, puede buscarse en ella al llamar a binarySearch( ), también definido por Collections. Tiene dos versiones. Aquí se muestra la usada en esta solución: static int binarySearch(List> col, T val) La lista que se buscará se pasa mediante col. El objeto que se buscará se pasa mediante val. El método devuelve el índice en que se encuentra la primera aparición del elemento, o un valor negativo si val no está en la lista. (El valor absoluto de un valor devuelto negativo es el índice en que debe insertarse el elemento en la lista para mantener ésta ordenada). Puede obtener el objeto en el índice devuelto por binarySearch( ) al llamar a get( ). Aquí se muestra: E get(int ind) Devuelve una referencia al elemento especificado.

Ejemplo En el siguiente ejemplo se muestra cómo ordenar una lista y luego buscar en la lista ordenada. // Ordena y busca en una LinkedList. import java.util.*; class DemoOrdenyBuscar { public static void main(String args[ ]) { LinkedList ll = new LinkedList ( ); // Agrega de la A a la Z a la lista. for(char n=’A’; n <= ‘Z’; n++) ll.add(n); // Ordena la lista al azar. Collections.shuffle(ll); // Despliega la lista ordenada al azar. System.out.println("La lista desordenada:"); for(Character x : ll) System.out.print(x + " "); System.out.println("\n"); // Ordena la lista. Collections.sort(ll);

Capítulo 5:


223

// Despliega la lista ordenada. System.out.println("La lista ordenada:"); for(Character x : ll) System.out.print(x + " "); System.out.println("\n"); // Busca un elemento. System.out.println("Buscando F."); int i = Collections.binarySearch(ll, ‘F’); if(i >= 0) { System.out.println("Se encontr\u00a2 en el \u00a1ndice " + i); System.out.println("El objeto es " + ll.get(i)); } } }

Aquí se muestra la salida: La lista desordenada: O B C Z X U J L V A D M G N H R W S Y K E F I Q T P La lista ordenada: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z Buscando F. Se encontró en el índice 5 El objeto es F

Opciones Como regla general, si su aplicación requiere una colección ordenada, la clase TreeSet es una mejor opción que ordenar una lista. A medida que se agregan elementos a un TreeSet, se insertan en orden automáticamente en el árbol. Por tanto, un TreeSet siempre contiene una colección ordenada. En contraste, después de que se ordena una lista, sólo permanecerá ordenada hasta que se agregue el siguiente elemento fuera del orden. Sin embargo, un TreeSet no permite elementos duplicados. Por tanto, en el caso de aplicaciones que requieren una colección ordenada que contiene duplicados, el uso de Collections.sort( ) es su mejor opción. Puede especificar un comparador cuando llama a sort( ) o binarySearch( ), que determinan la manera en que se comparan los elementos de la lista. Esto le permite ordenar o buscar de una manera diferente del orden natural. También le permite ordenar o buscar en listas que almacenan objetos que no implementan Comparable. Aquí se muestran estas versiones: static int binarySearch(List> col, T val, Comparator comp) static col, Comparator comp) Para conocer una descripción del uso de un comparador, consulte Use un Comparator con una colección.

224


Cree una colección comprobada Componentes clave Clases

Métodos


static <E> Collection<E> checkedCollection(Collection<E> col, Class<E> t)

Toda la estructura de colecciones se convirtió en elementos genéricos con el lanzamiento de Java 5. Por tanto, proporciona un medio de tipo seguro para almacenar y recuperar objetos. Sin embargo, es posible omitir esta seguridad de tipo de varias maneras. Por ejemplo, el código heredado que usa una colección declarada como de tipo simple (el que no especifica un argumento de tipo) puede agregar cualquier tipo de objeto a la colección. Si su código moderno y genérico debe hacer interfaz con ese tipo de código heredado, entonces es posible que un objeto no válido esté contenido en la colección porque el código heredado no lo evitará. Por desgracia, con el tiempo (tal vez mucho después de que se ha agregado el elemento no válido) su código operará en ese elemento no válido y esto causará una ClassCastException. Para evitar esta posibilidad, la clase Collections ofrece varios métodos que le permiten crear colecciones comprobadas. Estas colecciones crean lo que la documentación de la API de Java denomina "vista de tipo dinámicamente seguro" de una colección. Esta vista es una referencia a la colección que vigila la compatibilidad del tipo de las inserciones en tiempo de ejecución. Un intento por insertar un elemento no compatible causará una ClassCastException. Por tanto, el error ocurrirá de inmediato, en el momento de la inserción, y no después en el programa. Esto significa que se puede suponer en el resto de su programa que la colección no está corrompida. Para crear una colección comprobada, usará uno de los métodos checked…, proporcionados por Collections. En esta solución se usa checkedCollection( ), pero el mismo procedimiento básico se aplica a otros métodos de checked…

Paso a paso Para crear una colección comprobada, siga estos pasos: 1. Cree la colección en que quiera vigilar la inserción de elementos no válidos. 2. Cree una vista de tipo seguro de la colección al llamar a checkedCollection( ). 3. Realice todas las operaciones que agregan un elemento a la colección mediante la referencia de tipo seguro.

Análisis La clase Collections define cuatro métodos que devuelven vistas comprobadas de una colección. La usada en esta solución es checkedCollection( ), que se muestra a continuación: static <E> Collection<E> checkedCollection(Collection<E> col, Class<E> t)

Capítulo 5:


225

Para crear una colección comprobada, pase una referencia a la colección a col y especifique el tipo de elementos en t. Por ejemplo, si integer es el tipo de elementos almacenado en la colección, entonces pase a t la literal de clase Integer.class. El método devuelve una vista de tipo seguro en tiempo de ejecución de col. Cualquier intento por insertar un elemento incompatible en la colección comprobada causará una ClassCastException.

Ejemplo Con el siguiente ejemplo se demuestra cómo se evita con una colección comprobada que se agregue un elemento no válido a una colección. // // // // //

Crea y demuestra una colección comprobada. Nota: en este ejemplo se mezclan intencionalmente tipos genéricos y simples para demostrar el valor de las colecciones comprobadas. Normalmente, debe evitar el uso de tipos simples.

import java.util.*; class DemoComprobadas { public static void main(String args[ ]) { // Crea una LinkedList para cadenas. LinkedList<String> cadLl = new LinkedList<String>( ); // Crea una referencia comprobada a List y le asigna cadLl. Collection<String> colComp = Collections.checkedCollection(cadLl, String.class); // // // // //

Para ver la diferencia que hace una lista comprobada, convierta en comentario la línea anterior y quite la marca de comentario a la línea siguiente. Asigna cadLl a colComp sin envolverla primero en una colección comprobada. Collection<String> colComp = cadLl;

// Agregue algunas cadenas a la lista. colComp.add("Alfa"); colComp.add("Beta"); colComp.add("Gama"); System.out.println("He aqu\u00a1 la lista:"); for(String x : colComp) System.out.print(x + " "); System.out.println("\n"); // Para demostrar la lista comprobada, primero // se crea una referencia simple a List. Collection colSimp; // Luego, se asigna colComp, que es una referencia a List<string>, // a la referencia simple. colSimp = colComp;

226

Java: Soluciones de programación // Ahora, agrega un objeto de Integer a la lista. // Esto se compila porque una List simple puede contener // cualquier tipo de objeto (se omite la seguridad de tipo). // Sin embargo, en tiempo de ejecución se genera una // ClassCastException porque la lista está envuelta en // una lista comprobada. colSimp.add(new Integer(23)); // Despliega la lista. // Si colComp NO está envuelta en la lista comprobada, entonces // no se encontrará la falta de concordancia en el tipo hasta // que se ejecute este bucle. for(String x : colComp) System.out.print(x + " "); System.out.println("\n"); }

}

Aquí se muestra la salida del programa: He aquí la lista: Alfa Beta Gama Exception in thread "main" java.lang.ClassCastException: Attempt to insert class java.lang.Integer element into collection with element type class java.lang.String at java.util.Collections$CheckedCollection.typeCheck(Collections. java:2202) at java.util.Collections$CheckedCollection.add(Collections.java:2243) at DemoComprobadas.main(DemoComprobadas.java:50)

Observe que la excepción se encuentra cuando se hace el intento de insertar un objeto Integer en la lista, que está esperando objetos de tipo String. He aquí cómo funciona el programa. En primer lugar, se crea una LinkedList llamada cadLl que contiene objetos de String. Luego, el programa crea una colección comprobada, llamada colComp, agrega unas cuantas cadenas a la colección y las despliega. A continuación, se crea una referencia simple a Collection (es decir, sin tipo), llamada colSimp, y luego se le asigna colComp. Por tanto, después de este paso, colSimp hace referencia a la colección comprobada colComp. Este paso, en sí mismo, es completamente legal. A continuación, se hace un intento por agregar un Integer a colSimp. Por lo general esto también sería legal (aunque muy sospechoso) porque cualquier colección sin tipo (es decir, simple) puede contener cualquier tipo de objeto. Sin embargo, como colSimp hace referencia a una colección comprobada, esto causa que se lance una ClassCastException, evitando así que colComp contenga un elemento no válido. Si no se hubiera usado una colección comprobada, entonces el elemento no válido no habría causado una excepción hasta que se hiciera el intento de desplegar la lista después de que se ha insertado Integer. Para confirmar esto, convierta esta línea en un comentario: Collection<String> colComp = Collections.checkedCollection(cadLl, String.class);

A continuación, elimine la marca de comentario de la línea siguiente: //Collection<String> colComp = cadLl;

Capítulo 5:


227

Luego, vuelva a compilar y ejecutar el programa. La excepción ocurre cuando el último bucle for encuentra el elemento entero, que es después de que se agregó a la lista.

Opciones Además de checkedCollection( ), Collections proporciona otros varios métodos que devuelven vistas comprobadas, adecuadas para tipos específicos de colecciones. Aquí se muestran: static <E> List<E> checkedList(List<E> col, Class<E> t)

Devuelve una vista de tipo seguro en tiempo de ejecución de List.

static <E> List<E> checkedSet(Set<E> col, Class<E> t)

Devuelve una vista de tipo seguro en tiempo de ejecución de Set.

static <E> SortedSet<E> checkedSortedSet(SortedSet<E> col, Class<E> t)

Devuelve una vista de tipo seguro en tiempo de ejecución de SortedSet.

Para cada método, un intento por insertar un elemento incompatible causará una ClassCastException. Debe usar uno de estos métodos cuando necesite llamar a métodos que son específicos de List, Set o SortedSet. Collections también define los siguientes métodos que le permiten obtener vistas de tipo seguro de un mapa. static Map checkedMap(Map c, Class tipoC, Class tipoV)

Devuelve una vista de tipo seguro en tiempo de ejecución de Map

static SortedMap checkedSortedMap(SortedMap c, Class tipoC, Class tipoV)

Devuelve una vista de tipo seguro en tiempo de ejecución de SortedMap

Para ambos métodos, un intento de insertar una entrada incompatible causará una ClassCastException.

Cree una colección sincronizada Componentes clave Clases

Métodos


static Collection synchronizedCollection(Collection col)

228


Las clases de la colección proporcionadas por la estructura de colecciones no están sincronizadas. Si necesita una colección de subproceso seguro, entonces necesitará usar los métodos de synchronized…, definidos por Collections. Una colección sincronizada es necesaria en los casos en que un subproceso estará (o por lo menos podría estar) modificando una colección cuando otro subproceso también tiene a ella. En esta solución se muestra cómo crear una vista de colección sincronizada empleando synchronizedCollection( ), pero el mismo procedimiento se aplica a otros métodos de synchronized…

Paso a paso Para crear una vista sincronizada de una colección se requieren estos pasos: 1. Cree la colección que habrá de sincronizarse. 2. Obtenga una vista sincronizada de la colección al llamar al método synchronizedCollection( ). 3. Opere en la colección mediante la vista sincronizada.

Análisis Si varios subprocesos estarán usando una colección, entonces es necesario que cada subproceso opere en una vista sincronizada de esa colección. Si varios subprocesos tratan de usar una colección no sincronizada, entonces es posible que se lance una ConcurrentModificationException (además de otros errores). Esto puede suceder aunque sólo un subproceso lea, pero no modifique, la colección. Por ejemplo, si la colección está en el proceso de ser iterada por un subproceso y un segundo subproceso cambia la colección, entonces ocurrirá una ConcurrentModificationException. Para evitar este y otros errores asociados con colecciones no sincronizadas, debe obtener y usar exclusivamente una vista sincronizada de la colección. Para obtener una vista sincronizada (es decir, de subproceso seguro) de una colección, use uno de los cuatro métodos synchronized… definidos por la clase Collections. La versión usada por esta solución es synchronizedCollection( ). Aquí se muestra: static Collection synchronizedCollection(Collection col) Devuelve una vista de subproceso seguro de la colección pasada a col. Esta vista puede usarse de manera segura en un entorno de multiprocesamiento. Sin embargo, todo el (incluido el de sólo lectura) a la colección debe tener lugar a través de la referencia devuelta.

Ejemplo En el siguiente ejemplo se demuestra el uso de la colección sincronizada. // Crea y demuestra una colección sincronizada. import java.util.*; // Crea un segundo subproceso de ejecución que agrega // un elemento a la colección que se pasa. // Luego itera en la colección. class MiSubproceso implements Runnable { Thread t;

Capítulo 5:


Collection<String> col; MiSubproceso(Collection<String> c) { col = c; t = new Thread(this, "Segundo subproceso"); t.start( ); } public void run( ) { try { Thread.sleep(100); // deja que se ejecute el subproceso principal col.add("Omega"); // y otro elemento // Itera en los elementos. synchronized(col) { for(String cad : col) { System.out.println("Segundo subproceso: " + cad); // Deja que se ejecute el subproceso principal, si se puede. Thread.sleep(500); } } } catch(InterruptedException exc) { System.out.println("Segundo subproceso interrumpido."); } } } // Demuestra una colección sincronizada. class DemoSinc { public static void main(String args[ ]) { // Crea un TreeSet para cadenas. TreeSet<String> cadTs = new TreeSet<String>( ); // Crea una referencia sincronizada y la asigna a colSinc. Collection<String> colSinc = Collections.synchronizedCollection(cadTs); // // // // //

Para ver la diferencia que marca una colección sincronizada, convierta en comentario la línea anterior y quite la marca de comentario de la línea siguiente. Asigna cadTs a colSinc sin envolverla primero en una colección sincronizada. Collection<String> colSinc = cadTs;

// Agrega algunas cadenas al conjunto. colSinc.add("Gama"); colSinc.add("Beta"); colSinc.add("Alfa");

229

230

Java: Soluciones de programación // Inicia el segundo subproceso. new MiSubproceso(colSinc); try { synchronized(colSinc) { for(String cad : colSinc) { System.out.println("Subproceso principal: " + cad); // Deja que se ejecute el segundo subproceso, si se puede. Thread.sleep(500); } } } catch(InterruptedException exc) { System.out.println("Subproceso principal interrumpido."); } }

}

La salida producida por este programa se muestra a continuación: Subproceso principal: Alfa Subproceso principal: Beta Subproceso principal: Gama Segundo subproceso: Alfa Segundo subproceso: Beta Segundo subproceso: Gama Segundo subproceso: Omega

He aquí cómo funciona el programa. DemoSinc empieza por crear un TreeSet llamado cadTs. Este conjunto se envuelve después en una colección sincronizada llamada colSinc y se agregan tres elementos a ella. A continuación, main( ) empieza un segundo subproceso de ejecución, que es definido por MiSubproceso. Se pasa a este constructor una referencia a colSinc. Este subproceso empieza por quedar inactivo por un periodo corto, lo que permite que el subproceso principal reanude la ejecución, Luego MiSubproceso agrega otro elemento a la colección y empieza a iterar en ésta. Después de crear MiSubproceso, el subproceso principal empieza a iterar en el conjunto, demorando 500 milisegundos entre iteraciones. Esta demora permite que se ejecute el segundo subproceso, si se puede. Sin embargo, debido a que colSinc está sincronizada, el segundo subproceso no se puede ejecutar hasta que termine el primero. Por tanto, la iteración de los elementos en main( ) termina antes de que MiSubproceso agregue otro elemento al conjunto, evitando así una ConcurrentModificationException. Para probar la necesidad de usar una colección sincronizada cuando se usan varios subprocesos, haga este experimento. En el ejemplo, convierta en comentario estas líneas: Collection<String> colSinc = Collections.synchronizedCollection(cadTs);

Luego, elimine la marca de comentario de esta línea: //

Collection<String> colSinc = cadTs;

Ahora, vuelva a compilar y ejecutar el programa. Debido a que colSinc ya no está sincronizada, tanto el subproceso principal como MiSubproceso pueden acceder a él simultáneamente. Esto da como resultado una ConcurrentModificationException cuando MiSubproceso trata de agregar un elemento.

Capítulo 5:


231

Opciones Además de synchronizedCollection( ), Collections proporciona otros varios métodos que devuelven vistas sincronizadas para tipos específicos de colecciones. Aquí se muestran: static List synchronizedList(List col)

Devuelve una lista de subproceso seguro respaldada por col.

static Set synchronizedSet(Set col)

Devuelve un conjunto de subproceso seguro respaldado por col.

static SortedSet synchronizedSortedSet(SortedSet col)

Devuelve un conjunto ordenado de subproceso seguro respaldado por col.

Collections también proporciona los siguientes métodos que devuelven vistas sincronizadas de los mapas: static Map synchronizedMap(Map mapa)

Devuelve un mapa de subproceso seguro respaldado por mapa.

static SortedMap synchronizedSortedMap( SortedMap mapa)

Devuelve un mapa ordenado de subproceso seguro respaldado por mapa.

Cree una colección inmutable Componentes clave Clases

Métodos


static Collection unmodifiableCollection( Collection col)

Collections proporciona un conjunto de métodos que crean una vista inmutable de una colección. Estos métodos empiezan con el nombre unmodifiable. La colección no puede cambiarse a través de este tipo de vista. Esto resulta útil en los casos en que quiera asegurarse de que una colección no se modificará, como cuando se pasa a código de terceros.

Paso a paso Para crear una vista inmutable de una colección se requieren los pasos siguientes: 1. Cree una colección que será de sólo lectura. 2. Obtenga una vista inmutable de la colección al llamar al método unmodifiableCollection( ). 3. Opere en la colección a través de la vista de sólo lectura.

232


Análisis Para crear una vista inmutable de una colección, use uno de los métodos unmodifiable…, definidos por la clase Collections. Define cuatro métodos que devuelven vistas inmutables de una colección. La usada en esta solución es unmodifiableCollection( ). Aquí se muestra: static Collection unmodifiableCollection(Collection col) Devuelve una referencia a una vista de sólo lectura de la colección pasada a col. Esta referencia puede entonces pasarse a cualquier código que no tenga permitido modificar la colección. Cualquier intento de modificar la colección mediante esta referencia dará como resultado una UnedOperationException.

Ejemplo En el siguiente ejemplo se demuestra el uso de una colección inmutable. // Crea y demuestra una colección inmutable. import java.util.*; class DemoNoMod { public static void main(String args[ ]) { // Crea una ArrayList para cadenas. ArrayList lista = new ArrayList ( ); // Agrega un elemento. lista.add(‘X’); System.out.println("Elemento agregado a la lista: " + lista.get(0)); // Ahora, crea una vista inmutable de la lista. Collection colInmutable = Collections.unmodifiableCollection(lista); // Trata de agregar otro elemento. // Esto no funcionará y causará una excepción. colInmutable.add(‘Y’); } }

Aquí se muestra la salida. Tome nota de que se lanza una UnedOperationException cuando se hace un intento de modificar la colección. Elemento agregado a la lista: X Exception in thread "main" java.lang.UnedOperationException at java.util.Collections$UnmodifiableCollection.add(Collections.java:1018) at DemoNoMod.main(DemoNoMod.java:22)

Capítulo 5:


233

Opciones Además de unmodifiableCollection( ), Collections proporciona otros varios métodos que devuelven vistas inmutables adecuadas a tipos específicos de colecciones. Aquí se muestran: static List unmodifiableList(List col)

Devuelve una lista no modificable respaldada por col.

static Set unmodifiableSet(Set col)

Devuelve un conjunto no modificable respaldado por col.

static SortedSet unmodifiableSortedSet(SortedSet col)

Devuelve un conjunto ordenado no modificable respaldado por col.

Collections también proporciona los siguientes métodos que devuelven vistas inmutables de mapas: static Map unmodifiableMap( Map mapa)

Devuelve un mapa no modificable respaldado por mapa.

static SortedMap unmodifiableSortedMap( SortedMap mapa)

Devuelve un mapa ordenado no modificable respaldado por mapa.

Lea bytes de un archivo Componentes clave Clases e interfaces

Métodos

java.util.Map

void clear( ) boolean containsKey(Object c) boolean containsValue(Object v) Set<Map.Entry > entrySet( ) V get(Object c) boolean isEmpty( ) Set KeySet( ) V put(C c, V v) void putAll(Map m) V remove(Object c) Int size( ) Collection values( )

java.util.TreeMap

234


Como se explicó en la revisión general, los mapas no son, técnicamente hablando, colecciones, porque no implementan la interfaz Collection. Sin embargo, los mapas son parte de la estructura de colecciones. Los mapas almacenan pares clave/valor, y todas las claves deben ser únicas. Todos los mapas implementan la interfaz Map. Por tanto, todos los mapas comparten una funcionalidad común. Por ejemplo, todos los mapas le permiten agregar un par clave/valor a un mapa u obtener un valor, dada su clave. En esta solución se demuestra esta funcionalidad común al mostrar cómo • Agregar un par clave/valor a un mapa. • Obtener un valor dado a una clave. • Determinar el tamaño del mapa. • Obtener un conjunto de entrada de los elementos del mapa. • Recorrer en bucle las entradas de un mapa empleando un conjunto de entrada. • Obtener una colección de las claves y los valores en un mapa. • Eliminar un par clave/valor de un mapa. • Cambiar el valor asociado con una clave. • Determinar si un mapa está vacío. En esta solución se usa TreeMap, que es una implementación concreta de Map, pero sólo se usan los métodos definidos por Map. Por tanto, se pueden aplicar los mismos principios generales a cualquier mapa.

Paso a paso Para crear y usar un mapa se requieren estos pasos: 1. Cree una instancia del mapa deseado. En esta solución, se usa TreeMap, pero podría seleccionar cualquier otro mapa. 2. Realice varias operaciones en el mapa, al emplear los métodos definidos por Map como se describe en los pasos siguientes. 3. Agregue entradas al mapa al llamar a put( ) o putAll( ). 4. Obtenga el número de entradas en un mapa al llamar a size( ). 5. Determine si un mapa contiene una clave específica al llamar a containsKey( ). Determine si un mapa contiene un valor específico al llamar a containsValue( ). 6. Determine si un mapa está vacío (es decir, no contiene entradas) al llamar a isEmpty( ). 7. Obtenga un conjunto de entradas en el mapa al llamar a entrySet( ). 8. Use el conjunto de entradas obtenido de entrySet( ) para recorrer en bucle las entradas el mapa. 9. Obtenga un valor dada su clave al llamar a get( ). 10. Obtenga un conjunto de las claves del mapa al llamar a keySet( ). Obtenga un conjunto de valores al llamar a values( ). 11. Elimine entradas del mapa al llamar a remove( ). 12. Elimine todas las entradas del mapa al llamar a clear( ).

Capítulo 5:


235

Análisis Map es una interfaz genérica que se define como se muestra a continuación: interface Map Aquí C define el tipo de claves del mapa y V define el tipo de valores. Es permisible que C y V sean del mismo tipo. Los métodos definidos por Map se muestran en la tabla 5-8, que se encuentra en Revisión general de las colecciones, al principio de este capítulo. He aquí una breve descripción de su operación. Los objetos se agregan a un mapa al llamar a put( ). Observe que put( ) toma argumentos de tipo C y V. Esto significa que las entradas agregadas a un mapa deben ser compatibles con el tipo de datos esperado por el mapa. Puede agregar todo el contenido de un mapa a otro al llamar a putAll( ). Por supuesto, los dos mapas deben ser compatibles. Puede eliminar una entrada al usar remove( ). Para vaciar un mapa, llame a clear( ). Puede determinar si un mapa contiene una clave específica al llamar a containsKey( ). Para determinar si contiene un valor específico, llamaría a containsValue( ). Puede determinar cuando un mapa está vacío llamando a isEmpty( ). El número de elementos contenido realmente en un mapa se devuelve con size( ). Como se explicó en la revisión general, los mapas no implementan la interfaz Iterable y, por tanto, no apoyan iteradores. Sin embargo, aún puede recorrer en bucle el contenido de un mapa al obtener primero una vista de colección del mapa. Hay tres tipos de vistas de colección disponibles: • Un conjunto de entradas en el mapa • Un conjunto de claves en el mapa • Una colección de los valores del mapa Un conjunto de entradas en el mapa se obtiene al llamar a entrySet( ). Devuelve una colección Set que contiene las entradas. Cada entrada se conserva en un objeto de tipo Map.Entry. Dado un objeto de este tipo, puede obtener la clave al llamar a getKey( ). Para obtener el valor, llame a getValue( ). Empleando el conjunto de entradas, es fácil recorrer en bucle un mapa, obteniendo las entradas de una en una. Las otras dos vistas de colección le permiten tratar con las claves y los valores por separado. Para obtener un Set de las claves en el mapa, llame a keySet( ). Para obtener una Collection de los valores, llame a values( ). En el siguiente ejemplo se usa un TreeMap que contendrá el mapa. Consulte Revisión general de las colecciones presentada cerca del inicio del capítulo para conocer un análisis sobre los constructores.

Ejemplo En el siguiente ejemplo se demuestran las técnicas básicas usadas para crear y usar un mapa. Se crea un mapa llamado numsAtom, que vincula los nombres de elementos con sus números atómicos. Por ejemplo, el hidrógeno tiene el número atómico 1; el oxígeno tiene el 8, etcétera. // Demuestra las técnicas básicas de Map. import java.util.*; class MapasBasicos { public static void main(String args[ ]) {

236

Java: Soluciones de programación // Crea un mapa de árbol. TreeMap<String, Integer> numsAtom = new TreeMap<String, Integer>( ); // Pone las entradas en el mapa. // Cada entrada consta del nombre de un elemento // y su número atómico. Por tanto, la clave es el // nombre del elemento y el valor es su número atómico. numsAtom.put("Hidr\u00a2geno", 1); numsAtom.put("Ox\u00a1geno", 8); numsAtom.put("Hierro", 26); numsAtom.put("Cobre", 29); numsAtom.put("Plata", 47); numsAtom.put("Oro", 79); System.out.println("El mapa contiene estas " + numsAtom.size( ) + " entradas:"); // Obtiene un conjunto de las entradas. Set<Map.Entry<String, Integer>> set = numsAtom.entrySet( ); // Despliega las claves y los valores del mapa. for(Map.Entry<String, Integer> me : set) { System.out.print(me.getKey( ) + ", n\u00a3mero at\u00a2mico: "); System.out.println(me.getValue( )); } System.out.println( ); // Y otro mapa para numsAtom. TreeMap<String, Integer> numsAtom2 = new TreeMap<String, Integer>( ); // Pone elementos en el mapa. numsAtom2.put("Zinc", 30); numsAtom2.put("Plomo", 82); // Inserta numsAtom2 en numsAtom. numsAtom.putAll(numsAtom2); // Muestra el mapa después de las adiciones. set = numsAtom.entrySet( ); // Despliega las claves y los valores del mapa. System.out.println("Ahora el mapa contiene estas " + numsAtom.size( ) + " entradas:"); for(Map.Entry<String, Integer> me : set) { System.out.print(me.getKey( ) + ", n\u00a3mero at\u00a2mico: "); System.out.println(me.getValue( )); } System.out.println( ); // Busca una clave. if(numsAtom.containsKey("Oro")) System.out.println("El oro tiene un n\u00a3mero at\u00a2mico de " + numsAtom.get("Oro"));

Capítulo 5:


237

// Busca un valor. if(numsAtom.containsValue(82)) System.out.println("el n\u00a3mero at\u00a2mico 82 est\u00a0 en el mapa."); System.out.println( ); // Elimina una entrada. if(numsAtom.remove("Oro") != null) System.out.println("El oro se ha eliminado.\n"); else System.out.println("No se encontr\u00a2 la entrada.\n"); // Despliega el conjunto de claves después de la eliminación del oro. Set<String> claves = numsAtom.keySet( ); System.out.println("Las claves tras eliminar el oro:"); for(String cad : claves) System.out.println(cad + " "); System.out.println( ); // Despliega el valor establecido después de la eliminación del oro. Collection vals = numsAtom.values( ); System.out.println("Los valores tras eliminar el oro:"); for(Integer n : vals) System.out.println(n + " "); System.out.println( ); // Limpia el mapa. System.out.println("Limpiando el mapa."); numsAtom.clear( ); if(numsAtom.isEmpty( )) System.out.println("Ahora el mapa est\u00a0 vac\u00a1o."); } }

Aquí se muestra la salida: El mapa contiene estas 6 entradas: Cobre, número atómico: 29 Hidrógeno, número atómico: 1 Hierro, número atómico: 26 Oro, número atómico: 79 Oxígeno, número atómico: 8 Plata, número atómico: 47 Ahora el mapa contiene estas 8 entradas: Cobre, número atómico: 29 Hidrógeno, número atómico: 1 Hierro, número atómico: 26 Oro, número atómico: 79 Oxígeno, número atómico: 8 Plata, número atómico: 47 Plomo, número atómico: 82 Zinc, número atómico: 30

238


El oro tiene un número atómico de 79 el número atómico 82 está en el mapa. El oro se ha eliminado. Las claves tras eliminar el oro: Cobre Hidrógeno Hierro Oxígeno Plata Plomo Zinc Los valores tras eliminar el oro: 29 1 26 8 47 82 30 Limpiando el mapa. Ahora el mapa está vacío.

Opciones Aunque TreeMap se usó para demostrar las técnicas básicas de mapas, pudo usarse cualquier clase de mapa. Por ejemplo, pruebe la sustitución de TreeMap con HashMap en el ejemplo. El programa se compilará y ejecutará apropiadamente. La razón es que, por supuesto, todos los mapas implementan la interfaz Map y sólo los métodos definidos por Map se usan en el ejemplo. Cuando se usa un mapa ordenado, como TreeMap, puede especificar un comparador personalizado de la misma manera que lo haría con una colección ordenada. Consulte Use un Comparator con una colección.

Convierta una lista de Properties en un HashMap Componentes clave Clases e interfaces

Métodos

java.util.Properties

Object setProperty(String c, String v)

java.util.HashMap

Versiones anteriores de Java no incluían la estructura de colecciones. En cambio, se proporcionaba un grupo ad hoc de clases, como Vector, Properties y Hashtable. Aunque estas clases eran adecuadas, no formaban un todo coherente y se volvieron obsoletas con la estructura de colecciones. Sin embargo, estas clases heredadas aún tienen soporte en Java porque una cantidad importante de código aún depende de ellas. Para ayudar a zanjar la brecha entre las clases heredades y la estructura de colecciones, las clases heredades fueron tratadas para adecuarse a las colecciones. Por ejemplo, Vector implementa la interfaz List y Hashtable implementa Map. Esto facilita la

Capítulo 5:


239

conversión de una clase heredada en una colección o un mapa. Una situación en que esto resulta particularmente útil es cuando se trabaja con propiedades que están almacenadas en la lista de Properties. Properties es una clase heredada que almacena claves y valores. Properties es única porque cada clave y valor es una cadena. Es una subclase de Hashtable que fue reformada para implementar la interfaz Map. Esto facilita la conversión de una lista de Properties heredada en un mapa que es parte de la estructura de colecciones. Debido a que Properties usa una tabla de hash para almacenamiento, tiene sentido que se convierta en un HashMap. En esta solución se muestra cómo hacerlo.

Paso a paso Para convertir un objeto de Properties en un HashMap, siga estos pasos: 1. Obtenga una referencia al objeto de Properties que quiera convertir. 2. Cree un HashMap que especifique String para las claves y los valores. 3. Pase el objeto de Properties al constructor de HashMap. Para ello, debe modificar la referencia de Properties a Map.

Análisis La manera más fácil de convertir una lista de Properties en una Map es pasar el objeto de Properties al constructor del mapa. Esto funciona porque todas las implementaciones del mapa proporcionadas por la estructura de colecciones definen un constructor que crea un mapa a partir de otra instancia de Map. En esta solución se usa un HashMap para almacenar la lista de Properties convertida porque usa una tabla de hash para almacenamiento. Por tanto, HashMap proporciona una implementación equivalente. El siguiente constructor de HashMap se usa para convertir una lista de Properties en un mapa: HashMap(Map Por supuesto, cuando se pasa un objeto de Properties, tanto C como V serán objetos de String. Hay un tema del que necesita estar consciente cuando pase un objeto de Properties a una implementación de Map. Properties implementa Map

Java Soluciones De Programación 1n4l6b

Overview 26281t

More details 6y5l6z

Related Documents 3h463d

Soluciones 2c2o5m

Soluciones 2c2o5m

Soluciones 2c2o5m

Java 4b221u

Soluciones Ejercicios De Funciones 4l2f42

Busqueda De Soluciones 6g2c1x

More Documents from "Csar Palacios" 4h4t26

4p345f

4p345f

Diapositivas 38 Flores De Bach 683y5w

Estudios Geologicos Alternativas Para Presas 444j3t

Catalogo Torno Chino 6o1721

Temario Inspeccion Visual I Y Ii Imisi Corp 2r216a