IBM_Core Java - Libro 2

Core Java Código del Curso: CY420 Versión: 5.1

Guía del Estudiante

Libro 2: Core Java

IBM Training Worldwide Certified Material

Información Sobre la Publicación Esta publicación ha sido producida usando Microsoft Word 2000 y Microsoft PowerPoint 2000 para Windows.

Marcas Registradas IBM ® es una marca registrada por International Business Machines Corporation. Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o marcas de servicios de otros.

Marcas Registradas de otras Compañías HotJava browser, Java Development Kit (JDK), Java, Java Servlet, Solaris, Enterprise Java Beans, Java Server Pages, JDK, JSP – Sun Microsystems, Microsoft MAKECAB, Windows operating system, ASP, VB, .NET, VC++, Microsoft Access, Microsoft SQL Server, Microsoft ODBC for Oracle – Microsoft Corp, WinZip – Nico Mak Mak Computing, Inc., Time – Time Warner, JDBC – Javasoft, Oracle – Oracle Corporation, Sybase – Sybase Inc., UDB DB2 – IBM.

Edición Octubre 2007 La información contenida en este documento no ha sido sometida a ninguna prueba formal de IBM y es distribuida básicamente “como es" sin ninguna garantía ya sea expresa o implícita. El uso de esta información o la implementación de cualquiera de estas técnicas es responsabilidad del comprador y dependerá de la habilidad de éste para su evaluación e integración en el ambiente operacional del comprador. A pesar de que cada tema ha sido revisado por IBM para su exactitud en una situación específica, no hay garantía de que obtener el mismo resultado o uno similar a éste en otra situación. Los compradores que intenten adaptar estas técnicas a sus propios ambientes lo hacen bajo su propio riesgo.

Copyright International Business Machines Corporation, 2007. All rights reserved. Este documento no puede ser reproducido en su totalidad o en parte sin el previo permiso escrito de IBM. Instrucciones Especiales para la Impresión de este Curso: No elimine páginas en blanco que puedan aparecer al final de cada unidad o entre unidades. Estas páginas fueron insertadas intencionalmente.

.


Core Java

Contenido Volumen 3: Manejo Manejo de Excepciones .................................................... .................................................................1 .............1 Unidad 1: Manejo de Excepciones y Tipos de Excepciones...........................3 Objetivos de Aprendizaje

3

1. Introducción

4

2. Técnicas Tradicionales de Manejo de Errores

4

3. Excepciones y Condiciones Anormales

5

4. Java y el Manejo de Excepciones

5

5. Agrupar Excepciones en Java

14

6. Excepciones Verificadas y No Verificadas

17

7. La Clase Throwable y sus Clases Derivadas

17

8. Manejo de Excepciones

19

9. Flujo de Manejo de Excepciones

21

Resumen

23

Unidad 1: Examen de Autoevaluación

24

Respuestas a la Unidad 1: Examen de Autoevaluación

27

Unidad 2: Lanzamiento Lanzamiento y Manejo de Excepciones ........................................29 ........................................29 Objetivos de Aprendizaje

29

1. Introducción

30

2. Excepciones Estándar en Java

30

3. Usar la Jerarquía de Excepciones

32

4. La Cláusula finally Revisada

34

5. Sobrescribir Métodos que Lanzan Excepciones

36

6. Crear Excepciones Definidas por el Usuario

39

7. Más de Excepciones Definidas por el Usuario

42

8. La Cláusula throws Revisada

45

Resumen

50


51


53

Unidad 3: Laboratorio Laboratorio de Lanzamiento Lanzamiento y Manejo de Excepciones ..............55 Objetivos de Aprendizaje

55

Ejercicios de Laboratorio

56

Volumen 4: Facilidades de Entrada / Salida ................................................. .....................................................56 56 Unidad 1: Archivos y Flujos.......................................... Flujos................................................................... ...................................5 ..........566 i © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


Objetivos de Aprendizaje

56

1. Introducción

56

2. Archivos

56

3. Flujos

56

4. La Clase InputStream

56

5. La Clase OutputStream

56

6. La Clase Reader

56

7. La Clase Writer

56

8. La Clase Scanner

56

Resumen

56


56


56

Unidad 2: Laboratorio de Archivos y Flujos...................................................56 Objetivos del Aprendizaje

56


56

Unidad 3: Serialización de Objetos .................................................................56 Objetivos del Aprendizaje

56

1. Introducción

56

2. Serialización de Objetos

56

3. Aplicaciones de la Serialización de Objetos

56

4. Implementando Serialización en Java

56

Resumen

56


56


56

Unidad 4: Laboratorio de Serialización de Objetos .......................................56 Objetivos del Aprendizaje

56


56

ii © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.


Core Java

Volumen 3: Manejo de Excepciones

Libro 2: Core Java

Unidad 1: Manejo de Excepciones y Tipos de Excepciones 1 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.


Core Java

Unidad 1: Manejo de Excepciones y Tipos de Excepciones Objetivos de Aprendizaje Al final de esta unidad, usted será capaz de: •

•

•

•

•

Definir las excepciones y explicar las técnicas tradicionales de manejo de errores. Describir el manejo de excepciones en Java. Diferenciar entre excepciones verificadas y no verificadas. Describir las sub-clases de la clase Throwable. Describir el flujo de manejo de excepciones en Java.

Libro 2: Core Java


Core Java


1. Introducción En el Volumen 2 – Programación Orientada a Objetos, se revisó Java como lenguaje de programación y se identificaron los conceptos de clases, objetos, modificadores de acceso, herencia en java, interfaces y paquetes. En esta unidad, se discutirá como se manejan los errores en un programa. Los programas no están siempre libres de errores, en Java cuando ocurre una condición de error, se lanza una excepción. Las excepciones son eventos anormales que ocurren durante el curso de la ejecución de un programa y rompen la secuencia normal de ejecución del programa. Algunas de las preguntas inherentes a las excepciones, que le pueden surgir al programador son las siguientes: •

•

•

•

•

¿Necesariamente un programa debe manejar eventos anormales? ¿El código para el manejo de errores debe asociarse con cuál parte del programa? ¿Cómo se detecta y maneja el error durante el tiempo de ejecución? ¿Qué le pasa a la aplicación cuando se maneja un error? ¿Proveen los lenguajes de programación soporte para encontrar y manejar errores?

Muchas de estas preguntas serán respondidas en esta y la próxima unidad. Para empezar se discuten las técnicas tradicionales para el manejo de errores.

2. Técnicas Tradicionales de Manejo de Errores En los inicios de la programación de computadoras, lenguajes como Pascal, Fortran y C no proveían ningún soporte a los programadores para el manejo de errores. Era responsabilidad del programador proveer rutinas para el manejo de errores, debido a esto, muchos errores importantes no eran detectados en las aplicaciones. Todo esto se dedujo, porque el código para el manejo del error estaba escrito junto con el programa principal, esto hacía difícil distinguir el flujo del programa principal del código para manejo de errores. Adicionalmente, esta situación complicaba el proceso de depuración del programa. Lenguajes de programación desarrollados posteriormente como BASIC y COBOL proveían un soporte estructurado para la revisión y manejo de errores. Proporcionaban la siguiente construcción del lenguaje para el manejo de errores: ON ERROR GOTO ...

Esta construcción separaba el código para el manejo del error del código principal. Cuando un programa encontraba un error, el control del programa saltaba a la posición especificada por el GOTO. La posición especificada contenía el código para el manejo Unidad 1: Manejo de Excepciones y Tipos de Excepciones

Libro 2: Core Java 4

© Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.


Core Java

del error. Lenguajes de programación diferentes proveían sintaxis diferentes para la detección y manejo de errores. Sin embargo, la estructura básica era similar a la mencionada anteriormente. Aunque el código para manejo de errores con un lenguaje que lo soportara era mejor que ningún soporte, el código del programa principal todavía se intercalaba con el código para la verificación y manejo de errores. Además, el flujo de ejecución era interrumpido ya que el control saltaba a una posición diferente para luego retornar después de manejado el error. Con la evolución de la programación orientada a objetos, se introdujo una nueva forma de manejar los errores, en la cual, el código para el manejo del error era separado del código del programa principal.

3. Excepciones y Condiciones Anormales Como se mencionó anteriormente, las excepciones son eventos anormales que ocurren durante la ejecución del programa. Los siguientes son algunos ejemplos de cuando se lanzan excepciones: •

•

•

•

•

•

Cuando un número es dividido entre cero. Esto puede ser detectado sólo en tiempo de ejecución, ya que las operaciones se efectúan durante la ejecución del programa. Cuando se accede a un elemento de un arreglo que esta fuera del límite del arreglo. Cuando ocurre una condición de desborde (overflow o underflow) durante la asignación de valores a variables numéricas. Cuando un recurso que es requerido por la aplicación no está disponible. Una aplicación, por ejemplo, puede requerir una impresora y la impresora puede no estar conectada a la computadora. Cuando un programa requiere un archivo para lectura, y el archivo no está disponible en el sistema de archivos. Cuando un programa accede a recursos del sistema sin autorización.

Estos son solo algunos ejemplos de cuando puede ocurrir una excepción en un programa. Algunas de estas no son lo suficientemente serias y la ejecución del programa puede continuar, una vez manejadas, pero hay excepciones que no permiten que continúe la ejecución del programa. A continuación se discute el soporte provisto por Java para el manejo de excepciones.

4. Java y el Manejo de Excepciones Java tiene incorporado la capacidad para asegurar que las excepciones son manejadas dentro del programa. Aunque los programadores pueden manejar algunos errores, otros son manejados por la JVM. El programador debe manejar un error como el de ‘archivo no encontrado’, mientras que el error ‘fuera de memoria’ será manejado por la JVM. La Libro 2: Core Java


Core Java


Figura 1.1 muestra la secuencia de acciones que ocurren cuando se presenta una condición anormal.

Figura 1.1: Secuencia de Acciones Cuando se Produce una Excepción

Se discute a continuación lo que significa arrojar una excepción.

Unidad 1: Manejo de Excepciones y Tipos de Excepciones




Core Java

En Java, cuando ocurre un error, éste se encuentra en un método. El método crea un objeto de la excepción que ocurrió, para manejar el error, y separar el manejo del error del código actual. Así, si el método estaba efectuando algún cálculo matemático, si la variable no puede tomar un valor negativo, un objeto de la excepción que puede manejar esta excepción será creado. En Java, todas las clases excepción son derivadas de la clase base Exception. Una vez creado el objeto excepción, el método pasa el objeto excepción al sistema de tiempo de ejecución Java, este pase del objeto se hace a través del concepto de lanzar la excepción. El sistema de tiempo de ejecución busca en la pila de llamadas y ubica el método que manejará la excepción levantada. La pila de llamadas tendrá detalles de cómo se llamó al método que originó la excepción. En el caso de que el método más interno lance un error y no lo maneje, la excepción será pasada en forma ascendente por la pila de llamadas hasta que se consiga un método que maneje la excepción. Si se consigue este método, la excepción es manejada, sino la ejecución del programa se detiene. Java brinda soporte al manejo de excepciones con el uso de cinco palabras claves, que son: try, catch, throw, throws y finally. Se explican cada una de ellas en las siguientes secciones.

4.1 Usando Bloques try y catch Java provee dos cláusulas para el manejo de excepciones en una forma sofisticada. Se pueden manejar las excepciones en un programa Java, usando las cláusulas try y catch. Se usarán los términos bloques y cláusulas indistintamente, cuando se haga referencia a try, catch y finally (este último tratado en una sección posterior). A continuación se presenta un ejemplo para apreciar la importancia de separar la revisión y manejo del error del código principal.

Ejemplo 1.1 Asuma que se quiere obtener el n-ésimo elemento de una lista de elementos diferentes si este es un string. El algoritmo es el siguiente:

El algoritmo comienza aquí… 1. recuperarNEsimoElemento() { 2.

aceptar lista;

3.

obtener n-esimo elemento de la lista;

4.

retornar el elemento si es un String o retornar nulo;

5. }

El algoritmo termina aquí El algoritmo anterior no incluye nada para la verificación y manejo de errores. Se tienen cuatro eventos de revisión de error que puede proveer la función anterior: Libro 2: Core Java


Core Java


Si la lista es null. Si la lista esta disponible, pero vacía. Si el valor de 'N' no es un índice válido en la lista. Si el elemento N no es un string. Ahora se expande el algoritmo anterior para incluir el manejo de errores.

El algoritmo comienza aquí… 1. String recuperarNEsimoElemento(List lista, int n) { 2.

String str;

3. 4.

if (lista == null)

5.

str = "Lista nula";

6.

else if (esVacio(lista))

7.

str = "Lista vacia";

8.

else if (n < 0 || n > numeroDeElementos(lista))

9.

str = "Indice invalido";

10.

else {

11.

str = getElemento(lista, n);

12.

if (!esString(str))

13.

str = "No es un String";

14.

}

15. 16. 17.

return str; }

El algoritmo termina aquí Se ha intercalado el código principal con el código para manejo de errores, haciéndolo difícil de entender. Se va a ver como manejar los errores anteriores en Java.

El código Java comienza aquí… 1. // Definicion de Metodo en Java 2. String recuperarNEsimoElemento(List lista, int n) { 3.

try {

4.

1) Obtener n-esimo elemento de la lista;

5.

2) Retornar el elemento si es un String o retornar null;

6. 7. 8.

} catch (lista_es_nula) { 1) Manejo de la excepcion cuando la lista es nula; } catch (lista_esta_vacia) {




Guía del Estudiante 9.

Core Java

1) Manejo de la excepcion cuando la lista esta vacia;

10.

} catch (indice_invalido) {

11.

1) Manejo de la excepcion cuando el indice es invalido;

12.

} catch (elemento_no_es_String) {

13.

1) Manejo de la excepcion cuando el elemento a

14.

recuperar no es un String;

15.

}

16. }

El código Java termina aquí En el código anterior, se nota que el código para manejo de errores está separado del código principal, que se concentra en la funcionalidad del método. El código que puede generar una excepción se coloca dentro del bloque try, y el código para el manejo del error se coloca dentro del bloque catch apropiado. Aunque, el algoritmo anterior es muy elegante, se debe recordar que el programador tiene que escribir el código para manejar la excepción.

Fin del Ejemplo 1.1 Se mostrará ahora el uso de la cláusula throws en Java.

4.2 Usando la Cláusula throws La cláusula throws se usa cuando un método que lanza una excepción no maneja la excepción. Asuma que el método recuperarNEsimoElemento() no maneja ninguna excepción y que es invocado por el método validarLista(), entonces recuperarNEsimoElemento() debe especificar las excepciones que lanza, usando la cláusula throws, como a continuación: public String recuperarNEsimoElemento(List lista, int n) throws Excepcion1, Excepcion2, Excepcion3, Excepcion4 {

// Obtiene el n-esimo elemento de la lista; // Retorna elemento si es String o retorna null; }

Un método puede lanzar una o más excepciones. Todavía no se ha mostrado como se lanzan las excepciones, se explica en la Sección 4.3 – La Sentencia throw . Debido a que el método recuperarNEsimoElemento() no maneja las excepciones, debe usar la palabra reservada throws en su encabezado de método. Todas las excepciones verificadas lanzadas deben ser especificadas en el encabezado del método, los nombres usados en el ejemplo anterior son los nombres de las clases excepción creadas para manejar las diferentes excepciones. El método validarLista() será como a continuación se muestra: public void validarLista(List lista, int n) {

Libro 2: Core Java


Core Java


try { recuperarNEsimoElemento(lista, n); // Otras sentencias } catch (lista_es_nula) { // Manejo de la excepcion cuando la lista es nula; } catch (lista_esta_vacia) { // Manejo de la excepcion cuando la lista esta vacia; } catch (indice_invalido) { // Manejo de la excepcion cuando el indice es invalido; } catch (elemento_no_es_String) { // Manejo de la excepcion cuando el elemento a // recuperar no es un String; } }

Se puede ver del código anterior que el bloque try-catch se uso en el método validarLista() en lugar de en el método recuperarNEsimoElemento(). Si validarLista() no maneja la excepción, necesita especificar usando la cláusula throws las excepciones que no maneja. Finalmente, las excepciones deben ser manejadas en algún punto del programa, dentro de la pila de llamadas. Si ningún manejador esta disponible la JVM maneja la excepción, y finaliza. Se explicó como manejar excepciones usando los bloques try y catch, además de como el método que lanza una excepción, lo indica, usando la cláusula throws. A continuación se explica como se puede lanzar una excepción.

4.3 La Sentencia throw La cláusula throws se usa para indicar cual método puede lanzar una excepción. Cuando ocurre un error en un programa, justo en el punto donde ocurre, una excepción es levantada, esto se hace usando la sentencia throw en Java. Observe el algoritmo anterior para entender como usar la sentencia throw para lanzar la excepción.

El algoritmo comienza aquí… tipoDeRetorno nombreMetodo(tipoDeDato nombreArgumento) throws NombreExcepcion { // Declaraciones // Algunas sentencias if (algunaCondicion) throw new NombreExcepcion();





Core Java

else { // Continuar } }

El algoritmo termina aquí En el algoritmo anterior, cuando algunaCondicion es verdadera, se lanza una excepción usando la sentencia throw. La sentencia throw lanza un objeto de la clase excepción NombreExcepcion. Este objeto debe pertenecer a la clase excepción especificada en la cláusula throws. En el ejemplo anterior, la sentencia throw crea un objeto de la clase NombreExcepcion y lo lanza. A menos que una excepción sea arrojada en el programa, no puede ser tomada o manejada en ningún lugar. Un método puede lanzar más de una excepción de la siguiente manera:

El algoritmo comienza aquí… tipoDeRetorno nombreMetodo(tipoDeDato nombreArgumento) throws NombreExcepcion1, NombreExcepcion2 { // Declaraciones // Algunas sentencias if (algunaCondicion1) throw new NombreExcepcion1();

else { // Continuar if (algunaCondicion2) throw new NombreExcepcion2();

else // Continuar } }

El algoritmo termina aquí En el algoritmo anterior, el método lanza dos excepciones mediante el uso de dos sentencias throw en el cuerpo del método. Si alguno de los métodos en una clase lanza un objeto excepción que no concuerda con las clases excepción especificadas en la cláusula throws del método, se genera un error en tiempo de compilación. El método recuperarNEsimoElemento() usado anteriormente se muestra ahora con las sentencias throw incluidas: Libro 2: Core Java


Core Java


El código Java comienza aquí… public String recuperarNEsimoElemento(List lista, int n) throws ListaNullExcepcion, ListaVaciaExcepcion, IndiceInvalidoExcepcion, ElementoNoEsStringExcepcion { String elemento = null; if (lista == null) throw new ListaNullExcepcion(); if (esVacio(lista)) throw new ListaVaciaExcepcion(); if (n < 0 || n > numeroDeElementos(lista)) throw new IndiceInvalidoExcepcion(); elemento = getElemento(lista, n); if (!esString(elemento)) throw new ElementoNoEsStringExcepcion(); return elemento; }

El código Java termina aquí En el código anterior, se ve como el método lanza cuatro excepciones explícitamente usando la sentencia throw. Si el método que invoca al método anterior no maneja las excepciones, entonces solamente debe especificar la cláusula throws en su declaración de método. Solo la clase que levanta la excepción usa la sentencia throw. A continuación se explicará el uso de la cláusula finally en los programas.

4.4 Usando el Bloque finally Se vio que en el bloque try-catch, el bloque try contiene el código que puede generar la excepción, y el bloque catch captura las excepciones indicadas lanzadas por el bloque de código y las maneja. Existe otro tipo de bloque, llamado bloque finally, que puede ser añadido al final de todos los bloques catch. Se usa básicamente para tareas de limpieza, como cerrar archivos y liberar recursos.





Core Java

El bloque finally se ejecuta después de la ejecución de todos los bloques catch. El bloque finally siempre se ejecuta aún cuando no se lance ninguna excepción en el bloque try o aunque los bloques try-catch tengan una sentencia return. El siguiente algoritmo muestra la estructura general del bloque try-catch-finally:

El algoritmo comienza aquí… try{ // Código que puede generar las execpciones } catch (ChequeoExcepcion1 x1) { // Código para manejo de la excepción } catch (ChequeoExcepcion2 x2) { // Código para manejo de la excepción } finally(){ // Código de limpieza }

El algoritmo termina aquí La Figura 1.2 explica el uso del bloque finally.

Figura 1.2: Uso del Bloque finally

Libro 2: Core Java


Core Java


La Figura 1.2 muestra dos escenarios en los cuales se invoca el código en el bloque finally. Se explica a continuación cada uno de ellos. En el primer escenario, el método lanza todas las excepciones, ya que no hay un bloque catch. El bloque finally es ejecutado siempre. Aquí, la organización esta garantizada, al quedar separado el manejo de excepciones. El segundo escenario muestra sentencias catch además del bloque finally. El método captura las excepciones que coincidan con las del bloque catch. El bloque catch lanza una nueva excepción. La pulcritud esta todavía garantizada. Java también permite a los programadores crear sus propias excepciones. Esto les ayuda a manejar situaciones de error que podrían surgir de acuerdo al comportamiento de los objetos de las clases escritas por ellos. Se discutirá en detalle esta característica poderosa en la Unidad 2 - Lanzamiento y Manejo de Excepciones. A continuación se explica como se pueden agrupar las excepciones.

5. Agrupar Excepciones en Java Varias excepciones pueden ocurrir en un programa Java. Clasificar las excepciones las hacen más fáciles de manejar. Las excepciones que denotan desborde del tipo (overflow y underflow) en enteros y la división de un número entre cero, pueden ser clasificadas en una categoría. Las excepciones relacionadas con la manipulación de arreglos, como índice fuera de límites o elemento no presente pueden ser agrupadas en otra categoría. Las excepciones relacionadas con las pilas como pila vacía o pila llena pueden ser agrupadas separadamente, y también las excepciones que se ocupan de la lectura o escritura en archivos pueden ser agrupadas aparte. Es posible clasificar las excepciones, debido a que Java soporta la herencia. Se puede tener una superclase que especifique las características comunes a todas las excepciones de un tipo en particular. Todas las excepciones bajo una misma categoría pueden heredar de esta super clase. Todos los tipos de excepciones y errores en Java son sub-clases de la clase Throwable o una de las sub-clases de la clase Throwable. La Figura 1.3 representa la agrupación de las excepciones relacionadas con pilas. En la representación jerárquica de las clases excepción, los nodos hoja denotan tipos específicos de excepciones y errores, además los nodos intermedios denotan una categoría general de la excepción.





Core Java

En la Figura 1.3, PilaVaciaExcepcion y PilaLlenaExcepcion denotan dos tipos específicos de excepciones de pila. La PilaExcepcion representa la categoría general de las excepciones de pila.

Figura 1.3: Jerarquía Hipotética de las Excepciones de Pila

La Figura 1.4 representa los errores que ocurren en la lectura y escritura de archivos.

Figura 1.4: Jerarquía Hipotética de la Excepciones de la Clase File

Nota: Las excepciones en las sub-clases deben ser manejadas antes que las excepciones en las superclases. Si las superclases son manejadas primero, el código que maneja las subclases nunca alcanzará las excepciones en la subclase. Aunque es útil clasificar las excepciones en categorías y manejar una categoría particular de excepciones, algunas veces la situación puede demandar que cada excepción se maneje separadamente. Por esto, hay dos formas en las que se puede capturar y manejar excepciones. El primer método es capturar cada excepción separadamente, comenzando desde el nodo

Libro 2: Core Java


Core Java


inferior y subiendo en la jerarquía. El segundo método es capturar directamente la excepción representada por el nodo superior. El algoritmo para el primer método de captura de excepciones, es decir, capturar cada excepción separadamente, es como se muestra a continuación:

El algoritmo comienza aquí… try{ // Código que puede generar la excepción } catch (FileNotFoundException x1) { //Código para manejar la excepción } catch (FileCorruptException x2) { // Código para manejar la excepción } catch (NoPermissionOnFileException x3) { // Código para manejar la excepción } catch (CannotReadException x4) { // Código para manejar la excepción } catch (FileException x5) { // Código para manejar la excepción }

El algoritmo termina aquí En el código anterior, si la primera sentencia catch capturara FileException, entonces todas las excepciones lanzadas, que sean sub-clases de FileException serán capturadas justo en el primer catch. Esto no es deseable normalmente, ya que se quiere que cada excepción específica sea manejada separadamente. Por esto, se tiene a la superclase FileException como el último manejador de excepción. El segundo método de capturar excepciones, es decir, capturar la expresión del nodo superior directamente, es como a continuación se muestra:

El algoritmo comienza aquí… try{ // Código que puede generar la excepción





Core Java

} catch (FileException x) {/* // Código para manejar la excepción }

El algoritmo termina aquí Una vez entendidos los conceptos de excepciones, se explican ahora las excepciones verificadas y las no verificadas.

6. Excepciones Verificadas y No Verificadas Las excepciones verificadas son aquellas que el programador debe capturar y manejar dentro de la aplicación. Si el programador no captura una excepción verificada, o no la especifica usando la cláusula throws en la declaración del método, se producirá un error en tiempo de compilación. El programa no compilará hasta que la excepción sea capturada y manejada en algún punto apropiado dentro del programa. Las excepciones no verificadas son excepciones del tiempo de ejecución, las cuales son detectadas por la JVM. Las excepciones no verificadas son las excepciones de la clase RuntimeException y sus subclases que son lanzadas en un programa Java cuando hay un problema en la JVM. A los programadores no se les exige capturar y manejar las excepciones no verificadas. Existen situaciones donde se sabe que el código Java que se escribe puede arrojar excepciones, pero no se está seguro del tipo de la excepción que será lanzada. En estos casos, se puede simplemente capturarlas usando la clase Exception, que es la superclase de las excepciones, y una sub-clase de la clase Throwable . No es necesario capturar cada excepción separadamente. Java provee varias clases para manejar excepciones y errores. Se presentan a continuación.

7. La Clase Throwable y sus Clases Derivadas La Figura 1.5 muestra la jerarquía de clases general de varias excepciones y errores provistos en la librería de Java. La clase Throwable es la superclase de las clases Error y Exception .

Libro 2: Core Java


Core Java


Figura 1.5: Jerarquía General de Clases de Excepciones y Errores de la Librería de Java

Los objetos de las clases Error y Exception son las excepciones lanzadas en los programas Java. Los errores causan que los objetos Error sean lanzados y las excepciones causan que los objetos Exception sean lanzados. Los errores son excepciones de bajo nivel, lanzados por la JVM. Java provee pocas clases excepción como parte de su librería, se explican ahora brevemente. Los programas Java que se escriben pueden lanzar y capturar solo excepciones, y no errores. La clase RuntimeException es un tipo especial de excepción que indica las excepciones ocurridas en la JVM en tiempo de ejecución. La clase NullPointerException es un tipo de RuntimeException que ocurre cuando un método intenta acceder a un objeto a través de una referencia a null. No es necesario para los programadores capturar y manejar excepciones del tiempo de ejecución, ya que es difícil seguirlas y capturarlas. Se ha discutido acerca de las excepciones, ahora Unidad 1: Manejo de Excepciones y Tipos de Excepciones




Core Java

pasando a los errores, algunos ejemplos de errores son: errores de AWT, errores de enlace, error de hilo muerto, y error de la máquina virtual. Java tiene clases separadas para manejar todos estos tipos de errores. AWT (Abstract Window Toolkit) será cubierto en el Volumen 5, Unidad 1 – Componentes y Contenedores AWT . A continuación se resumen las posibles acciones que se pueden tomar cuando se encuentra una excepción en el programa.

8. Manejo de Excepciones Los programadores pueden manejar las excepciones en cuatro formas, que son: •

•

•

•

Ignorar las excepciones no verificadas. Manejar las excepciones con un bloque try-catch. Lanzar las excepciones al método que invocó al actual. Manejar las excepciones y relanzarlas al método que invocó al actual.

8.1 Ignorar las Excepciones No Verificadas Los programadores pueden o no manejar las excepciones no verificadas. El compilador no impone ninguna restricción en las excepciones no verificadas. Los programadores pueden ignorarlas. La Figura 1.6 muestra como las excepciones no verificadas pueden ser ignoradas.

Figura 1.6: Ignorando las Excepciones No Verificadas

Si no se toma ninguna acción cuando ocurre una excepción no verificada, el método en el cual ocurre la excepción termina. La excepción es enviada al método que llamó al primer método. Esta es propagada hasta que la excepción sea manejada o el programa termina.

Libro 2: Core Java


Core Java


8.2 Manejar Excepciones con el bloque try-catch Esta es una forma estándar de manejar excepciones en Java. El bloque try-catch intercepta la excepción y la maneja. La excepción potencial puede ocurrir en cualquier lugar dentro del bloque try. Una vez que la excepción ocurre, el control se transfiere al bloque catch para el manejo. La Figura 1.7 ilustra esto.

Figura 1.7: Manejando Excepciones con el Bloque try-catch

En la figura, se llama al método registrarEmpleado() dentro del bloque try. En caso de que se lance EmpleadoActualExcepcion, es manejada dentro del bloque catch. La dirección del objeto EmpleadoActualExcepcion es recibida dentro del bloque catch para el procesamiento.

8.3 Lanzar Excepciones al Método Invocante Puede haber situaciones donde se tendrá una excepción verificada, pero no se está seguro de que se tiene que hacer si la excepción es capturada. En estos casos, se puede pasar la excepción al método que llamó al método actual. Considere la Figura 1.8, donde el método registrarEmpleado() lanza EmpleadoActualExcepcion. En caso de que la excepción ocurra en este método, la excepción es manejada en el método que invocó al método registrarEmpleado().

Figure 1.8: Lanzando Excepciones al Método Invocante





Core Java

8.4 Manejar Excepciones y Re-lanzarlas al Método Invocante Puede haber situaciones donde se quiera capturar una excepción, pero no se puede resolver la raíz de la causa del mismo. En estos casos, se puede capturar la excepción, hacer lo que se pueda para corregirla y pasar el objeto excepción al método invocante. Esto se muestra en la Figura 1.9.

Figura 1.9: Manejar y Relanzar Excepciones al Método Invocante

En el código anterior, si el objeto e es modificado dentro del bloque catch, y luego relanzado, el e modificado será lanzado. Así, un manejo parcial del error puede realizarse, donde el objeto e puede ser modificado, y luego relanzado. Se han visto varias formas de manejar excepciones y también diversos escenarios, donde se debe adoptar un método particular de manejo. Se puede decidir la forma apropiada de manejar excepciones, sin embargo, cuando hay numerosas invocaciones a métodos, manejo de excepciones y bloques que lanzan excepciones, el programador tiene que entender el flujo de las excepciones. Se discute a continuación el flujo de manejo de excepciones.

9. Flujo de Manejo de Excepciones Cuando se tienen muchas invocaciones a métodos y métodos lanzando las excepciones a los métodos que los invocaron, se torna difícil entender el flujo de la excepción. Considere la Figura 1.10, que explica el flujo de una excepción.

Libro 2: Core Java


Core Java


Figura 1.10: Flujo del Manejo de una Excepción

El método enemistar() es el detector de la condición de error. En el punto de la detección, crea y lanza un objeto. Un objeto, que es especificado por el ' throw', y debe ser una subclase de la clase Throwable. Asuma que algún método invoca al método cobrar(). Este a la vez llama al método prestar() dentro un bloque try-catch. La excepción lanzada por el método prestar() es manejada por el método cobrar() dado que no hay bloque catch definido en prestar(). El método prestar() invoca a enemistar(), que lanza la excepción X. Dado que la excepción en enemistar() no es manejada dentro de prestar()es relanzada al método cobrar().





Core Java

Resumen Ahora que ha completado esta unidad, usted debe ser capaz de: •

•

•

•

•

Definir las excepciones y las técnicas tradicionales para el manejo de errores. Describir el manejo de excepciones en Java. Diferenciar entre las excepciones verificadas y no verificadas. Describir las sub-clases de la clase Throwable. Describir el flujo de manejo de excepciones en Java.

Libro 2: Core Java


Core Java


Unidad 1: Examen de Autoevaluación 1) ¿Cuáles de las siguientes sentencias son verdaderas? a) Las excepciones son eventos. b) Los errores causan excepciones. c) Las excepciones causan errors. d) Todos los eventos son excepciones. 2) ¿Cuáles de las siguientes opciones pueden causar excepciones? a) Una falla de chip de memoria. b) Un intento de dividir un entero entre cero. c) Una referencia a una ubicación de memoria no asignada al usuario. d) Un intento de ejecutar una instrucción ilegal. 3) En Java, ¿cuáles de las siguientes opciones son consideradas como errores? a) Una falla de chip de memoria. b) Un intento de dividir un entero entre cero. c) Una referencia a una ubicación de memoria no asignada al usuario. d) Un intento de ejecutar una instrucción ilegal. 4) ¿Cuál de las siguientes es la clase base de todas las excepciones y errores? a) Exception. b) Error. c) Throwable. d) Ninguna de las anteriores. 5) En Java, tanto Error como Exception se derivan de la clase Throwable. a) Verdadero b) Falso 6) En Java, RuntimeException no necesita ser capturada ni manejada por el programador. a) Verdadero b) Falso





Core Java

7) Si A es la superclase de B, C y D, donde A, B, C y D son clases excepción, ¿cuál es el mensaje impreso cuando una excepción de la clase B es lanzada cuando se invoca al method1. (Refiérase al fragmento de código dado a continuación para responder a esta pregunta.) try { // metodo1 invocado aqui } catch(Throwable t) { System.out.println("T"); } catch (A a) { System.out.println("A"); } catch (B b) { System.out.println("B"); } catch (Exception e) { System.out.println("E"); }

a) b) c) d)

B A Error de compilación E

8) Las sentencias en Java dentro del bloque finally siempre serán ejecutadas ya sea que una excepción sea lanzada o no. a) Verdadero b) Falso 9) ¿Qué pasaría si throw object; es especificado y object no es un objeto Throwable? a) El throw será válido. b) Será convertido en un objeto Throwable y la sentencia será ejecutada. c) El compilador señalaría un error. d) Esto lanzaría una excepción.

Libro 2: Core Java


Core Java


10) ¿Cuál palabra clave se usa para indicar que un método lanza una excepción? a) throw. b) thrown. c) throws. d) Ninguna de las anteriores.





Core Java

Respuestas a la Unidad 1: Examen de Autoevaluación 1) 2) 3) 4) 5) 6) 7) 8) 9) 10)

ayb b a, c y d c a a c a c c

Libro 2: Core Java



Core Java

Unidad 2: Lanzamiento y Manejo de Excepciones Objetivos de Aprendizaje Al final de esta unidad, usted será capaz de: •

•

•

•

Mencionar las excepciones estándar en Java. Describir el uso de la jerarquía de excepciones. Explicar como sobrescribir métodos que lanzan excepciones. Crear excepciones definidas por el usuario.

Libro 2: Core Java

Unidad 2: Lanzamiento y Manejo de Excepciones 29 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


1. Introducción En la Unidad 1 – Manejo de Excepciones y Tipos de Excepciones, se explicaron las excepciones, la importancia de manejar excepciones y las clases excepción en Java. Se mostraron las sentencias básicas en Java try, catch y finally, que ayudan a manejar las excepciones y también se discutieron las excepciones verificadas y no verificadas. En esta unidad, se discutirán algunos ejemplos que ilustran el manejo de las excepciones de Java. También se explicará el método para definir, capturar y manejar excepciones definidas por el usuario. Igualmente se explicó que Java provee soporte para manejar excepciones en la forma de excepciones verificadas y no verificadas. Estas forman parte de la clasificación general de las excepciones estándar en Java. Java también le proporciona al programador la posibilidad de definir excepciones, que son llamadas excepciones definidas por el usuario. Antes, de proceder se explican las excepciones estándar en Java.

2. Excepciones Estándar en Java Se ha estudiado que las excepciones estándar son de dos tipos, verificadas y no verificadas. Las excepciones verificadas son aquellas que el programador debe capturar y manejar dentro de la aplicación, las excepciones verificadas no son del sistema de tiempo de ejecución. Si el programador no captura una excepción verificada usando el bloque try-catch, o no la especifica usando la cláusula throws en la declaración del método, se arrojará un error en tiempo de compilación. Si un código puede lanzar más de una excepción, entonces el código debe ser colocado dentro de un bloque try y seguido de un bloque catch para cada excepción que puede ser lanzada. Observe el siguiente ejemplo.

Ejemplo 2.1 El programa de este ejemplo ilustra como cada excepción se maneja separadamente con diferentes bloques catch.

El código Java comienza aquí… 1. /*Definicion de la clase ExcepcionEjemplo comienza aqui*/ 2. public class ExcepcionEjemplo { 3.

/* Metodo main comienza aqui */

4.

public static void main(String[] args) {

5.

float miArregloFloat[] = new float[10];

6.

int i;

7.

Unidad 2: Lanzamiento y Manejo de Excepciones




Core Java

8.

/* Chequear por argumento de línea de comando */

9.

if (args.length == 0)

10.

System.out.println(

11.

"Uso invalido de ExcepcionEjemplo");

12.

else {

13.

try {

14.

i = Integer.parseInt(args[0]);

15.

miArregloFloat[i - 1] = (float) 11.234;

16.

System.out.println(miArregloFloat[i]);

17.

} catch (ArrayIndexOutOfBoundsException e) {

18.

System.out.println(

19. 20.

"El valor del argumento no puede exceder de 10"); } catch (NumberFormatException e) {

21.

System.out.println(

22. 23. 24.

"El valor del argumento debe ser un numero entero"); } }

25. }/* Metodo main termina aqui */ 26. }/* Definicion de la clase ExcepcionEjemplo termina aqui */

El código Java termina aquí En este programa, primero se revisa si se tiene una entrada a través de la línea de comandos usando un simple if. Un mensaje de error se muestra cuando no se tiene entrada por la línea de comandos. Seguidamente, se tiene un bloque try que convierte el valor de entrada en un entero. Note que los argumentos de la línea de comandos son tomados como strings. El método parseInt() en Integer convierte el string "10" en el entero 10 si este valor es pasado como entrada en la línea de comandos. Luego, se usa el entero convertido como subíndice para el arreglo miArregloFloat, y un valor de punto flotante se le asigna al elemento i. Dos excepciones pueden ser lanzadas en el bloque try, las cuales son capturadas por los bloques catch que siguen al bloque try. Si la entrada no es un entero, se lanza una NumberFormatException, si el valor de la entrada excede el 10, se lanza una ArrayIndexOutOfBoundsException. Los mensajes que se reciben en cada caso, se muestran a continuación. Cuando el valor de la entrada no es un entero: El valor del argumento debe ser un numero entero

Cuando el valor de la entrada excede el tamaño del arreglo: El valor del argumento no puede exceder de 10

Libro 2: Core Java


Core Java


En este programa se pudo haber utilizado sola la superclase Exception en el bloque catch. El tener la superclase ayuda a capturar todas las excepciones lanzadas en el bloque try. Sin embargo, no se podrá manejar cada excepción separadamente.

Fin del Ejemplo 2.1 A continuación se verá como usar la jerarquía de excepciones.

3. Usar la Jerarquía de Excepciones Un bloque try puede tener cualquier cantidad de manejadores catch. Cuando se lanza una excepción, el control pasa al manejador catch apropiado. Cuando los manejadores catch pertenecen a diferentes clases en una jerarquía de excepciones, se sabe que las subclases en la jerarquía de excepciones deben ser capturadas antes que las superclase en la jerarquía de excepciones. Si las excepciones de las superclases son tomadas antes que las excepciones de las subclases, el compilador generará un error. Esto, porque la superclase se refiere a un concepto de generalización, mientras que la subclase representa una especialización del mismo concepto. Así, los manejadores de excepciones deben siempre primero manejar las excepciones en las subclases de la jerarquía. A continuación se presenta un ejemplo.

Ejemplo 2.2 El fragmento de código en el ejemplo ilustra el concepto de la jerarquía de excepciones que se ha discutido.

El código Java comienza aquí… try { i = Integer.parseInt(args[0]); miArregloFloat[i - 1] = (float) 11.234; System.out.println(miArregloFloat[i]); }catch (Exception e) { System.out.println("Alguna excepcion ha sido capturada"); }catch (ArrayIndexOutOfBoundsException e) { System.out.println( "El valor del argumento no puede exceder de 10"); }catch (NumberFormatException e) { System.out.println( "El valor del argumento debe ser un numero entero"); }

El código Java termina aquí Unidad 2: Lanzamiento y Manejo de Excepciones




Core Java

Un error en tiempo de compilación se genera para el código anterior, porque ya se han provisto los manejadores catch para manejar excepciones específicas. En Java, no se permite que un manejador para una excepción de una superclase preceda a uno de una subclase. Sin embargo, se puede dejar que el manejador de la superclase sea el último manejador de excepciones. Esto lo muestra el siguiente código:

El código Java comienza aquí… catch (ArrayIndexOutOfBoundsException e) { System.out.println( "El valor del argumento no puede exceder de 10"); }catch (NumberFormatException e) { System.out.println( "El valor del argumento debe ser un numero entero"); }catch (Exception e) { System.out.println( "Alguna excepcion ha sido capturada"); }

El código Java termina aquí En el segmento de código anterior, si se lanza ArrayIndexOutOfBoundsException, el primer bloque catch la maneja. Si se lanza NumberFormatException, el segundo bloque catch la maneja, y si alguna otra excepción se lanza, es manejada por el tercer bloque catch.

Fin del Ejemplo 2.2 Si no hay jerarquía de herencia entre las excepciones que pueden ser lanzadas en un programa, entonces las excepciones pueden ser capturadas en cualquier orden. La Figura 2.1 ilustra el manejo de excepciones usando un bloque try-catch. Los bloques catch se usan para capturar EOFException, FileNotFoundException, y ObjectStreamException. El orden en el cual estas excepciones son capturadas no importa, porque no hay jerarquía de herencia entre estas tres excepciones ya que todas son subclases de la clase java.io.IOException.

Libro 2: Core Java


Core Java


Figura 2.1: Manejo de Múltiples Excepciones

Una vez tratado exhaustivamente las excepciones en Java, se discute brevemente la cláusula finally mencionada en la Unidad 1 – Manejo de Excepciones y Tipos de Excepciones. En la Unidad 1, se dijo que la cláusula finally se puede usar para manejar excepciones estándar. A continuación, se discute como esta cláusula puede ser usada también para manejar excepciones definidas por el usuario.

4. La Cláusula finally Revisada En la Unidad 1- Manejo de Excepciones y Tipos de Excepciones, mostró que el bloque finally se puede usar al final del bloque try-catch para realizar operaciones de limpieza. El bloque finally será ejecutado sin importar si la excepción es lanzada o no y aún si el bloque try-catch tiene una sentencia return. Sin embargo, no será ejecutado si se tiene la siguiente sentencia: System.exit(0);

En cualquiera de los bloques try o catch System.exit(0) simplemente finalizará el programa, sin hacer ninguna operación de limpieza. Usar el bloque finally y la instrucción System.exit(0) juntos se considera una práctica pobre de programación, debido a que el control del programa nunca alcanzará el bloque finally. Se presenta a continuación un ejemplo para entenderlo mejor.

Ejemplo 2.3 Se escribe un programa que calcula la división de dos enteros que son pasados como argumentos.





Core Java

El código Java comienza aquí… 1. /*Definicion de la clase comienza aqui*/ 2. public class EnteroExcepcionEjemplo { 3.


4.


5.

System.out.println(

6.

"Invocando dividirEnteros " +

7.

"para dividir 12 entre 3");

8.

dividirEnteros(12, 3);

9.

System.out.println(

10.

"Invocando dividirEnteros " +

11.

"para dividir 12 entre 0");

12. 13.

dividirEnteros(12, 0); }/* Metodo main termina aqui */

14. 15.

/* Metodo dividirEnteros comienza aqui */

16.

public static void dividirEnteros(int x, int y) {

17.

try {

18.

int z = x / y;

19.

System.out.println("Cociente: " + z);

20.

}// Fin del bloque try

21.

catch (Exception e) {

22.

System.out.println(

23.

"Ocurrio una excepcion efectuando la division");

24.

}// Fin del bloque Exception

25.

finally {

26. 27. 28. 29.

System.out.println( "Ejecucion del bloque finally"); }// Fin del bloque finally }/* Metodo dividirEnteros termina aqui */

30. }/* Definicion de la clase termina aqui */

El código Java termina aquí La salida del código anterior será como sigue: Invocando dividirEnteros para dividir 12 entre 3 Cociente: 4 Ejecucion del bloque finally

Libro 2: Core Java


Core Java


Invocando dividirEnteros para dividir 12 entre 0 Ocurrio una excepcion efectuando la division Ejecucion del bloque finally

Fin del Ejemplo 2.3 En este ejemplo, cuando el método dividirEnteros es invocado (línea 8) por primera vez con los argumentos 12 y 3, el resultado de la operación es 4 y este valor es almacenado en z. La próxima instrucción es ejecutada y se imprime lo siguiente: Cociente: 4

Luego la cláusula finally se ejecuta, e imprime lo siguiente: Ejecucion del bloque finally

Cuando el método dividirEnteros se ejecuta por segunda vez con argumentos 12 y 0(línea 12), se sabe que resultará en un error porque un entero se divide entre cero. En este caso se arroja una excepción, y por esto la próxima instrucción, System.out.println no se ejecuta. La excepción será capturada por el bloque catch y cuando la sentencia dentro del bloque catch se ejecuta, se imprime lo siguiente: Ocurrio una excepcion efectuando la division

Luego, el bloque finally se ejecuta y se imprime lo siguiente: Ejecucion del bloque finally

Los métodos que lanzan excepciones pueden también ser sobrescritos como los métodos normales en Java. Esta sobrescritura ayuda cuando las subclases proveen una funcionalidad específica para el método. A continuación se aprenderá como sobrescribir métodos que lanzan excepciones.

5. Sobrescribir Métodos que Lanzan Excepciones Cuando la superclase y su subclase tienen métodos con el mismo nombre, número, tipo de argumentos y orden, la subclase esta sobrescribiendo el método en la superclase. Por esto, cuando se invoca este método desde un objeto de la subclase, solo el método que fue declarado en la subclase será ejecutado. El método declarado en la superclase está oculto. Cuando una subclase sobrescribe un método que lanza una excepción declarada en su superclase, la subclase puede hacer una de las siguientes opciones en el método sobrescrito: •

•

El método en la subclase puede lanzar el mismo tipo de excepciones lanzadas en el método de la superclase. El método en la subclase puede lanzar subclases de las excepciones lanzadas por el método en la superclase.





Core Java

Por ejemplo, asuma que la excepción A tiene las subclases B y C. Otra clase llamada Super en su método miMetodo lanza una excepción de tipo A. Cualquier clase derivada de Super, cuando sobrescriba miMetodo, puede lanzar una excepción de tipo A, o las subclases de A, que son B y C. Las subclases de Super no pueden lanzar ninguna otra excepción en el método miMetodo. El método en la subclase puede lanzar menos excepciones que el método en la superclase o puede no lanzar ninguna excepción. Sin embargo, el método declarado en la subclase no puede lanzar una excepción que sea superclase de la excepción lanzada en el método de la superclase. Se presenta el Ejemplo 2.4 para entender esto claramente.

Nota: Estas reglas aplican solo para excepciones verificadas, y solo para métodos sobrescritos no sobrecargados. Ejemplo 2.4 El siguiente código ilustra el concepto de lanzar excepciones en superclase y subclases.

El código Java comienza aquí… 1.

import javax.naming.LinkException;

2.

import javax.naming.NamingException;

3. 4.

/*Definicion de la clase SuperClase comienza aqui*/

5.

class SuperClase{

6.

/* Metodo miMetodo comienza aqui */

7.

public static void miMetodo(int a)

8.

throws LinkException{

9. 10.

}/* Metodo miMetodo termina aqui */

11. }/* Definicion de la clase SuperClase termina aqui */ 12. 13. /*Definicion de la clase SubClase comienza aqui*/ 14. public class SubClase extends SuperClase{ 15.


16.


17.

throws NamingException{

18. 19.


20. 21.


Libro 2: Core Java


Core Java 22.

Guía del Estudiante public static void main(String[] args) {

23.

SubClase sc = new SubClase();

24.

try {

25.

sc.miMetodo(10);

26.

}// Fin del bloque try

27.

catch (Exception e) {

28.

}// Fin del bloque catch

29.

}/* Metodo main termina aqui */

30. }/* Definicion de la clase SubClase termina aqui */

El código Java termina aquí Este programa no compilará (línea 16 en SubClase) porque el método miMetodo en SuperClase lanza LinkException, y el método miMetodo en SubClase lanza NamingException, que es superclase de LinkException. Suponga que el método miMetodo en SuperClase lanza NamingException, y el de SubClase lanza LinkException, entonces el programa compilará. Vea las líneas que cambiarían en el ejemplo anterior:

El código Java comienza aquí… . . 1. /*Definicion de la clase SuperClase comienza aqui*/ 2. class SuperClase{ 3.


4.


5.

throws NamingException{

6. 7.




13.


14.


15. 16.


.





Core Java

.

El código Java termina aquí Asuma que el método miMetodo en SubClase no lanza ninguna excepción. Aún así, el programa compila, ya que el método sobrescrito puede lanzar menos número de excepciones o ninguna excepción. Esto se ilustra en el siguiente fragmento de código:

El código Java comienza aquí… . . 1. /*Definicion de la clase SuperClase comienza aqui*/ 2. class SuperClase{ 3.


4.


5.


6. 7.




13.

public static void miMetodo(int a){

14. 15.


. .

El código Java termina aquí En el programa anterior, aunque miMetodo(), definido en la clase SubClase, no lanza ninguna excepción, el programa compila.

Fin del Ejemplo 2.4 Se discute a continuación como las excepciones definidas por el usuario pueden ser creadas para adaptarse a los programas.

6. Crear Excepciones Definidas por el Usuario Cuando se crean clases propias en Java, se elaboran excepciones propias o personalizadas para lanzar, capturar y manejar. Se pueden escribir clases de Libro 2: Core Java


Core Java


excepciones propias para adaptar su comportamiento. En Java, las excepciones se pueden crear para adaptarlas a nuestras necesidades de programación. También es posible crear una jerarquía de excepciones. Para crear una excepción, primero se tiene que declarar una clase que sea subclase de la clase Exception. El constructor de la nueva clase excepción que se crea invoca al constructor de su superclase (la clase Exception). En la Figura 2.4, se ilustra que la clase MiExcepcion es la clase excepción que se crea, esta clase extiende de la clase Exception. El constructor de MiExcepcion solamente invoca al constructor de su superclase, la clase Exception.

public class MiExcepcion extends Exception { public MiExcepcion(String mensaje) { super(mensaje); } //Esto es, ahora tiene su propia excepcion. //Sin embargo, todavia falta un poco mas por hacer }

Figura 2.2: Creando Una Clase Excepción Definida por el Usuario

Se entiende mejor esto con un ejemplo.

Ejemplo 2.5 El siguiente programa crea tres excepciones, son estas: MiBaseExcepcion, MiSubExcepcion y MiProximaExcepcion, que heredan de la clase Exception.

El código Java comienza aquí… 1. /*Definicion de la clase MiBaseExcepcion comienza aqui*/ 2. class MiBaseExcepcion extends Exception{ 3.

/* Constructor MiBaseExcepcion comienza aqui */

4.

public MiBaseExcepcion() {

5. 6.

super(); }/* Constructor MiBaseExcepcion termina aqui */

7. 8.


9.

public MiBaseExcepcion(String s) {

10.

super(s);





Core Java

}/* Constructor MiBaseExcepcion termina aqui */

12. }/* Definicion de la clase MiBaseExcepcion termina aqui */ 13. 14. /*Definicion de la clase MiSubExcepcion comienza aqui*/ 15. public class MiSubExcepcion extends MiBaseExcepcion{ 16.

/* Constructor MiSubExcepcion comienza aqui */

17.

public MiSubExcepcion() {

18. 19.

super(); }/* Constructor MiSubExcepcion termina aqui */

20. 21.


22.

public MiSubExcepcion(String s) {

23. 24.

super(s); }/* Constructor MiSubExcepcion termina aqui */

25. }/* Definicion de la clase MiSubExcepcion termina aqui */ 26. 27. /*Definicion de la clase ProximaExcepcion comienza aqui*/ 28. class ProximaExcepcion extends Exception { 29.

/* Constructor ProximaExcepcion comienza aqui */

30.

public ProximaExcepcion() {

31. 32.

super(); }/* Constructor ProximaExcepcion termina aqui */

33. 34.

/* Constructor ProximaExcepcion comienza aqui */

35.

public ProximaExcepcion(String s) {

36. 37.

super(s); }/* Constructor ProximaExcepcion termina aqui */

38. }/* Definicion de la clase ProximaExcepcion termina aqui */

El código Java termina aquí Aquí, se tiene tres excepciones creadas, MiSubExcepcion es subclase de MiBaseExcepcion, que a su vez es subclase de Exception. Por esto, MiSubExcepcion es indirectamente una subclase de la clase Exception. MProximaExcepcion es una subclase directa de la clase Exception.

Fin del Ejemplo 2.5

Libro 2: Core Java


Core Java


7. Más de Excepciones Definidas por el Usuario A

continuación

se

presentan

otros

ejemplos. Se usarán las clases InputStreamReader y BufferedReader en los ejemplos que siguen. Estas dos clases forman parte del paquete java.io y serán estudiadas en detalle en el Volumen 4, Unidad 1 – Archivos y Flujos. Seguidamente, se dará una breve explicación de estas clases ya que consisten en un método mejor para leer datos de consola que usar simplemente el método System.in.read(). La clase InputStreamReader lee bytes y los convierte en caracteres. Esta clase provee un puente entre flujos de bytes y caracteres. La clase BufferedReader almacena caracteres conforme los lee de un flujo de entrada de caracteres. Para crear un objeto InputStreamReader, se necesita un objeto InputStream como un argumento para el constructor de InputStreamReader. El InputStream que se puede pasar al constructor de InputStreamReader es System.in. Para crear un objeto de BufferedReader, se necesita un objeto de la clase Reader para el constructor de BufferedReader. Dado que InputStreamReader lee bytes, y los convierte en caracteres, se puede pasar un objeto de InputStreamReader como argumento al constructor de BufferedReader. Se presenta un extracto de código para entender bien este concepto: // Crear un objeto de InputStreamReader InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr);

Se pueden combinar las dos sentencias anteriores como sigue: BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.in se pasa como parámetro al constructor de InputStreamReader, que a su vez es el parámetro para el constructor de BufferedReader. Una vez creado un objeto BufferedReader, se pueden leer caracteres de consola usando el método readLine(), como sigue: br.readLine();

Esta instrucción retorna caracteres que pueden ser convertidos a un entero usando el método parseInt() de la clase Integer como sigue: total =Integer.parseInt(br.readLine()); // total es un int

Usar BufferedReader para leer datos es una buena alternativa en vez de usar System.in.read().

Ejemplo 2.6





Core Java

Tómese el ejemplo de la clase Stack. Las principales operaciones que se hacen con una pila son push cuando se coloca un elemento en la pila y pop cuando se toma el elemento que está en el tope de la pila. Java provee excepciones estándar para indicar las excepciones que podrían ser lanzadas durante las operaciones de push y pop. Defínase un método llamado top, que se usa para obtener el elemento del tope de la pila sin removerlo de la pila. Se debe lanzar una excepción si se intenta obtener el elemento en el tope de una pila vacía. Se escribe una clase propia de excepción (PilaVaciaExcepcion), que será lanzada cuando se intenta obtener el elemento tope de una pila vacía. El siguiente programa ilustra esto:

El código Java comienza aquí… 1. import java.io.BufferedReader; 2. import java.io.IOException; 3. import java.io.InputStreamReader; 4. import java.util.Stack; 5. 6. /*Definicion de la clase PilaVaciaExcepcion comienza aqui*/ 7. class PilaVaciaExcepcion extends Exception{ 8.

/* Constructor PilaVaciaExcepcion comienza aqui */

9.

public PilaVaciaExcepcion() {

10. 11.

System.out.println("La pila esta vacia"); }/* Constructor PilaVaciaExcepcion termina aqui */

12. }/* Definicion de la clase PilaVaciaExcepcion termina aqui */ 13. 14. /*Definicion de la clase PilaEjemplo comienza aqui*/ 15. public class PilaEjemplo extends Stack { 16.

/* Metodo top comienza aqui */

17.

public void top(PilaEjemplo pe)

18.

throws PilaVaciaExcepcion{

19. 20.

if (pe.isEmpty()){

21. 22.

throw new PilaVaciaExcepcion(); }else{

23.

Integer a = (Integer) pe.pop();

24.

System.out.println(a);

25. 26.

} }/* Metodo top termina aqui */

27. 28.


Libro 2: Core Java


Core Java 29.



30.

int total, numero;

31.

PilaEjemplo pila = new PilaEjemplo();

32. 33.

try {

34.

BufferedReader br = new BufferedReader(

35.

new InputStreamReader(System.in));

36.

System.out.println(

37.

"Ingrese la cantidad de elementos de la pila");

38.

total = Integer.parseInt(br.readLine());

39. 40.

if (total != 0) {

41.

System.out.println("Ingrese los numeros");

42. 43.

while (total > 0) {

44.

numero = Integer.parseInt(br.readLine());

45.

pila.push(new Integer(numero));

46.

total--;

47.

}

48. 49.

System.out.print(

50.

"El elemento que esta en el " +

51.

"tope de la pila es: ");

52. 53.

/* Llamada a funcion para obtener

54.

un elemento del tope de la pila */

55.

pila.top(pila);

56. 57.

} } catch (PilaVaciaExcepcion pv) {

58. 59.

System.out.println(pv); } catch (IOException e) {

60. 61.

e.printStackTrace(); } catch (NumberFormatException e) {

62.

System.out.println("Valor invalido");

63.

System.exit(0);

64. 65.

} }/* Metodo main termina aqui */





Core Java

66. }/* Definicion de la clase PilaEjemplo termina aqui */

El código Java termina aquí El código es autoexplicativo. Ilustra el método para definir una excepción definida por el usuario. Esto se hace derivando de la clase predefinida Exception.

Fin del Ejemplo 2.6 A continuación se explica el uso de la cláusula throws con excepciones definidas por el usuario.

8. La Cláusula throws Revisada Se requiere que un método Java especifique las excepciones que puede lanzar, que no son capturadas ni manejadas. Además de manejar excepciones estándar, la cláusula throws se usa también para manejar excepciones definidas por el usuario. Considere dos excepciones: ExcepcionA y ExcepcionB, en donde la ExcepcionA es la superclase de ExcepcionB. Considere un método prueba() en la clase es la superclase de SuperClaseDePrueba. SuperClaseDePrueba SubClaseDePrueba. El método prueba() declarado en SuperClaseDePrueba puede lanzar ExcepcionB, ExcepcionA o no lanzar ninguna excepción. Asuma que el método prueba() está sobrescrito en SubClaseDePrueba. Si el método prueba() declarado en SuperClaseDePrueba lanza la ExcepcionA: entonces el método sobrescrito en SubClaseDePrueba puede lanzar ExcepccionA, ExcepcionB o no lanzar ninguna excepción; esto se debe a que el método que sobrescribe sólo puede lanzar la excepción lanzada por el método en la superclase o una subclase de la excepción, o en última instancia, no lanzar ninguna excepción. Esto se muestra en la Figura 2.3.

Libro 2: Core Java


Core Java


Figura 2.3: Herencia y la Cláusula throws

Un método puede capturar una excepción específica, manejarla y lanzar la misma excepción de nuevo desde el bloque catch. Aún en tal caso, se requiere que el método especifique la excepción usando la cláusula throws. La Figura 2.4 muestra un método algunMetodo() que captura AlgunaExcepcion usando un bloque catch, maneja la excepción y relanza AlgunaExcepcion desde el bloque catch. Aquí, algunMetodo() especifica AlgunaExcepcion en su declaración.

Figura 2.4: Especificando Excepciones que son Relanzadas





Core Java

En la sección anterior se vio como la cláusula throws se puede usar para manejar excepciones definidas por el usuario. Antes de seguir examinando la definición de excepciones en clases definidas por el usuario, se presenta una breve discusión sobre usar clases excepción en Java con un ejemplo. Recuerde que todas las excepciones son subclases de la clase Throwable. Existen algunas cosas que se deben tener en cuenta cuando se usa la jerarquía de excepciones. Considere el Ejemplo 2.7.

Ejemplo 2.7 Escriba un programa que usa la jerarquía de excepciones, para entender los aspectos involucrados en esto.

El código Java comienza aquí… 1. /*Definicion de la clase MiBaseExcepcion comienza aqui*/ 2. class MiBaseExcepcion extends Exception{ 3.


4.

public MiBaseExcepcion() {

5. 6.

super(); }/* Constructor MiBaseExcepcion termina aqui */

7. 8.


9.

public MiBaseExcepcion(String s) {

10. 11.

super(s); }/* Constructor MiBaseExcepcion termina aqui */

12. }/* Definicion de la clase MiBaseExcepcion termina aqui */ 13. 14. /*Definicion de la clase MiSubExcepcion comienza aqui*/ 15. class MiSubExcepcion extends MiBaseExcepcion{ 16.


17.

public MiSubExcepcion() {

18. 19.

super(); }/* Constructor MiSubExcepcion termina aqui */

20. 21.


22.

public MiSubExcepcion(String s) {

23. 24.

super(s); }/* Constructor MiSubExcepcion termina aqui */

25. }/* Definicion de la clase MiSubExcepcion termina aqui */

Libro 2: Core Java


Core Java


26. 27. /*Definicion de la clase ExcepcionEjemplo comienza aqui*/ 28. public class ExcepcionEjemplo { 29.

/* Metodo metodo1 comienza aqui */

30.

public static void metodo1(int i) {

31.

try {

32. 33.

metodo2(i); } catch (MiBaseExcepcion e) {

34.

System.out.print("MiBaseExcepcion: ");

35.

System.out.println(e.getMessage());

36.

System.out.println("Manejado en el metodo1");

37. 38.

} }/* Metodo metodo1 termina aqui */

39. 40.


41.

public static void metodo2(int i)

42.

throws MiBaseExcepcion {

43. 44.

int resultado;

45.

try {

46.

System.out.println("i = " + i);

47.

resultado = metodo3(i);

48.

System.out.print("metodo3(i) = " + resultado);

49.

} catch (MiSubExcepcion e) {

50.

System.out.print("MiSubExcepcion: ");

51.

System.out.println(e.getMessage());

52.

System.out.println("Manejado en el metodo2");

53.

} finally {

54. 55. 56.

System.out.print("\n"); } }/* Metodo metodo2 termina aqui */

57. 58.


59.

public static int metodo3(int i)

60.

throws MiBaseExcepcion, MiSubExcepcion {

61. 62.

if (i < 0)




Guía del Estudiante 63. 64.

throw new MiBaseExcepcion("El valor es muy bajo"); else if (i > 99)

65. 66.

throw new MiSubExcepcion("El valor es muy alto"); else

67. 68.

Core Java

return i + i; }/* Metodo metodo3 termina aqui */

69. 70.


71.


72.

try {

73.

metodo1(99);

74.

} catch (Exception

75.

e) {}


76. }/* Definicion de la clase ExcepcionEjemplo termina aqui */

El código Java termina aquí En el programa anterior, MiBaseExcepcion define dos constructores – una que no toma parámetros, y otro que toma un parámetro de tipo String. La excepción MiSubExcepcion que es subclase de MiBaseExcepcion sobrescribe los dos constructores de MiBaseExcepcion. La clase ExcepcionEjemplo define tres métodos: metodo1(), metodo2() y metodo3(). metodo1() invoca a metodo2() que a su vez invoca a metodo3(). dos excepciones, llamadas, y metodo3() lanza MiBaseExcepcion MiSubExcepcion. La excepción MiSubExcepcion, que es lanzada por metodo3(), es manejada por metodo2(). La excepción MiBaseExcepcion que es lanzada por metodo3() se pasa a metodo2(), que a su vez la pasa a metodo1(), que finalmente maneja la excepción. Si

metodo2() manejara MiBaseExcepcion, entonces manejaría ambas MiBaseExcepcion y MiSubExcepcion cuando metodo3() lance estas excepciones. En este caso las excepciones no se pasarán a metodo1().

Fin del Ejemplo 2.7

Libro 2: Core Java


Core Java


Resumen Ahora que ha completado esta unidad, usted será capaz de: •

•

•

•

Mencionar las excepciones estándar en Java. Describir el uso de la jerarquía de excepciones. Explicar como sobrescribir métodos que lanzan excepciones. Crear excepciones definidas por el usuario.





Core Java

Unidad 2: Examen de Autoevaluación 1) ¿Cuál de las siguientes no son excepciones del tiempo de ejecución (runtime exceptions? a) Excepciones no verificadas. b) Excepciones definidas por el usuario. c) Excepciones verificadas. d) Ninguna de las anteriores. 2) La cláusula try/catch debe intentar ____________________. a) Capturar primero la excepción más genérica. b) Capturar primero la excepción menos genérica. c) Capturar las excepciones en cualquier orden, pero capturarlas todas. d) Ninguna de las anteriores. 3) Si hay un System.exit(0); dentro de un bloque try-catch entonces____________. a) Las sentencias dentro del finally todavía serán ejecutadas. b) El programador puede especificar si las sentencias en el finally deben ser ejecutadas. c) Es un error, dado que no se puede colocar esta sentencia allí. d) Las sentencias dentro del finally no serán ejecutadas. 4) Un método que sobrescribe en una subclase puede lanzar solo excepciones declaradas en su clase padre o hijas de las excepciones declaradas en su clase padre. ¿Cuándo es verdadero esto? a) Cuando existen métodos sobrescritos o métodos sobrecargados. b) Cuando sólo son métodos sobrescritos y no métodos sobrecargados. c) Cuando el programador establece explícitamente que el compilador ignore el error potencial. d) Ninguna de las anteriores. 5) ¿Cuál de las siguientes es una declaración correcta para una clase excepción definida por el usuario? a) class A extends B {…} b) class A extends B implements Exception {…} c) class A extends Exception {…} d) class A extends Exception implements B {…}

Libro 2: Core Java


Core Java


6) ¿Qué indica la cláusula throws de un método a los programadores cliente? a) Las excepciones que no han sido tomadas en cuenta. b) Las excepciones con las que deberá tratar cuando invoque al método. c) Las excepciones que puede ignorar cuando invoque al método. d) Ninguna de las anteriores. 7) Un método puede capturar una excepción específica, manejarla y lanzar la misma excepción de nuevo desde el bloque catch. a) Verdadero b) Falso 8) ¿Cuál es el primer paso para crear una excepción definida por el usuario? a) Declarar una clase, crear una subclase de esa clase, que implemente una clase Exception. b) Declarar una clase Exception. c) Declarar el constructor de la clase Exception. d) Declarar una clase que sea subclase de la clase Exception. 9) Un bloque try-catch debe siempre estar seguido por una cláusula finally. a) Verdadero b) Falso 10) La cláusula throws está disponible para indicar que un método puede actualmente lanzar una excepción. a) Verdadero b) Falso





Core Java


c b d b cyd b a d b a

Libro 2: Core Java



Core Java

Unidad 3: Laboratorio de Lanzamiento y Manejo de Excepciones Objetivos de Aprendizaje •

•

•

Manejar excepciones. Usar las cláusulas throw y match. Escribir excepciones definidas por el usuario.

Libro 2: Core Java

Volumen 3: Manejo de Excepciones 55 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


Ejercicios de Laboratorio 1) Escriba un programa en Java que tenga una clase abstracta llamada Cuenta. Esta clase debe tener los siguientes miembros: private int id; private float saldo; abstract void depositar(float monto) throws MontoAnormalException; abstract void retirar(float monto) throws MontoInsuficienteException;

El

programa

debe tener también dos clases concretas llamadas CuentaCorriente y CuentaAhorro que son subclases de la clase Cuenta. Los objetos de la clase CuentaCorriente pueden llegar a tener el saldo negativo luego de un retiro, al contrario de los objetos de la clase CuentaAhorro que no pueden llegar a tener saldo negativo. Las clases MontoAnormalException y MontoInsuficienteException son clases excepciones que deben ser manejadas en el programa. Debe escribir una clase Principal que permita crear instancias de CuentaCorriente y CuentaAhorro para verificar el manejo correcto de las excepciones.

Recomendaciones Útiles: •

•

•

•

•

•

Escriba una clase llamada Cuenta que defina los miembros mencionados y métodos que permitan acceder a las variables private (geter y seter). El método depositar() acepta un dato float que representa el monto que se desea depositar en la cuenta. Este método lanza MontoAnormalException como advertencia cuando el monto a depositar excede los 10 millones de Bs. El método retirar() acepta una dato float que representa el monto que se desea retirar de la cuenta. Este método lanza MontoInsuficienteException cuando el monto a retirar es mayor al saldo disponible en la cuenta. Crear dos clases excepciones llamadas MontoInsuficienteException y MontoAnormalException que tengan mensajes acordes con el evento sucedido. Crear dos subclases de Cuenta llamadas CuentaCorriente y CuentaAhorro. Estas clases deben ser concretas, para esto deben implementar los métodos abstractos de su superclase. La clase CuentaCorriente debe permitir crear instancias de ella en donde sea posible tener saldos negativos sin lanzar ninguna excepción.

Unidad 3: Laboratorio de Lanzamiento y Manejo de Excepciones



Guía del Estudiante •

•

Core Java

La clase CuentaAhorro debe permitir crear instancias de ella en donde no sea posible tener saldos negativos, cuando se intente retirar algún monto mayor al saldo disponible debe lanzar MontoInsuficienteException. Crear una clase llamada Principal que tenga el método main y en el cual se creen instancias de CuentaAhorro y CuentaCorriente para verificar el manejo correcto de las excepciones.

2) Escriba un programa en Java que tenga una clase llamada Autentica. Esta clase tiene los nombres de usuario y sus correspondientes palabras claves guardadas en arreglos String (declarados private). También tiene una variable boolean, accesoPermitido, cuyo valor por defecto es false. Existe un método llamado chequearClave() que verifica la palabra clave ingresada contra el nombre de usuario. Si la palabra clave ingresada es correcta, entonces imprime “Autenticación Verificada. Acceso al Usuario Permitido” en la salida estándar cambia el valor de accesoPermitido a true. Si la palabra clave ingresada es incorrecta entonces accesoPermitido se hace false y se lanza una excepción llamada PropiedadPrivadaExcepcion. PropiedadPrivadaExcepcion es una excepción definida por el usuario. La clase Usuario instancia la clase Autentica, e invoca al método chequearClave()para validar la palabra clave a fin de obtener acceso a DatoSecreto. Los datos en la clase DatoSecreto solo puede ser accedidos cuando accesoPermitido de Autentica es true, de otra forma se lanza una excepción AlertaDeIntrusoExcepcion, también definida por el usuario. PropiedadPrivadaExcepcion Ambas excepciones y AlertaDeIntrusoExcepcion tienen información que puede ser usada por Usuario cuando son capturadas.


•

•

•

•

•

Escriba

llamadas PropiedadPrivadaExcepcion y AlertaDeIntrusoExcepcion que extiendan de la clase Exception. Escriba una clase llamada DatoSecreto que tenga una variable private y métodos para obtener y asignar valor a la variable private. Escriba una clase Autentica y dentro de ella, declare dos arreglos de String que sean inicializadas con nombres de usuario y sus correspondientes palabras clave. Declare una variable boolean, accesoPermitido inicializada en false. Defina un método, chequearClave que revise si un nombre de usuario y palabra clave recibidos concuerdan con los del arreglo de String. Escriba una clase, Usuario que acepte un nombre de usuario y una palabra clave y use el método chequearClave para autenticar al usuario.

Libro 2: Core Java

clases

excepción

Volumen 3: Manejo de Excepciones 57 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java •

•

•


Si el método chequearClave retorna true, entonces se imprime “Autenticación verificada. Acceso al Usuario Permitido” en la salida estándar y a la variable accesoPermitido se le asigna true. Si el método chequearClave retorna false, la excepción PropiedadPrivadaExcepcion es lanzada. Si

la

variable

private

es accesoPermitido AlertaDeIntrusoExcepcion 3)

en

DatoSecreto se se lanza false,

accede cuando la excepción

Escriba un programa en Java que invierta una cadena dada. Si la cadena original y la cadena invertida son iguales, entonces lanza una excepción Palindrome, que es una excepción definida por el usuario.


•

•

•

•

•

Escriba una clase llamada PalindromeExcepcion que extiende de la clase Exception. Escriba una clase CadenaInvertida que tenga una variable String inicializada con un valor string. Forme un arreglo de caracteres de la variable String Invierta el arreglo de caracteres y forme un String del arreglo invertido. Compare la variable String inicial y la variable String obtenida de invertir el arreglo de caracteres usando el método equals(). Si el método equals() retorna true, imprimir “Es palíndrome” en la salida estándar, sino lanzar PalindromeExcepcion.

Unidad 3: Laboratorio de Lanzamiento y Manejo de Excepciones




Core Java

Volumen 4: Facilidades de Entrada / Salida

Libro 2: Core Java

Volumen 4: Facilidades de Entrada / Salida 59 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.


Core Java

Unidad 1: Archivos y Flujos Objetivos de Aprendizaje Al final de esta unidad, usted será capaz de: •

•

•

•

•

•

Entender la clase File. Describir FileDescriptor. Conocer acerca de los flujos. Explicar los diferentes tipos de flujos de caracteres. Explicar los diferentes tipos de flujos de bytes. Mencionar la forma de trabajo con archivos de acceso aleatorio.

Libro 2: Core Java

Unidad 1: Archivos y Flujos 61 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


1. Introducción Esta unidad se ocupa de la entrada y salida en Java. La mayoría de las aplicaciones requieren de datos que sean leídos de una fuente externa o datos que sean almacenados en una fuente externa. Los archivos se usan para almacenar, leer y escribir datos. Para hacer esto, primero se debe acceder a los archivos, la unidad trata con dos categorías de clases, que están relacionadas con archivos: •

•

Archivos. Flujos.

Las clases relativas a los archivos trabajan con el sistema de archivos en la computadora. Los flujos, por otra parte, ayudan en funciones relativas a archivos como leer del archivo, escribir datos al archivo, leer y escribir datos sobre la red, etc. Imagine un flujo como un tubo donde es posible leer o escribir bytes y/o caracteres. No importa lo que pueda haber en el otro extremo del tubo: puede ser un teclado, un monitor, un archivo, un proceso, una conexión TCP/IP o un objeto Java. Todas las clases que manejan la entrada y salida de datos están disponibles en el paquete java.io. La Figura 1.1 da una visión general de algunas de las clases disponibles en el paquete java.io.

Unidad 1: Archivos y Flujos




Core Java

Figura 1.1: Clases para Entrada/Salida en el Paquete java.io

De la Figura 1.1, se puede notar lo siguiente: •

File, FileDescriptor, RandomAccessFile, ObjectStream, OutputStream, Reader y Writer derivan de la clase Object.

Libro 2: Core Java

InputStream,


Core Java •


Las clases clases InputStream, OutputStream, Reader y Writer tienen clases derivadas para realizar actividades específicas de entrada/salida.

Se estudiarán algunas de las clases de la figura en esta unidad, se comienza el tema con entrada/salida usando archivos.

2. Archivos Java provee soporte a archivos usando tres clases, llamadas, File, FileDescriptor y RandomAccessFile para usar el sistema de archivos en una computadora. A continuación se explicará primero la clase File.

2.1 La Clase File Los archivos son un mecanismo usado para almacenar información. Existen varias categorías de archivos, dependiendo del tipo de información que es almacenada y el sistema de archivos que se usa depende del sistema de operación usado en la computadora. Una categoría particular de archivos puede, típicamente, ser almacenada bajo un nombre de directorio. El nombre de directorio es un identificador que se usa para localizar una categoría en particular. Todos los archivos, por ejemplo, relacionados a un proyecto en particular pueden almacenarse bajo un directorio llamado proyecto. Se puede tener una jerarquía de directorios para almacenar varias categorías de archivos. Java permite acceder a los archivos almacenados en el sistema de archivos local usando la clase File, que es una representación abstracta de los archivos y directorios disponibles en el sistema de archivos local. Esta representación abstracta es independiente del sistema de operación o del hardware en el cual la JVM se está ejecutando. Los objetos de la clase File son inmutables, en otras palabras, una vez que se crea un objeto File para representar una ruta particular, no se puede modificar para apuntar a otra ruta, sólo es posible asignarle una instancia diferente de la clase File. La clase File extiende de la clase Object e implementa las siguientes interfaces: Serializable Comparable

•

•

Como File implementa la interfaz Serializable, sus objetos pueden ser serializados y deserealizados. (Refiérase a la Unidad 3 – Serialización de Objetos de este volumen para información detallada acerca de la serialización/deserealización). File también implementa la interfaz Comparable y por esto se pueden comparar dos rutas de objetos File usando el método compareTo() .





Core Java

A continuación se escribe un programa simple en Java que ilustrará como crear un objeto de la clase File y mostrará algunos datos acerca del archivo abierto, usando la clase File.

Ejemplo 1.1 El código Java comienza aquí... 1.

import java.io.File;

2. 3. /*Definicion de la clase DetalleArchivo comienza aqui*/ 4. public class DetalleArchivo { 5.


6.


7.

File a = new File("/home/stud File("/home/student1/ejemplo.txt ent1/ejemplo.txt"); ");

8.

if (a.exists()) {

9.

System.out.println("* System.out.println("* * * Datos del Archivo * * *");

10.

System.out.println("Nombre: System.out.println("Nombre: " + a.getName());

11.

System.out.println("Ruta System.out.println("Ruta Completa: " + a.getPath());

12.

System.out.println("Directorio System.out.println("Directorio Padre: " + a.getParent());

13.

System.out.println("Tamano System.out.println("Tamano (en Bytes): " + a.length());

14.

} else {

15.

System.out.println(

16.

"Archivo: " +

17.

a.getName() +

18.

" no existe");

19. 20.


21. }/* Definicion de la clase DetalleArchivo termina aqui */

El código Java termina aquí La salida del programa será la siguiente: * * * Datos del Archivo * * * Nombre: ejemplo.txt Ruta Completa: /home/student1/ejemplo.txt Directorio Padre: /home/student1 Tamano (en Bytes): 16

Nota: El objeto File es una abstracción de los archivos en el sistema. La creación de un objeto File no creará ningún archivo en el sistema de archivos. Libro 2: Core Java


Core Java


Fin del Ejemplo 1.1 A continuación se discuten los separadores separadores de archivos en la ruta de archivos.

2.2 Separadores de Archivos Los separadores de archivos son aquellos que separan los subdirectorios en la ruta. Windows usa una barra invertida ‘\’ para separar los subdirectorios, en cambio UNIX usa una barra ‘/’ para separar los directorios. Como resultado, las rutas de archivos lucen diferentes en cada sistema de operación. Por ejemplo, en el Ejemplo 1.1, se usó la siguiente línea de código: File a = new File("/home/student1/ejemplo.txt"). Para evitar el problema de los separadores y el sistema operativo, se puede usar File.separator, que usa el separador por omisión del sistema de operación en el cual el programa se está ejecutando. El código anterior modificado con File.separator se da a continuación: File a = new File(File.separator+"home"+ File(File.separator+"home"+ File.separator+"student1"+ File.separator+" student1"+ File.separator+" File.separator+"ejemplo.txt"); ejemplo.txt");

Este código puede ser usado en ambos Windows y UNIX. Ahora, se verán los descriptores de archivo. archivo.

2.3 La Clase FileDescriptor Esta clase se usa para manejar flujos de entrada, salida y error específicos para la máquina dentro de un programa Java. Esta clase tiene variables estáticas como manejadores para los siguientes tres flujos: •

•

•

FileDescriptor.in FileDescriptor.out FileDescriptor.err

- Maneja el flujo de entrada - Maneja el flujo de salida - Maneja el flujo de error

Típicamente, las aplicaciones no crean descriptores de archivo. FileDescriptor extiende de la clase Object. Los objetos FileInputStream, FileOutputStream, FileWriter y FileReader pueden ser creados usando el objeto FileDescriptor como argumento. El siguiente fragmento de código muestra como un objeto FileWriter se crea usando un objeto FileDescriptor. La clase FileWriter será discutida en una sección posterior. El código a continuación se usa simplemente para mostrar el uso de la clase FileDescriptor.

Ejemplo 1.2 El código Java comienza aquí… 22. import java.io.FileDescriptor; java.io.FileDescriptor;





Core Java

23. import java.io.FileWriter; 24. 25. /*Definicion de la clase FileDescriptorEjemplo comienza aqui*/ 26. public class FileDescriptorEjemplo { 27.


28.


29.

try {

30.

FileDescriptor fd = FileDescriptor.out;

31.

FileWriter fw = new FileWriter(fd);

32.

fw.write("Hola mundo!");

33.

fw.close();

34.

} catch (Exception e) {

35. 36. 37.

e.printStackTrace(); } }/* Metodo main termina aqui */

38. }/*Definicion de la clase FileDescriptorEjemplo termina aqui*/

El código Java termina aquí El

objeto

fd se crea usando el manejador para el flujo de salida FileDescriptor.out. fd y se le pasa entonces a FileWriter como argumento,

durante su instanciación. Como resultado de compilar y ejecutar este programa se imprime en la consola de salida la frase Hola mundo!

Fin del Ejemplo 1.2 En esta sección se aprendió acerca de la clase FileDescriptor, ahora se continuará con archivos que son accedidos de forma aleatoria.

2.4 Archivos de Acceso Aleatorio El paquete java.io tiene la clase RandomAccessFile. El acceso aleatorio a archivos se usa para leer y escribir datos en cualquier sitio en un archivo. El acceso secuencial a archivo requiere pasar por cada línea de datos en el archivo antes de encontrar la información requerida. Tómese un ejemplo para entender el acceso de datos aleatorio. Asuma que un archivo tiene las siguientes líneas de datos: Mike, 32, California Aaron, 31, New York Jane, 32, Ohio Richards, 29, Texas

Libro 2: Core Java


Core Java


John, 31, Pennsylvania

Para encontrar a Richards, que es el cuarto registro en la lista, el acceso secuencial requerirá pasar a través de los tres primeros registros. Pero usando la operación de seek en modo de acceso aleatorio, Richards puede ser encontrado sin pasar por los tres primeros registros. RandomAccessFile extiende de la clase Object e implementa las siguientes

interfaces: •

DataOutput

•

DataInput

Los argumentos que se usan cuando se instancia una clase, ayudan a decidir si el objeto será usado para lectura o escritura. La siguiente línea de código crea un RandomAccessFile que se usa para leer del archivo entrada.txt. new RandomAccessFile("entrada.txt" RandomAccessFile("entrada.txt", , "r");

La siguiente línea crea una clase RandomAccessFile que se usa para lectura y escritura en el archivo salida.txt: new RandomAccessFile("salida.txt", RandomAccessFile("salida.txt", "rw");

El ”r” y ”rw” indican el modo de apertura del archivo de acceso aleatorio. Aquí ‘ r’ denota sólo lectura, y ‘ rw’ denota lectura-escritura. La clase RandomAccessFile provee soporte para el concepto de apuntador a archivo para indicar la ubicación actual en el archivo. En el momento de creación del archivo, el puntero de archivo se establece en 0, lo que indica el inicio del archivo. Luego el número de bytes que son leídos o escritos mueve el apuntador del archivo. Esta manipulación del apuntador a archivo se lleva a cabo en esta clase, usando los siguientes tres métodos: skipBytes(), seek() y getFilePointer(). El método skipBytes() mueve el apuntador de archivo hacia adelante el número de bytes especificado. El método seek() posiciona el apuntador de archivo exactamente antes del byte especificado. El método getFilePointer() permite obtener la ubicación actual del apuntador a archivo. En caso de que el fin de archivo se alcance antes de leer el número de bytes especificado, entonces se lanza una EOFException y en caso de no leer o escribir un byte, entonces se lanza una IOException. Una IOException puede ser lanzada también cuando un flujo está cerrado.

Ejemplo 1.3 Este programa ilustra como leer y escribir datos a un archivo de acceso aleatorio.





Core Java



2. import java.io.FileNotFoundException; java.io.FileNotFoundException; 3. import java.io.IOException; java.io.IOException; 4. import java.io.RandomAccessFile; java.io.RandomAccessFile; 5. 6. /*Definicion de la clase comienza aqui*/ 7. public class RandomAccessFileEjemplo { 8.

final static int POSICION_CARACTER = 2;

9.

static String nombreArchivo = "aleatorio.txt";

10. 11.


12.

public static void main(String args[]) {

13.

try {

14.

RandomAccessFileEjemplo RandomAccessFile Ejemplo aleatorio;

15.

aleatorio = new RandomAccessFileEjemplo(); RandomAccessFileEjemplo();

16.

aleatorio.escribirAlfabeto();

17.

aleatorio.leerAlfabeto();

18.


19. 20. 21.

System.out.println(e); } }/* Metodo main termina aqui */

22. 23.

/* Metodo leerAlfabeto comienza aqui */

24.

public void leerAlfabeto() throws IOException {

25.

try {

26.

File archivo = new File(nombreArchivo);

27.

RandomAccessFile raf;

28.

raf = new RandomAccessFile(archivo, RandomAccessFile(archivo, "r");

29.

System.out.println(

30.

"\nAlfabeto desde el archivo " +

31.

nombreArchivo);

32.

long longitud = raf.length();

33.

for (int i = POSICION_CARACTER; POSICION_CARACTER;

34.

i < longitud;

35.

i += 2 * POSICION_CARACTER) {

36.

Libro 2: Core Java


Core Java


37.

raf.seek(i);

38.

System.out.println(raf.readChar());

39.

}// Fin del ciclo for

40.

raf.close();

41.

} catch (FileNotFoundException e) {

42.

System.out.println("No System.out.print ln("No se encuentra el archivo");

43.

System.exit(0);

44.

} catch (IOException e) {

45.

System.out.println(e);

46.

}

47.

} /* Metodo leerAlfabeto termina aqui */

48. 49.

/* Metodo escribirAlfabeto comienza aqui */

50.

public void escribirAlfabeto() throws IOException {

51.

File archivo = new File(nombreArchivo);

52.

RandomAccessFile raf;

53.

raf = new RandomAccessFile(archivo, RandomAccessFile(archivo, "rw");

54.

System.out.println(

55.

"Los datos a escribir en el archivo " +

56.

nombreArchivo + " son:");

57.

for (int i = 65; i < 91; i++) {

58.

raf.writeChar(i);

59.

System.out.print((char) System.out.print ((char) i + " ");

60.

}// Fin del ciclo for

61.

System.out.println();

62.

raf.close();

63.

}/* Metodo escribirAlfabeto termina aqui */

64. }/* Definicion de la clase termina aquí */

El código Java termina aquí La salida del programa anterior es como sigue: Los datos a escribir en el archivo aleatorio.txt son: 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 Alfabeto desde el archivo aleatorio.txt B D





Core Java

F H J L N P R T V X Z

Fin del Ejemplo 1.3 En este programa, el archivo aleatorio.txt tiene las letras de la A a la Z. RandomAccessFile se usa para acceder en forma no secuencial cada segundo carácter almacenado en el archivo e imprimir en la salida estándar, sin pasar por cada carácter en forma secuencial. Ahora que se sabe como trabajar con archivos en Java, se explican los flujos y como se manejan en Java.

3. Flujos La entrada/salida en Java está basada en flujos. Java trata toda la información, independientemente de la fuente o el destino, como flujos. Los datos que son leídos y escritos en un programa Java son tratados como un flujo de datos, bytes continuos de datos que vienen y van. Estos bytes son leídos o escritos a archivos, conectores o conexiones en Internet. Los flujos son independientes del dispositivo. Un flujo en Java es cualquier ruta de información desde la fuente al destino. Los siguientes son algunos pares de fuentes y destinos: •

•

•

•

•

•

Un teclado (fuente) y un monitor (destino). Una página de texto en un monitor (fuente) y un archivo en un disco duro (destino). Un archivo en un disco duro (fuente) y un monitor (destino). Un servidor web (fuente) y un navegador (destino). Un teclado (fuente) y una cadena de caracteres (destino). Un archivo de texto (fuente) y una impresora (destino).

Libro 2: Core Java


Core Java


El procesamiento de flujos en Java está bien abstraído e igualmente bien entendido. Esto hace a Java un lenguaje ideal para comunicaciones en red, porque incluye transferencias de datos desde la fuente hasta el destino. Considere la Figura 1.2, que ilustra el concepto de flujos en Java.

Figura 1.2: Flujos en Java

La lectura del o escritura al flujo en Java es igual a leer o escribir a un archivo en lenguajes como C o C++. Los pasos para realizar estas operaciones son los mismos que en C o C++. El algoritmo básico para leer usando un flujo se da a continuación:

Paso 1: Abrir un flujo de la fuente de datos en el programa Java. Paso 2: Mientras haya datos disponibles en la fuente de datos, leerlos.

Paso 3: Cerrar el flujo. El algoritmo básico para escribir usando un flujo se da a continuación:

Paso 1: Abrir el flujo a destino de los datos en el programa Java.





Core Java

Paso 2: Mientras haya datos disponibles en el programa Java, escribirlos.

Paso 3: Cerrar el flujo. Ambos algoritmos dan los tres pasos básicos requeridos para lectura y escritura usando flujos. Así, cualquiera sea los tipos de datos leídos o escritos, será fácil para los programadores usar clases de entrada/salida de Java. Los flujos en Java están bien organizados y se clasifican en los siguientes dos grupos: •

•

Flujos de Byte. Flujos de Carácter.

Estos dos tipos de flujos permiten acceder datos de una manera secuencial. Los flujos de byte se usan para transferir 8-bits de datos, mientras que los flujos de caracteres trabajan con caracteres de 16-bit Unicode. Los flujos de byte son representados en Java con las clases: •

•

InputStream. OutputStream.

Los flujos de caracteres son representados con las clases: •

•

Reader. Writer.

Java considera un enfoque internacional para los caracteres; se usan dos bytes para representar un carácter. Las clases InputStream y OutputStream no pueden procesar caracteres Unicode de una forma eficiente, para esto fueron creadas las clases Reader y Writer en Java. La Figura 1.3 muestra los flujos de byte y de carácter en Java.

Figura 1.3: Flujos de Byte y Flujos de Carácter Libro 2: Core Java


Core Java


A continuación se estudian cada una de estas cuatro clases, llamadas, InputStream, OutputStream, Reader y Writer, en detalle.

4. La Clase InputStream La clase InputStream es una clase abstracta que permite leer bytes (8-bit) de datos. Esta clase extiende de la clase Object. Las clases que heredan de InputStream deben implementar un método que retorne el próximo byte de datos del flujo que se está leyendo. Las subclases de la clase InputStream se muestran en la Figura 1.4.

Figura 1.4: La Clase InputStream y sus Subclases

Se discutirá acerca de ObjectInputStream en la Unidad 3 – Serialización de Objetos, la cual se usa para de-serializar objetos durante la serialización de objetos. Todas las otras clases serán discutidas en esta unidad. Se comenzará con ByteArrayInputStream.

4.1 La Clase ByteArrayInputStream La clase ByteArrayInputStream es una de las subclases de InputStream. Se ha mencionado que si una clase es subclase de la clase InputStream, tiene que implementar un método para devolver el próximo byte de la entrada del flujo que se está leyendo. La clase ByteArrayInputStream provee este método al tener un buffer interno de datos y un contador que representa el próximo byte en el buffer. El ejemplo a continuación muestra la clase ByteArrayInputStream. Unidad 1: Archivos y Flujos




Core Java

Ejemplo 1.4 El ejemplo ilustra la lectura en un string que el usuario introduce y se muestra el string usando un objeto ByteArrayInputStream.


import java.io.ByteArrayInputStream;

2. 3. /*Definicion de la clase comienza aqui*/ 4. public class ByteArrayInputStreamEjemplo { 5.


6.


7.

String frase = "Hola mundo!";

8. 9.

/* Declaracion arreglo de byte */

10.

byte arregloBytes[] = frase.getBytes();

11. 12.

/* Crear una instancia de ByteArrayInputStream */

13.

ByteArrayInputStream bais;

14.

bais = new ByteArrayInputStream(arregloBytes);

15. 16.

System.out.println("ByteArrayInputStream obtuvo: ");

17.

int caracterLeido;

18.

Character caracter = null;

19. 20.

/* Leer de ByteArrayInputStream

21.

y mostrar en mayuscula */

22.

while ((caracterLeido = bais.read()) != -1){

23.

caracter = Character.toUpperCase((char) caracterLeido);

24.

System.out.print(caracter);

25.

}

26.

bais.reset();

27.



El código Java termina aquí La salida del programa anterior es como sigue: ByteArrayInputStream obtuvo:

Libro 2: Core Java


Core Java


HOLA MUNDO!

Fin del Ejemplo 1.4 El programa del Ejemplo 1.4 toma el string hola mundo! como entrada, y lo lee usando el ByteArrayInputStream y se imprime en la salida estándar usando letras mayúsculas. La próxima clase que se estudia es la FileInputStream.

4.2 La Clase FileInputStream La clase FileInputStream se usa para leer el contenido de un archivo en forma de bytes. Los tipos de archivos que están disponibles dependen del sistema de archivos usado por el sistema de operación subyacente. La clase FileInputStream extiende de InputStream. Considere el ejemplo 1.5, que muestra el uso de la clase FileInputStream.


import java.io.FileInputStream;

2. import java.io.FileNotFoundException; 3. import java.io.InputStream; 4. 5. /*Definicion de la clase comienza aqui*/ 6. public class FileInputStreamEjemplo { 7.


8.


9.

try {

10.

int cantidad;

11.

String nombreArchivo = "miArchivo.txt";

12.

InputStream ie;

13.

ie = new FileInputStream(nombreArchivo);

14.

cantidad = ie.available();

15.

System.out.println(

16.

"Leyendo desde el archivo: " +

17.

nombreArchivo);

18. 19.

System.out.println( "Total bytes disponibles: " +





Core Java cantidad + "\n");

21. 22.

/* Mostrar los datos de byte

23.

disponible a la salida estandar */

24.

for (int i = 0; i < cantidad; i++) {

25.

System.out.print((char) ie.read());

26.

}

27. 28.

/* Cerrar el InputStream */

29.

ie.close();

30.


31.

System.out.println("Archivo no encontrado");

32.

System.exit(0);

33.


34.


35.

} // Fin del bloque Exception

36.



El código Java termina aquí El contenido de miArchivo.txt es el siguiente: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

La salida del programa anterior es la siguiente: Leyendo desde el archivo: miArchivo.txt Total bytes disponibles: 121 El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Fin del Ejemplo 1.5 En el programa anterior, se leen bytes de datos del archivo miArchivo.txt, usando FileInputStream y se imprimen en la salida estándar.

Libro 2: Core Java


Core Java


4.3 La Clase FilterInputStream FilterInputStream ,

como el nombre sugiere, se usa para trabajar en el flujo de entrada, manipulando los datos de entrada basado en ciertos filtros (condiciones) definidas por el usuario. La clase FilterInputStream extiende de InputStream. La condición del filtro puede estar basada en varias condiciones, como leer sólo caracteres ASCII o leer los caracteres de un rango específico, etc. FilterInputStream se ilustra en el Ejemplo 1.5.

Ejemplo 1.6 El ejemplo muestra la creación de un objeto FilterInputStream y su uso.



2. import java.io.FilterInputStream; 3. import java.io.IOException; 4. import java.io.InputStream; 5. 6. /*Definicion de la clase comienza aqui*/ 7. public class FilterInputStreamEjemplo 8.

extends FilterInputStream {

9. 10.

/* Constructor FilterInputStreamEjemplo comienza aqui */

11.

protected FilterInputStreamEjemplo(InputStream in) {

12. 13.

super(in); }/* Constructor FilterInputStreamEjemplo termina aqui */

14. 15.

/* Metodo read comienza aqui */

16.

public int read() throws IOException {

17.

int valor = in.read();

18. 19.

/* Imprimir Alfabeto */

20.

if ((valor >= 'A' && valor <= 'Z') ||

21.

(valor >= 'a' && valor <= 'z'))

22. 23.

return valor;

24. 25.

/* Retorno de carro, nueva linea,





Core Java

tab, y fin de archivo */ else if (valor == 10 || valor == 13 ||

28.

valor == 9 || valor == -1)

29. 30.

return valor;

31. 32.

/* Caracteres no imprimibles */

33.

else

34. 35.

return '?'; } /* Metodo read termina aqui */

36. 37.

/* Metodo read sobrecargado comienza aqui */

38.

public int read(byte[] datos, int inicio, int maximo)

39.

throws IOException {

40. 41.

int resultado = in.read(datos, inicio, maximo);

42.

for (int i = inicio; i < inicio + resultado; i++) {

43. 44.

/* No hacer nada con los caracteres

45.

retorno de carro, nueva linea,

46.

tab, y fin de archivo */

47.

if (datos[i] == 10 || datos[i] == 13 ||

48.

datos[i] == 9

49.

;

|| datos[i] == -1)

50. 51.

/* Caracteres no imprimibles */

52.

else if (datos[i] < 32 || datos[i] > 126)

53. 54.

datos[i] = (byte) '?'; }

55. 56. 57.

return resultado; } /* Metodo read sobrecargado termina aqui */

58. 59.


60.

public static void main(String[] args)

61.

throws IOException{

62.

Libro 2: Core Java


Core Java 63.

Guía del Estudiante for (int i = 0; i < args.length; i++) {

64.

FilterInputStreamEjemplo fise;

65. 66.

fise = new FilterInputStreamEjemplo(

67.

new FileInputStream(args[i])

68.

);

69. 70.

while (true) {

71.

int c = fise.read();

72.

if (c == -1)

73.

break;

74.

System.out.print((char) c);

75. 76. 77.

} } }/* Metodo main termina aqui */


El código Java termina aquí Este programa filtra el flujo de entrada para permitir solo letras. El archivo palabras.txt que se pasa como argumento por la línea de comandos tiene el siguiente contenido: Bienvenido a IBM, este programa ilustra el uso de FileInputStream

Al introducir el siguiente comando: java FilterInputStreamEjemplo palabras.txt

La salida del programa será la siguiente: Bienvenido?a?IBM??este?programa?ilustra?el?uso?de?FileInpu tStream

Fin del Ejemplo 1.6 El programa del Ejemplo 1.6 lee el contenido del archivo palabras.txt carácter por carácter y los imprime en la salida estándar únicamente si son letras del alfabeto. Si FilterInputStream lee un carácter no imprimible, el carácter es filtrado y se imprime un signo de interrogación ( ?) en la salida estándar. A continuación se explican las cuatro subclases de la clase FilterInputStream.





Core Java

4.4 La Clase BufferedInputStream La clase BufferedInputStream permite que los flujos de entrada almacenen en un buffer los bytes de datos que son leídos. Los datos leídos de los flujos usualmente no son almacenados en un buffer. Sólo cuando los datos son leídos del flujo, los próximos datos llegan al flujo. BufferedInputStream también es subclase de FilterInputStream. BufferedInputStream mantiene un arreglo que representa el buffer interno. Cuando se leen bytes del flujo, el flujo de entrada rellena el buffer interno con un número de bytes, a la vez. Esto permite lecturas más rápidas de datos, porque estos están pre-almacenados.

Ejemplo 1.7 Este programa muestra el uso de BufferedInputStream para leer datos de un archivo y cuenta la cantidad de líneas que tiene el archivo.


import java.io.BufferedInputStream;

2. import java.io.FileInputStream; 3. import java.io.IOException; 4. 5. /*Definicion de la clase comienza aqui*/ 6. public class BufferedInputStreamEjemplo { 7.


8.


9.

if (args.length != 1) {

10.

System.err.println(

11.

"uso: BufferedInputStreamEjemplo nombreArchivo");

12. 13.

System.exit(1); }

14. 15.

try {

16.

BufferedInputStream bis;

17.

bis = new BufferedInputStream(

18. 19.

new FileInputStream(args[0]) );

20.

int contador = 1;

21.

int b;

22. 23.

Libro 2: Core Java

while ((b = bis.read()) != -1) {


Core Java


24.

if (b == '\n')

25.

contador++;

26.

}

27. 28.

bis.close();

29.

System.out.println(

30.

"El archivo contiene " +

31.

contador +

32.

" lineas");

33.


34.

System.err.println(e);

35. 36.



El código Java termina aquí Suponiendo que el archivo palabras.txt tenga lo siguiente: Bienvenido a IBM

La salida del programa anterior será la siguiente: El archivo contiene 2 lineas

Fin del Ejemplo 1.7 El programa anterior acepta un nombre de archivo de la línea de comandos. Abre el archivo especificado usando BufferedInputStream, lee el contenido del archivo, byte a byte. Cuando se encuentra el carácter ‘\n’, el valor del contador de líneas es incrementado. Finalmente, muestra el total de líneas en la salida estándar.

4.5 La Clase DataInputStream Los tipos de datos primitivos usualmente tienen una representación dependiente de la máquina subyacente. La clase DataInputStream permite que una aplicación lea los tipos de datos primitivos en una forma que es independiente de la máquina. La clase DataInputStream extiende a FilterInputStream . Representa cadenas Unicode en un formato que es una modificación menor del formato UTF-8. Los detalles exactos de la representación interna de los tipos de datos primitivos en esta clase están más allá del alcance de esta discusión.

Ejemplo 1.8 Unidad 1: Archivos y Flujos




Core Java



2. import java.io.DataInputStream; 3. import java.io.FileInputStream; 4. import java.io.FileNotFoundException; 5. import java.io.IOException; 6. 7. /*Definicion de la clase comienza aqui*/ 8. public class DataInputStreamEjemplo { 9.


10.


11.

try {

12.

String nombreArchivo = "miArchivo.txt";

13.

DataInputStream in;

14. 15.

in = new DataInputStream(

16.

new BufferedInputStream(

17.

new FileInputStream(nombreArchivo)

18.

)

19.

);

20. 21.

System.out.println(

22.

"Leyendo el archivo: " +

23.

nombreArchivo +

24.

". Su contenido es: "

+ "\n");

25. 26.

/* Mientras no sea el fin del archivo */

27.

while (in.available() != 0)

28. 29.

System.out.print((char) in.readByte()); } catch (FileNotFoundException e) {

30.


31.

System.exit(0);

32.


33. 34. 35.

System.err.println("IOException"); } }/* Metodo main termina aqui */


Libro 2: Core Java


Core Java


El código Java termina aquí El contenido de miArchivo.txt es el siguiente: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

La salida del programa es la siguiente: Leyendo el archivo: miArchivo.txt. Su contenido es: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Fin del Ejemplo 1.8 En el programa anterior, un DataInputStream lee el contenido de miArchivo.txt byte por byte e imprime el byte leído en la salida estándar.

4.6 La Clase LineNumberInputStream Esta clase es ahora obsoleta (deprecated). La clase LineNumberInputStream puede ser usada si se necesita el número de la línea actual de los datos leídos. El número de la línea actual es incrementado cuando el flujo tiene el carácter de fin de línea (retorno de carro '\r', nueva línea '\n', o retorno de carro y nueva línea ‘ \r’ y ‘\n’). LineNumberInputStream extiende de FilterInputStream.

4.7 La Clase PushbackInputStream En los flujos vistos hasta ahora, una vez leídos los datos, son removidos del flujo. Con la clase PushbackInputStream, es posible que un dato que es leído del flujo sea colocado de nuevo en el flujo. Es útil cuando se leen bytes de datos que están delimitados por un byte específico, que el último byte leído pueda ser “des-leído”, de forma que la próxima operación pueda leerlo de nuevo. La clase PushbackInputStream extiende a la clase FilterInputStream.

Ejemplo 1.9





Core Java

Este programa ilustra el uso de la clase PushbackInputStream, usada con caracteres que son leídos byte por byte de un string.


import java.io.ByteArrayInputStream;

2. import java.io.IOException; 3. import java.io.PushbackInputStream; 4. 5. /*Definicion de la clase comienza aqui*/ 6. public class PushbackInputStreamEjemplo { 7.


8.


9.

try {

10.

String texto = "if (marca==75)\n" +

11. 12.

"resultado=distincion;\n"; byte arregloBytes[] = texto.getBytes();

13. 14.

/* Crear una instancia de ByteArrayInputStream */

15.

ByteArrayInputStream bais;

16.

bais = new ByteArrayInputStream(arregloBytes);

17. 18.

/* Crear una instancia de PushbackInputStream */

19.

PushbackInputStream pis;

20.

pis = new PushbackInputStream(bais);

21. 22.

int caracter;

23.

while ((caracter = pis.read()) != -1) {

24.

if (caracter == '=') {

25.

if ((caracter = pis.read()) == '=')

26.

System.out.print(".eq.");

27.

else {

28.

System.out.print("<-");

29.

pis.unread(caracter);

30. 31.

} } else {

32. 33.

Libro 2: Core Java

System.out.print((char) caracter); }


Core Java


34.

}

35.


36.


37. 38.



El código Java termina aquí La salida de este programa es la siguiente: if (marca.eq.75) resultado<-distincion;

Fin del Ejemplo 1.9 En el programa anterior, se le asigna el string " if (marca==75)\n" + "resultado=distincion;\n", a texto (línea 10). Este string se lee byte-por-byte usando PushbackInputStream y se imprime en la salida estándar. Si dos ‘ =’ son leídos subsecuentemente, entonces se imprime “ .eq.” en la salida estándar. Si un solo ‘=’ es leído, entonces se imprime “ <-” en la salida estándar y el carácter siguiente(‘d’) se coloca de nuevo en el flujo. La próxima subclase de InputStream , que se estudia es la clase PipedInputStream.

4.8 La Clase PipedInputStream Esta clase se usa típicamente para transferencia de datos entre dos hilos en un escenario multihilos. Esta clase trabaja en sincronización con PipedOutputStream. Ambas implementan los componentes de entrada y salida de una tubería. Las tuberías se utilizan para canalizar la salida de un programa (o thread) a la entrada de otro programa (o thread). Si se intenta usar ambas clases en el mismo hilo, entonces el hilo puede bloquearse. El buffer presente en PipedInputStream se usa para separar las operaciones de lectura de las operaciones de escritura dentro de sus límites. La clase PipedInputStream extiende de la clase InputStream.

4.9 La Clase SequenceInputStream Podría haber una situación cuando la salida de más de un flujo necesita ser concatenada para generar una única salida. La clase SequenceInputStream se usa para esto. La clase SequenceInputStream comienza leyendo en grupos flujos de entrada, y lee desde el primer flujo de entrada hasta alcanzar el fin de archivo, luego toma el siguiente flujo de entrada y así sucesivamente, hasta que alcanza el fin de archivo del último flujo de entrada. Unidad 1: Archivos y Flujos




Core Java

La clase SequenceInputStream extiende a la clase InputStream .

Ejemplo 1.10 El programa muestra como se puede usar

SequenceInputStream .



2. import java.io.FileNotFoundException; 3. import java.io.IOException; 4. import java.io.InputStream; 5. import java.io.SequenceInputStream; 6. import java.util.Enumeration; 7. import java.util.NoSuchElementException; 8. 9. /*Definicion de la clase Archivo comienza aqui*/ 10. class Archivo implements Enumeration { 11.

private String[] listaArchivos;

12.

private int actual = 0;

13. 14.

/* Constructor Archivo comienza aqui */

15.

public Archivo(String[] listaArchivos) {

16. 17.

this.listaArchivos = listaArchivos; }/* Constructor Archivo termina aqui */

18. 19.

/* Metodo hasMoreElements comienza aqui */

20.

public boolean hasMoreElements() {

21.

if (actual < listaArchivos.length)

22. 23.

return true; else

24. 25.

return false; }/* Metodo hasMoreElements termina aqui */

26. 27.

/* Metodo nextElement comienza aqui */

28.

public Object nextElement() {

29.

InputStream in = null;

30. 31.

if (!hasMoreElements())

Libro 2: Core Java


Core Java


32.

throw new NoSuchElementException(

33. 34.

"No mas archivos"); else {

35.

String proximoArchivo = listaArchivos[actual++];

36.

try {

37.

in = new FileInputStream(proximoArchivo);

38.


39.

System.err.println(

40.

"No se puede abrir el archivo: " +

41.

proximoArchivo);

42.

System.exit(0);

43. 44.

} }

45. 46. 47.

return in; } /* Metodo nextElement termina aqui */

48. }/* Definicion de la clase Archivo termina aqui */ 49. 50. /* Definicion de la clase comienza aqui */ 51. public class SequenceInputStreamEjemplo { 52.


53.


54.

/* Se debe ingresar dos argumentos

55. 56.

por linea de comandos */ if (args.length != 2) {

57.

System.err.println(

58.

"Uso: java SequenceInputStreamEjemplo" +

59.

"archivo1 archivo2");

60. 61.

System.exit(0); }

62. 63. 64.

try { Archivo archivo = new Archivo(args);

65. 66.

/* Crear una instancia de SequenceInputStream */

67.

SequenceInputStream s;

68.

s = new SequenceInputStream(archivo);





Core Java

69. 70.

int c;

71.

while ((c = s.read()) != -1)

72.


73. 74.

/* Cerrar SequenceInputStream */

75.

s.close();

76.


77.

e.printStackTrace();

78. 79.



El código Java termina aquí La salida del programa será la siguiente: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entradaGeorge 24 25000.0 true

Fin del Ejemplo 1.10 El programa anterior usa SequenceInputStream para implementar un utilitario de concatenación que enlaza archivos en forma secuencial en el orden en que son listados en la línea de comandos. Asuma que se quiere concatenar los archivos miArchivo.txt y Empleado.txt. Se introduciría el siguiente comando en la línea de comandos: java SequenceInputStreamEjemplo miArchivo.txt Empleado.txt

Donde, SequenceInputStreamEjemplo es el nombre del archivo Java. miArchivo.txt Empleado.txt

es el primer archivo. es el segundo archivo.

Los archivos listados como argumentos para línea de comandos son miArchivo.txt y Empleado.txt. Libro 2: Core Java


Core Java


miArchivo.txt tiene el siguiente contenido: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings

desde el flujo de entrada Empleado.txt tiene el siguiente contenido: George 24 25000.0 true

A continuación se explica la clase StringBufferInputStream.

4.10 La Clase StringBufferInputStream Una aplicación puede crear este flujo de un string y leer los contenidos en la forma de bytes. Esta clase sólo usa los ocho bits bajos usados para representar un carácter. La clase StringBufferInputStream extiende de Inputstream. Esta clase está actualmente desaprobada (deprecated) y por esto no es recomendable usarla. Ahora, se discute en detalle la clase OutputStream.

5. La Clase OutputStream La clase OutputStream es una clase abstracta que permite escribir datos en la forma de bytes (8-bits). Las clases que son subclases de OutputStream deben implementar un método que retorne al menos un byte de datos como salida. Sin embargo, las subclases pueden sobrescribir los métodos proporcionados por OutputStream para tener mayor eficiencia o para añadir algunas características. La clase

OutputStream

extiende de la clase OutputStream se muestran en la Figura 1.5.


Object .

Las subclases de la clase




Core Java

Figura 1.5: La Clase OutputStream y sus Subclases

La clase ObjectOutputStream, que es una subclase de la clase OutputStream, es un flujo de byte que se usa para serializar objetos durante la serialización de objetos. Se estudiarán las otras subclases de OutputStream en esta unidad. Se comienza con la clase ByteArrayOutputStream.

5.1 La Clase ByteArrayOutputStream La clase ByteArrayOutputStream se usa como un OutputStream para escribir datos en un arreglo de byte. Esta clase mantiene internamente un buffer que almacena los bytes que serán escritos en el arreglo de byte. La clase ByteArrayOutputStream extiende OutputStream. Observe el Ejemplo 1.11.

Ejemplo 1.11 Este ejemplo ilustra como trabajar con la clase ByteArrayOutputStream.


import java.io.BufferedReader;

2. import java.io.ByteArrayOutputStream; 3. import java.io.IOException; 4. import java.io.InputStreamReader; 5. 6. /* Definicion de la clase comienza aqui */

Libro 2: Core Java


Core Java


7. public class ByteArrayOutputStreamEjemplo { 8.


9.


10.

try {

11.

String texto;

12.

/* Crear instancia de BufferedReader */

13.

BufferedReader br;

14.

br = new BufferedReader(

15. 16.

new InputStreamReader(System.in) );

17. 18.

do {

19.

System.out.println("Ingrese texto:");

20.

texto = br.readLine();

21.

texto = texto.trim();

22.

} while (texto.length() == 0);

23. 24.

/* Declaracion de arreglo de byte */

25.

byte arregloBytes1[] = texto.getBytes();

26. 27.

/* Crear una instancia de ByteArrayOutputStream */

28.

ByteArrayOutputStream aros;

29.

aros = new ByteArrayOutputStream();

30.

aros.write(arregloBytes1);

31.

System.out.println(

32.

"Contenido del ByteArrayOutputStream : " +

33.

aros.toString());

34. 35.

System.out.println(

36.

"Se copia el ByteArrayOutputStream " +

37.

"a un arreglo de byte: ");

38.

byte arregloBytes2[] = aros.toByteArray();

39. 40.

/* Mostrar valor de arregloBytes2 */

41.

for (int i = 0; i < arregloBytes2.length; i++)

42.

System.out.print((char) arregloBytes2[i]);

43.






45.


46.


47. 48.

Core Java



El código Java termina aquí La salida de este programa es la siguiente: Ingrese texto: Bienvenido a IBM Contenido del ByteArrayOutputStream : Bienvenido a IBM Se copia el ByteArrayOutputStream a un arreglo de byte: Bienvenido a IBM

Fin del Ejemplo 1.11 El programa anterior toma el string Bienvenido a IBM como entrada del usuario. Este es convertido en un arreglo de byte. Un ByteArrayOutputStream se abre sobre este arreglo de byte, y sus contenidos son impresos en la salida estándar usando el método ByteArrayOutputStream.toString(). Los contenidos de este flujo son leídos byte-por-byte e impresos en la salida estándar. A continuación se explica la clase FileOutputStream.

5.2 La Clase FileOutputStream FileOutputStream se usa para escribir bytes de datos a un archivo existente en el

sistema de archivos. Un objeto File o FileDescriptor se usa como argumento para representar el archivo al cual se va a escribir. El comportamiento de la protección al archivo (file locks), mientras se usa esta clase depende del sistema de operación subyacente. Esta clase extiende OutputStream . Se presenta el Ejemplo 1.12.

Ejemplo 1.12 Este ejemplo muestra como usar un objeto FileOutputStream.



2. import java.io.FileOutputStream; 3. import java.io.InputStreamReader; 4. import java.io.PrintStream; 5. 6. /* Definicion de la clase comienza aqui */

Libro 2: Core Java


Core Java


7. public class FileOutputStreamEjemplo { 8.


9.


10.

try {

11.

FileOutputStream salida;

12.

PrintStream ps;

13.

String nombreArchivo = "archivoSalida.txt";

14.

String texto;

15. 16.


17.

BufferedReader br;

18.


19.

new InputStreamReader(System.in)

20.

);

21. 22.

do {

23.

System.out.println("Ingrese texto");

24.


25.


26.


27. 28.

/* Crear un nuevo archivo de flujo de salida */

29.

salida = new FileOutputStream(nombreArchivo);

30. 31.

/* Conectar flujo de impresora

32.

al flujo de salida */

33.

ps = new PrintStream(salida);

34.

ps.println(texto);

35.

System.out.println(

36.

"Texto escrito en el archivo " +

37.

nombreArchivo);

38. 39.

/* Cerrar PrintStream */

40.

ps.close();

41.


42. 43.

System.err.println(e); }





Core Java



El código Java termina aquí El archivo archivoSalida.txt será creado si no existe, dependiendo de la plataforma en la cual se ejecute la JVM, y contendrá el siguiente string, si el string de entrada introducido es “Bienvenido a IBM”. Ingrese texto Bienvenido a IBM Texto escrito en el archivo archivoSalida.txt

Fin del Ejemplo 1.12 En el ejemplo anterior, el string Bienvenido a IBM se toma como entrada del usuario y se escribe a un archivo llamado archivoSalida.txt, usando FileOutputStream. A continuación se estudia FilterOutputStream y sus subclases.

5.3 La Clase FilterOutputStream FilterOutputStream, como el nombre lo sugiere, se usa para trabajar en el flujo de

salida, manipulando los datos de salida basados en ciertos filtros (condiciones) definidas por el usuario. La clase FilterOutputStream extiende OutputStream. La condición de filtrado puede estar basada en varias condiciones, como escribir solo caracteres ASCII o escribir los caracteres de un rango específico.

5.4 La Clase BufferedOutputStream La clase BufferedOutputStream permite a los flujos de salida almacenar en un buffer los bytes que están siendo escritos. Los datos que son escritos en otros flujos usualmente no esta en un buffer, por lo que se tiene que acceder al disco por cada byte de datos escrito. BufferedOutputStream mantiene un buffer interno como arreglo donde se escriben los bytes para el flujo. Los datos son guardados en este buffer hasta que se llena y son escritos en la salida. Los datos que son escritos en el buffer son escritos en la salida también, cuando el buffer es vaciado explícitamente o el flujo es cerrado. La clase BufferedOutputStream extiende FilterOutputStream. A continuación se presenta un ejemplo que usa la clase BufferedOutputStream.

Libro 2: Core Java


Core Java


Ejemplo 1.13 El programa en este ejemplo imprime los caracteres correspondientes a los valores enteros del 65 al 90.


import java.io.BufferedOutputStream;

2. import java.io.DataOutputStream; 3. import java.io.FileNotFoundException; 4. import java.io.FileOutputStream; 5. import java.io.IOException; 6. 7. /* Definicion de la clase comienza aqui */ 8. public class BufferedOutputStreamEjemplo { 9.


10.


11. 12.

try { /* Debe ingresar dos argumentos en

13.

linea de comandos */

14.


15.

System.err.println(

16.

"Debe ingresar algo asi:");

17.

System.err.println(

18.

"java BufferedOutputStreamEjemplo " +

19.

"nombreArchivo cantidadBuffer");

20. 21.

System.exit(1); }

22. 23.

/* Convertir el argumento de la cantidad

24.

del buffered de la linea de

25.

commando a entero */

26.

int cantidadBuffer = Integer.parseInt(args[1]);

27. 28.

/* Crear una instancia de FileOutputStream */

29.

FileOutputStream fos = new FileOutputStream(args[0]);

30. 31.

/* Crear una instancia de BufferedOutputStream */

32.

BufferedOutputStream bos;





Core Java

bos = new BufferedOutputStream(fos, cantidadBuffer);

34. 35.

/* Crear una instancia de DataOutputStream */

36.

DataOutputStream dos = new DataOutputStream(bos);

37.

for (int i = 65; i < 91; ++i) {

38.

dos.writeInt(i);

39.

System.out.print((char) i + " ");

40.

}

41. 42.


43.

dos.close();

44.


45.

System.out.println(

46.

"Archivo no encontrado");

47. 48.

System.exit(0); } catch (IllegalArgumentException e) {

49.

System.out.println(

50.

"La cantidad del buffer no " +

51.

"debe ser cero ni negativo");

52.

System.exit(0);

53.


54.

System.out.println(

55.

"Error de Entrada/Salida");

56. 57. 58.

System.exit(0); } }/* Metodo main termina aqui */


El código Java termina aquí La salida que se obtiene es la siguiente, y será escrita en el argumento especificado en la línea de comandos BufferSalida.txt: 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

Fin del Ejemplo 1.13 El programa se corre como sigue: java BufferedOutputStreamEjemplo BufferSalida.txt 100

Donde, Libro 2: Core Java


Core Java


BufferedOutputStreamEjemplo es el nombre del archivo Java. BufferSalida.txt

es el archivo correspondientes a los valores enteros. 100

que

almacena

los

caracteres

es el tamaño del buffer.

5.5 La Clase DataOutputStream Los tipos de datos primitivos usualmente tienen una representación que es dependiente de la máquina. La clase DataOutputStream permite que una aplicación escriba los tipos de datos primitivos de una forma independiente de la máquina. La clase DataOutputStream extiende de FilterOutputStream. Los datos escritos por este flujo pueden ser recuperados al programa Java por DataInputStream.

5.6 La Clase PrintStream Se podría querer escribir datos en la misma representación de tipos de datos que utiliza la plataforma subyacente. La clase PrintStream permite hacer esto. La codificación por defecto de los caracteres de la plataforma se usa para convertir los caracteres escritos usando PrintStream a bytes. Es más útil cuando se van a escribir caracteres, en vez de bytes. La clase PrintStream extiende de la clase FilterOutputStream. El ejemplo a continuación muestra el uso de la clase PrintStream.

Ejemplo 1.14 El código Java comienza aquí… 1.


2.

import java.io.BufferedOutputStream;

3.


4.


5.

import java.io.FileNotFoundException;

6.

import java.io.FileOutputStream;

7.

import java.io.IOException;

8.

import java.io.InputStreamReader;

9.

import java.io.PrintStream;

10. 11. /* Definicion de la clase PrintStreamEjemplo comienza aqui */ 12. public class PrintStreamEjemplo { 13.






Core Java

public static void main(String[] args) { try {

16.

String archivoOrigen

= "miArchivo.txt";

17.

String archivoDestino = "miArchivoDestino.txt";

18.

String texto;

19. 20.

/* Crear una instancia de BufferedInputStream */

21.

BufferedInputStream bis;

22.

bis = new BufferedInputStream(

23. 24.

new FileInputStream(archivoOrigen) );

25. 26.

/* Crear una instancia de PrintStream */

27.

PrintStream ps;

28.

ps = new PrintStream(

29.

new BufferedOutputStream(

30. 31. 32.

new FileOutputStream(archivoDestino) ) );

33. 34.

/* Establecer la entrada, salida y error estandar */

35.

System.setIn(bis);

36.

System.setOut(ps);

37.

System.setErr(ps);

38. 39.

/* Crear una instancia de BufferedReader */

40.

BufferedReader br;

41.


42. 43.


44. 45.

/* Leer de BufferedReader */

46.

while ((texto = br.readLine()) != null)

47.

System.out.println(texto);

48. 49. 50.

Libro 2: Core Java

System.out.println( "Salida escrita en este archivo");


Core Java


51. 52.

/* Cerrar el PrintStream */

53.

ps.close();

54.


55.


56.

System.exit(0);

57.


58.

System.out.println("Error de Entrada/Salida");

59.

System.exit(0);

60. 61.


62. }/* Definicion de la clase PrintStreamEjemplo termina aqui */

El código Java termina aquí Este programa redirige la salida a un archivo llamado miArchivoDestino.txt. Los contenidos de miArchivo.txt son los siguientes: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Los contenidos de miArchivoDestino.txt son los siguientes: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada Salida escrita en este archivo

Fin del Ejemplo 1.14 En el programa anterior, los contenidos de miArchivo.txt son leídos usando Los contenidos son escritos en el archivo BufferedInputStream. miArchivoDestino.txt usando PrintStream.

5.7 La Clase PipedOutputStream La clase PipedOutputStream es una subclase de OutputStream. Usualmente, trabaja en combinación con PipedInputStream para crear un canal (pipe) de comunicación. Se continúa el análisis con la clase Reader y sus subclases.





Core Java

6. La Clase Reader Se han visto hasta ahora formas de leer y escribir datos como bytes. Los flujos también se usan para ello. Se puede querer realizar estas operaciones sobre datos de tipo caracter en vez de bytes. En estos casos, se usan las clases Reader y Writer. Reader es una superclase abstracta para los flujos de caracteres que se usan para la lectura de caracteres. La clase abstracta Reader provee el API junto con la

implementación parcial para todos los flujos de lectura que se usan para leer caracteres de 16-bit. Los lectores están adecuados para manejar caracteres unicode y por esto son preferibles a utilizar un flujo de entrada de objeto.

La clase Reader extiende de la clase Object. La Figura 1.6 muestra la clase Reader y sus subclases.

Figura 1.6: La Clase Reader y sus Subclases

A continuación se estudiarán las subclases de la clase Reader comenzando con la clase BufferedReader.

6.1 La Clase BufferedReader La clase BufferedReader es un tipo de lector, como los flujos tipo buffer, mantiene un buffer interno de caracteres, y por esto permite leer caracteres, líneas, arreglos y strings de una forma eficiente. El tamaño del buffer puede ser especificado, cuando no se especifica, se usa el tamaño por defecto. La clase BufferedReader extiende a la clase Reader. Libro 2: Core Java


Core Java


Considere el Ejemplo 1.15, que muestra el uso de la clase BufferedReader.



2. import java.io.FileNotFoundException; 3. import java.io.FileReader; 4. import java.io.IOException; 5. 6. /*Definicion de la clase BufferedReaderEjemplo comienza aqui*/ 7. public class BufferedReaderEjemplo { 8.


9.


10.

try {

11.

/* Declaracion de variables */

12.

String dato;

13. 14.

/* Crear instancia de FileReader */

15.

FileReader fReader = new FileReader("miArchivo.txt");

16. 17.


18.

BufferedReader bReader = new BufferedReader(fReader);

19. 20.

/* Leer hasta alcanzar fin de archivo */

21.

while ((dato = bReader.readLine()) != null)

22.

System.out.println(dato);

23. 24.

/* Cerrar BufferedReader y FileReader */

25.

bReader.close();

26.

fReader.close();

27.


28.


29.

System.exit(0);

30.


31.


32.

System.exit(0);

33.

}





Core Java


35. }/*Definicion de la clase BufferedReaderEjemplo termina aqui*/

El código Java termina aquí El archivo de entrada miArchivo.txt contiene el siguiente texto: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

La salida del programa será la siguiente: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Fin del Ejemplo 1.15 El programa del Ejemplo 1.15 lee el contenido del archivo miArchivo.txt a través de BufferedReader y lo muestra en la salida estándar. A continuación se explica la clase LineNumberReader, que ayuda a saber el número de líneas dentro de un archivo.

6.2 La Clase LineNumberReader La clase LineNumberReader se puede usar en el caso de que se necesite estar al tanto del número de la línea actual de los datos leídos. El número de línea actual es incrementado cada vez que se lee el carácter de fin de línea (retorno de carro ' \r', nueva línea '\n', o retorno de carro ‘ \r’ seguido inmediatamente de nueva línea ‘ \n’). La clase LineNumberReader extiende BufferedReader. Considere el Ejemplo 1.16, que muestra su uso.

Ejemplo 1.16 El programa busca en el archivo de texto especificado, pasado como argumento args[1] por la línea de comandos, un patrón que se pasa en el argumento args[0] de la línea de comandos y muestra cada línea que tiene el patrón con su número de línea.



2. import java.io.FileReader; 3. import java.io.IOException;

Libro 2: Core Java


Core Java


4. import java.io.LineNumberReader; 5. 6. /*Definicion de la clase comienza aqui*/ 7. public class LineNumberReaderEjemplo { 8.


9.


10.

/* Debe ingresar 2 argumentos en la linea de comandos */

11.


12.

System.err.println(

13.


14.

System.err.println(

15.

"java LineNumberReaderEjemplo " +

16.

"palabraABuscar nombreArchivo");

17. 18.

System.exit(1); }

19. 20.

/* args[0] tiene la palabra a buscar */

21.

String palabraABuscar = args[0];

22.

/* args[1] tiene el nombre del archivo de busqueda */

23.

String nombreArchivo = args[1];

24. 25.

boolean encontrada = false;

26.

String texto;

27.

try {

28.

/* Crear instancia de fileReader */

29.

FileReader fReader = new FileReader(nombreArchivo);

30. 31.

/* Crear instancia de LineNumberReader */

32.

LineNumberReader lnReader;

33.

lnReader = new LineNumberReader(fReader);

34. 35.

/* Leer linea por linea del archivo */

36.

while ((texto = lnReader.readLine()) != null) {

37.

/* Si se encuentra la palabra buscada */

38.

if (texto.indexOf(palabraABuscar) != -1) {

39.

/* Extraer el numero de linea donde

40.

la busqueda encontro la palabra */





Core Java

41.

int numeroLinea = lnReader.getLineNumber();

42.

System.out.println(

43.

nombreArchivo +

44.

"[" +

45.

numeroLinea +

46.

"]: " +

47.

texto);

48. 49.

/* Establecer la bandera */

50.

encontrada = true;

51.

}

52.

}

53. 54.

/* Cuando no se encuentra la palabra en el archivo */

55.

if (!encontrada)

56.

System.out.println(

57.

"La palabra " +

58.

palabraABuscar +

59.

" no fue encontrada en " +

60.

nombreArchivo);

61. 62.

/* Cerrar el LineNumberReader */

63.

lnReader.close();

64.


65.

System.err.println(

66.

"Archivo " +

67.

nombreArchivo +

68.

" no encontrado");

69.

System.exit(0);

70.


71.

System.out.println(

72.


73. 74. 75.



El código Java termina aquí Libro 2: Core Java


Core Java


La salida del programa será la siguiente: miArchivo.txt[1]: El BufferedReader es un tipo de Reader(lector). miArchivo.txt[2]: Se utiliza para leer los caracteres o Strings miArchivo.txt[3]: desde el flujo de entrada

Fin del Ejemplo 1.16 El archivo de entrada miArchivo.txt contiene el siguiente texto: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Asuma que se quiere buscar la palabra ‘es’ en miArchivo.txt. Se introduce el siguiente comando: java LineNumberReaderEjemplo es miArchivo.txt

Aquí, LineNumberReaderEjemplo es el nombre del archivo Java. es es la palabra a buscar. miArchivo.txt en el archivo en el cual se va a buscar la palabra.

A continuación se estudia la clase CharArrayReader, que permite leer de un arreglo de caracteres.

6.3 La Clase CharArrayReader La clase CharArrayReader se usa para leer caracteres de un arreglo de caracteres. La clase CharArrayReader extiende Reader. Considere el Ejemplo 1.17, que muestra su uso.

Ejemplo 1.17 El programa lee tres entradas del usuario. La primera es una cadena, que se copia al objeto CharArrayReader. La segunda y tercera son enteros que indican el índice de inicio y el número de caracteres a copiar del objeto CharArrayReader existente a un nuevo objeto CharArrayReader.



2. import java.io.CharArrayReader; 3. import java.io.IOException;





Core Java

4. import java.io.InputStreamReader; 5. 6. /*Definicion de la clase comienza aqui*/ 7. public class CharArrayReaderEjemplo { 8.


9.


10.

try {

11.

/* Crear una instancia de BufferedReader */

12.

BufferedReader br;

13.


14. 15.


16. 17.

/* Declaracion de variable */

18.

String texto;

19.

int longitudTexto;

20.

do {

21.

/* Obtener una linea de texto del usuario */

22.

System.out.println("Ingrese una linea de texto");

23.


24.


25. 26.

/* Obtener la longitud del texto ingresado */

27.

longitudTexto = texto.length();

28.

System.out.println(

29.

"La longitud del texto es: " +

30.

longitudTexto);

31.

} while (longitudTexto == 0);

32. 33.

char arregloChar[] = new char[longitudTexto];

34. 35. 36. 37.

/* El metodo getChars copia lo que hay en texto desde la posicion 0 en arregloChar */ texto.getChars(0, longitudTexto, arregloChar, 0);

38. 39.

CharArrayReader caReader1;

40.

caReader1 = new CharArrayReader(arregloChar);

Libro 2: Core Java


Core Java 41.

Guía del Estudiante int i;

42. 43.

System.out.println("Contenido de caReader1: ");

44.

while ((i = caReader1.read()) != -1)

45.

System.out.print((char) i);

46. 47.

int inicio, numCaracteres;

48. 49. 50.

do { System.out.println(

51.

"\nIngrese el indice del " +

52.

"caracter desde donde quiere copiar");

53. 54.

inicio = Integer.parseInt(br.readLine());

55.

if (inicio < 0)

56.

System.out.println(

57. 58.

"El indice no puede ser negativo"); if (inicio > longitudTexto - 1)

59.

System.out.println(

60.

"El indice no puede ser mayor " +

61.

"que la longitud de la cadena");

62.

} while (inicio < 0 || inicio > longitudTexto - 1);

63. 64. 65.

do { System.out.println(

66.

"\nIngrese el numero de " +

67.

"caracteres que quiere copiar");

68. 69.

numCaracteres = Integer.parseInt(br.readLine());

70.

if (numCaracteres < 0)

71.

System.out.println(

72.

"El numero de caracteres " +

73.

"no puede ser negativo");

74.

if (numCaracteres > longitudTexto)

75.

System.out.println(

76.

"El numero de caracteres no puede " +

77.

"ser mayor que la longitud de la cadena");





Core Java

} while ((numCaracteres < 0) ||

79.

(numCaracteres > longitudTexto));

80. 81.

CharArrayReader caReader2;

82.

caReader2 = new CharArrayReader(

83.

arregloChar,

84.

inicio,

85.

numCaracteres

86.

);

87. 88.

System.out.println("Contenido de caReader2: ");

89.

while ((i = caReader2.read()) != -1) {

90.


91. 92.

} } catch (NumberFormatException e) {

93.

System.out.println("Valor ingresado invalido");

94.

System.exit(0);

95.


96.


97.

System.exit(0);

98. 99.



El código Java termina aquí La salida de este código con las entradas de prueba será la siguiente: Ingrese una linea de texto Bienvenido a IBM La longitud del texto es: 16 Contenido de caReader1: Bienvenido a IBM Ingrese el indice del caracter desde donde quiere copiar 13 Ingrese el numero de caracteres que quiere copiar 3 Contenido de caReader2: IBM

Fin del Ejemplo 1.17

Libro 2: Core Java


Core Java


Los pasos seguidos en el programa anterior son los siguientes: •

•

•

•

•

Al usuario, primero, se le pide una línea de texto. La línea del usuario es: Bienvenido a IBM La longitud de esta línea se calcula e imprime (que es 16). Luego se copia en CharArrayReader caReader1. Después, se toma el conjunto de caracteres a copiar. Se toma el índice de inicio y el número de caracteres a copiar. Finalmente, se copian los caracteres en otro CharArrayReader caReader2 y se muestran en la salida estándar.

6.4 La Clase FilterReader FilterReader, como el nombre lo sugiere, se usa para trabajar en el flujo de

caracteres manipulando los datos de entrada basado en ciertos filtros (condiciones) definidas por el usuario. La clase abstracta FilterReader extiende de Reader.

6.5 La Clase PushbackReader La clase PushbackReader es similar a la clase PushbackInputStream. Los caracteres que son leídos por el Reader pueden ser colocados nuevamente en el flujo. Esta clase extiende FilterReader. Considere el Ejemplo 1.18 que muestra su uso

Ejemplo 1.18 Este programa lee caracteres usando PushbackReader, que se abre sobre un CharArrayReader, que es, a su vez, abierto sobre un arreglo de caracteres. El arreglo de caracteres tiene tres caracteres ‘I’, ‘B’, y ‘ M’.

El código Java comienza aquí... 1.

import java.io.CharArrayReader;

2. import java.io.PushbackReader; 3. 4. /*Definicion de la clase PushbackReaderEjemplo comienza aqui*/ 5. public class PushbackReaderEjemplo { 6.


7.

public static void main(String[] args)

8.

throws Exception{

9. 10.

char buffer[] = {'I', 'B', 'M'};

11.

char letra;





Core Java

12. 13.

/* Establecer lector para leer

14.

del arreglo de caracteres */

15.

CharArrayReader car;

16.

car = new CharArrayReader(buffer);

17.

PushbackReader pr;

18.

pr = new PushbackReader(car, 1);

19.

/* Leer un caracter */

20.

letra = (char) pr.read();

21.

System.out.println(letra);

22. 23.

/* Leer otro caracter */

24.


25.


26. 27.

/* "Desleer" un caracter */

28.

pr.unread(letra);

29. 30.

/* Leerlo otra vez */

31.


32.


33.


34. }/*Definicion de la clase PushbackReaderEjemplo termina aqui*/

El código Java termina aquí La salida del programa anterior es la siguiente: I B B

Fin del Ejemplo 1.18 Este programa lee caracteres usando PushbackReader, que se abre sobre un CharArrayReader, abierto sobre un arreglo de caracteres. El arreglo de caracteres tiene tres caracteres ‘I’, ‘B’ y ‘M’. PushbackReader lee el primer carácter ‘I’ y lo muestra en la salida estándar, luego, lee el próximo carácter ‘B’ y los muestra en la salida estándar. Posteriormente, “des-lee” el segundo carácter. Ahora PushbackReader lee el próximo caracter, que es ‘B’ en vez de ‘M’. Finalmente el carácter leído, ‘B’, se imprime en la salida estándar.

Libro 2: Core Java


Core Java


A continuación se explica la clase InputStreamReader.

6.6 La Clase InputStreamReader Se ha aprendido acerca de flujos de byte y flujos de carácter. En algunos casos, se podría necesitar usar los flujos de byte y convertirlos en caracteres antes de que puedan ser usados. InputStreamReader realiza esta operación de acuerdo con el esquema de codificación de caracteres especificado. Esto se muestra en la Figura 1.7.

Figura 1.7: InputStreamReader como Puente entre Flujos de Byte y Flujos de Caracter

La clase

InputStreamReader

extiende de la clase Reader . Se puede usar InputStreamReader para tomar la entrada del usuario del dispositivo de entrada estándar (teclado). La entrada del usuario en el dispositivo de entrada estándar se captura primero abriendo un InputStream en System.in. InputStream, lee datos en la forma de bytes. Este es encapsulado, usando el InputStreamReader, que convierte los datos en forma de byte en caracter. BufferedReader envuelve a InputStreamReader, y finalmente se convierte la entrada del usuario en caracteres. Esto se muestra en la Figura 1.8.

Figura 1.8: InputStreamReader como Puente entre InputStream y BufferedReader





Core Java

La entrada del usuario tomada del teclado se lee usando InputStreamReader y luego es convertida en caracteres. El contenido de un archivo en un disco (disco duro o disco flexible) puede ser leído carácter por carácter usando FileReader. Los datos leídos pueden ser transferidos a otras computadoras conectadas a la red a través de conexiones de conectores (socket). Los datos pueden ser mostrados como caracteres en la salida estándar (monitor) en la misma computadora o mostrados en la salida estándar de una computadora diferente en la red usando PrintStream. Esto se ilustra en la Figura 1.9.

Figura 1.9: Lectura y Escritura de Datos a través de Flujos de Caracter

Si el esquema de codificación de caracteres usado no se especifica explícitamente, el esquema de codificación de caracteres por defecto para la plataforma será usado. Es recomendable envolver un InputStreamReader dentro de un BufferedReader, como se muestra en el siguiente código, para mejorar la eficiencia. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

Considere el Ejemplo 1.19, que ilustra el uso de InputStreamReader.

Libro 2: Core Java


Core Java


Ejemplo 1.19 En este programa, se le pide al usuario que introduzca una línea de texto. La línea del usuario es 'Bienvenido a IBM'. Este texto se lee y se muestra en la salida estándar.



2. import java.io.IOException; 3. import java.io.InputStreamReader; 4. 5. /*Definicion de la clase comienza aqui*/ 6. public class InputStreamReaderEjemplo { 7.


8.


9.

try {

10.


11.

BufferedReader br;

12.


13.


14.

);

15. 16.

/* Indicar al usuario de ingresar

17.

una linea de texto */

18.

System.out.println("Ingrese texto");

19. 20.

/* Leer el texto */

21.

String texto = br.readLine();

22. 23.

/* Mostrar el texto ingresado */

24.

System.out.println(

25.

"El texto ingresado fue: " +

26.

texto);

27.


28.


29.

System.exit(0);

30. 31.







Core Java

El código Java termina aquí La salida de este programa es: Ingrese texto Bienvenido a IBM El texto ingresado fue: Bienvenido a IBM

Fin del Ejemplo 1.19 A continuación se estudiará la clase FileReader, usada para leer caracteres de archivos.

6.7 La Clase FileReader FileReader es una clase que permite leer datos caracteres de un archivo. Esta clase extiende a la clase InputStreamReader.

Considere el Ejemplo 1.20, que muestra su uso.



2. import java.io.FileNotFoundException; 3. import java.io.FileReader; 4. import java.io.FileWriter; 5. import java.io.IOException; 6. 7. /*Definicion de la clase FileReaderEjemplo comienza aqui*/ 8. public class FileReaderEjemplo { 9.


10.


11.

/* Debe ingresar dos argumentos en linea de comandos */

12.

try {

13.


14.

System.err.println(

15.


16.

System.err.println(

17.

"java FileReaderEjemplo " +

18.

"archivoOrigen archivoDestino");

19. 20.

Libro 2: Core Java

System.exit(1); }


Core Java


21. 22.

/* args[0] tiene el nombre del archivo fuente */

23.

String nombreArchivoOrigen = args[0];

24. 25.

/* args[1] tiene el nombre del archivo destino */

26.

String nombreArchivoDestino = args[1];

27. 28.

/* Crear instancia de File */

29.

File archivoEntrada = new File(nombreArchivoOrigen);

30.

File archivoSalida

= new File(nombreArchivoDestino);

31. 32.

/* Crear instancia de FileReader */

33.

FileReader entrada = new FileReader(archivoEntrada);

34. 35.

/* Crear instancia de FileWriter */

36.

FileWriter salida = new FileWriter(archivoSalida);

37.

int c;

38. 39.

System.out.println(

40.

"Contenido de " +

41.

nombreArchivoOrigen +

42.

"\n");

43. 44.

while ((c = entrada.read()) != -1) {

45.


46.

salida.write(c);

47.

}

48. 49.

System.out.println("\n\n");

50. 51.

/* Cerrar todos los archivos abiertos */

52.

entrada.close();

53.

salida.close();

54. 55.

/* Ahora mostrar el contenido del archivo destino */

56.

FileReader reader;

57.

reader = new FileReader(





Core Java

58.

new File(nombreArchivoDestino)

59.

);

60. 61.

System.out.println(

62.

"Contenido de " +

63.

nombreArchivoDestino +

64.

"\n");

65. 66.

/* Leer del from destination file */

67.

while ((c = reader.read()) != -1)

68.


69. 70.


71.

entrada.close();

72.


73.

System.out.println(

74.

"Archivo fuente " +

75.

args[0] +

76.

" no encontrado");

77.

System.exit(0);

78.


79.

System.out.println(

80.


81. 82. 83.


84. }/*Definicion de la clase FileReaderEjemplo termina aqui*/

El código Java termina aquí Asuma que se quiere copiar los contenidos de miArchivo.txt a tuArchivo.txt. Se introduce el siguiente comando en la línea de comandos: java FileReaderEjemplo miArchivo.txt tuArchivo.txt

Aquí, FileReaderEjemplo es el archivo del programa Java. miArchivo.txt es el nombre del archivo fuente. tuArchivo.txt es el nombre del archivo destino.

Libro 2: Core Java


Core Java


La salida del código anterior será la siguiente: Contenido de miArchivo.txt El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Contenido de tuArchivo.txt El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Fin del Ejemplo 1.20 El programa del Ejemplo 1.20 es muy simple. Abre un FileReader en miArchivo.txt, y un FileWriter en tuArchivo.txt. El archivo de entrada miArchivo.txt tiene el siguiente texto: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Después de copiar en el archivo de salida, tuArchivo.txt tiene el siguiente texto: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

6.8 La Clase PipedReader La clase PipedReader es una subclase de Reader, se usa para utilizar una “tubería” de caracteres en flujos de entrada. Utilizar una “tubería” en un flujo de entrada de caracteres implica abrir un flujo de caracteres de entrada en el tope de otro. Véase la explicación de PipedInputStream. Esta clase extiende a la clase Reader.

6.9 La Clase StringReader Esta clase se usa para leer caracteres de un string. Esta clase también extiende a la clase Reader. Considere el Ejemplo 1.21, que muestra su uso:





Core Java


/*Definicion de la clase StringReaderEjemplo comienza aqui*/

2. public class StringReaderEjemplo { 3.


4.


5.

try {

6.

String texto = "Bienvenido a IBM";

7.

StringReader sReader = new StringReader(texto);

8.

int i;

9. 10.

/* Leer de StringReader */

11.

while ((i = sReader.read()) != -1)

12.


13.


14.


15.

System.exit(0);

16. 17.


18. }/* Definicion de la clase StringReaderEjemplo termina aqui */

El código Java termina aquí La salida del programa anterior es la siguiente: Bienvenido a IBM

Fin del Ejemplo 1.21 En el programa anterior, el string ' Bienvenido a IBM' es almacenado en otro string llamado texto. StringReader se usa para leer carácter por carácter de texto. Una vez vista la clase Reader y sus subclases; se pasa al otro tipo de clases, la clase Writer y sus subclases.

7. La Clase Writer Hasta ahora, se han visto formas de leer y escribir datos de tipo carácter en vez bytes. Writer es una superclase abstracta para los flujos de caracteres que se usan para escribir datos de tipo carácter. Las clases Writer están adecuadas para manejar

Libro 2: Core Java


Core Java


caracteres Unicode y por esto son preferibles a los flujos de salida de objetos. La Figura 1.10 muestra a Writer y sus subclases.

Figura 1.10: La Clase Writer y Sus Subclases

Las subclases de Writer deben implementar write(char[], int, int), flush() y close(). Sin embargo, ellas pueden sobrescribir otros métodos provistos por Writer para proporcionar la funcionalidad requerida. La declaración de esta clase es como sigue: public abstract class Writer extends Object

A continuación se estudian las distintas subclases de la clase Writer. Se comienza con la clase BufferedWriter.

7.1 La Clase BufferedWriter La clase BufferedWriter es un tipo de escritor, como otros flujos de tipo buffer, la clase BufferedWriter mantiene un buffer interno de caracteres, que permite escribir caracteres, líneas, arreglos y strings eficientemente. El tamaño del buffer puede ser especificado. Cuando el tamaño del buffer no se especifica, se usa el tamaño por defecto. La clase BufferedWriter extiende a la clase Writer. BufferedWriter provee el método newLine() que permite usar el separador de

línea definido por la plataforma. La plataforma tiene su separador de línea, especificado mediante la propiedad del sistema llamada line.separator. Algunas plataformas usan un carácter que es diferente del '\n' para especificar el fin de línea. Por ello, es





Core Java

preferible usar el método newLine() definido en esta clase para marcar el fin de cada línea en la salida. Usualmente cuando se hace una solicitud de escritura al Writer, este instruye al flujo de carácter o byte subyacente para llevar a cabo esta solicitud. Por esto, un BufferedWriter puede envolver a un escritor costoso, como un FileWriter o un OutputStreamWriter, como se muestra: PrintWriter pw = new PrintWriter( new BufferedWriter( new FileWriter("salida.txt") ) );

Este código envía de un PrintWriter a un archivo salida.txt para manejo de buffer. En caso de que no se emplee el buffer, los caracteres serán escritos uno por uno en el archivo. Esto puede ser ineficiente. Considere el Ejemplo 1.22, que muestra el uso de la clase BufferedWriter:



2. import java.io.BufferedWriter; 3. import java.io.FileWriter; 4. import java.io.IOException; 5. import java.io.InputStreamReader; 6. import java.io.PrintWriter; 7. import java.io.Writer; 8. 9. /*Definicion de la clase BufferedWriterEjemplo comienza aqui*/ 10. public class BufferedWriterEjemplo { 11.


12.


13.

try {

14.

String archivo = "Empleado.txt";

15.


16.

BufferedReader br;

17.


18.

Libro 2: Core Java



Core Java


19.

);

20. 21.

String empNombre;

22.

int empEdad;

23.

float empSalario;

24.

boolean empCasado;

25.

int estado = 0;

26. 27.

System.out.println("Ingrese datos de Empleado\n");

28. 29.

System.out.print("Nombre: ");

30.

empNombre = br.readLine();

31.

empNombre = empNombre.trim();

32. 33.

System.out.print("Edad: ");

34.

empEdad = Integer.parseInt(br.readLine());

35. 36.

System.out.print("Salario: ");

37.

empSalario = Float.parseFloat(br.readLine());

38. 39.

System.out.print("Casado (Si-0, No-1): ");

40.

estado = Integer.parseInt(br.readLine());

41.

if (estado == 0)

42. 43. 44.

empCasado = true; else empCasado = false;

45. 46.

/* Crear instancia de Writer */

47.

Writer salida = new FileWriter(archivo);

48. 49.

/* Crear instancia de BufferedWriter */

50.

BufferedWriter bw = new BufferedWriter(salida);

51. 52.

/* Crear instancia de PrintWriter */

53.

PrintWriter empSalida = new PrintWriter(bw);

54. 55.

/* Escribir en PrintWriter */





Core Java

56.

empSalida.println(empNombre);

57.

empSalida.println(empEdad);

58.

empSalida.println(empSalario);

59.

empSalida.println(empCasado);

60. 61.

/* Cerrar PrintWriter */

62.

empSalida.close();

63.

System.out.println(

64.

"Los datos del Empleado " +

65.

"fueron escritos en " +

66.

archivo);

67.

} catch (NumberFormatException e) {

68.

System.out.println("Numero invalido");

69.

System.exit(0);

70.


71.


72.

System.exit(0);

73. 74.


75. }/*Definicion de la clase BufferedWriterEjemplo termina aqui*/

El código Java termina aquí La salida son los detalles de un empleado almacenados en Empleado.txt. Ingrese datos de Empleado Nombre: Alvaro Edad: 23 Salario: 200000 Casado (Si-0, No-1): 1 Los datos del Empleado fueron escritos en Empleado.txt

Fin del Ejemplo 1.22 En el programa del Ejemplo 1.22, los detalles del empleado como: nombre, edad, salario y estado civil, se toman como entradas del usuario y se escriben al archivo Empleado.txt. Ahora, se estudiará la clase CharArrayWriter, que permite escribir arreglos de caracteres a un flujo.

Libro 2: Core Java


Core Java


7.2 La Clase CharArrayWriter La clase CharArrayWriter se usa para escribir un arreglo de caracteres en un flujo con un buffer interno. La clase CharArrayWriter extiende de la clase Writer. Los datos escritos en este flujo pueden ser recuperados usando los métodos toCharArray() y toString(). Considere el Ejemplo 1.23, que muestra su uso:


import java.io.Buffered java.io.BufferedReader; Reader;

2. import java.io.CharArrayWriter; java.io.CharArrayWriter; 3. import java.io.FileWriter; java.io.FileWriter; 4. import java.io.IOException; java.io.IOException; 5. import java.io.InputStreamReader; java.io.InputStreamReader; 6. 7. /*Definicion de la clase comienza aqui*/ 8. public class CharArrayWriterEjemplo { 9.


10.


11.

try {

12.

/* Crear instancia de CharArrayWriter */

13.

CharArrayWriter caWriter = new CharArrayWriter(); CharArrayWriter();

14. 15.


16.

BufferedReader br;

17.


18. 19.

new InputStreamReader(System.in) InputStreamReader(System.in) );

20. 21.

String texto;

22.

do {

23.

System.out.println(

24.

"Ingrese una linea de texto: ");

25.


26.


27.






Core Java

28. 29.

char buffer[] = new char[texto.length()];

30.

texto.getChars(0, texto.getChars(0 , texto.length(), texto.length(), buffer, 0);

31.

caWriter.write(buffer);

32. 33.

System.out.println(

34.

"\nCharArrayWriter "\nCharArrayWrit er contiene:\n" +

35.

caWriter.toString() caWriter.toStrin g() +

36.

"\n");

37. 38.

FileWriter fWriter = new FileWriter("Arreglo.txt"); FileWriter("Arreglo.txt");

39.

caWriter.writeTo(fWriter);

40.

fWriter.close();

41.

caWriter.reset();

42. 43.

System.out.println(

44.

"El contenido del arreglo " +

45.

"fue escrito en Arreglo.txt");

46.


47.

System.out.println("Error System.out.print ln("Error de Entrada/Salida"); Entrada/Salida");

48.

System.exit(0);

49. 50.



El código Java termina aquí La salida del programa es la siguiente: Ingrese una linea de texto: Bienvenido a IBM CharArrayWriter contiene: Bienvenido a IBM El contenido del arreglo fue escrito en Arreglo.txt

Fin del Ejemplo 1.23 En el programa anterior, se toma una línea como entrada del usuario. La línea de prueba es 'Bienvenido a IBM'. Esta línea se escribe a un CharArrayWriter como un

Libro 2: Core Java


Core Java


arreglo de caracteres. Los contenidos del CharArrayWriter son luego escritos al archivo Arreglo.txt. A continuación se presenta como trabaja trabaja la clase FilterWriter.

7.3 La Clase FilterWriter FilterWriter, como el nombre lo sugiere, se usa para trabajar en el flujo de

caracteres manipulando los datos de salida basado en ciertos filtros (condiciones) definidas por el usuario. La clase FilterWriter extiende Writer. Esta clase es abstracta, y por esto la forma de filtrar tiene que estar implementada en la subclase.

7.4 La Clase OutputStreamWriter La clase OutputStreamWriter actúa como un puente entre los flujos de caracteres y los de bytes. Esta clase extiende a la clase Writer. Esto se ilustra en la Figura 1.11.

Figura 1.11: OutputStreamWriter como Puente entre Flujos de Carácter y Flujos de Bytes OutputStreamWriter se usa para convertir caracteres en bytes, de acuerdo al

esquema de codificación de caracteres especificado. El usuario puede especificar el esquema de codificación usado o usar la codificación por defecto de la plataforma, definida por la propiedad de sistema file.encoding. Cada vez que se llama al método write, se invoca al convertidor de codificación en los caracteres dados. Los caracteres que son convertidos a bytes se guardan en un buffer antes de escribirse en el flujo de salida. El tamaño del buffer puede ser especificado, aunque el tamaño por defecto es generalmente suficiente para la mayoría de los programas. Los caracteres que se pasan a write() (antes de la conversión) no están en un buffer, por lo que es recomendable envolver un OutputStreamWriter por un BufferedWriter, como se muestra en el siguiente código, para mejorar la eficiencia: BufferedWriter bw = new BufferedWriter( new OutputStreamWriter( OutputStreamWriter( System.out ) );





Core Java

Considere el Ejemplo 1.24, que muestra el uso de OutputStreamWriter:


import java.io.BufferedWriter;

2.


3.

import java.io.FileReader;

4.


5.

import java.io.OutputStreamWriter;

6. 7.

/*Definicion de la clase comienza aqui*/

8.

public class OutputStreamWriterEjemplo {

9.


10.


11.

try {

12.

/* Debe ingresar el nombre del

13. 14.

archivo en la linea de comando */ if (args.length != 1) {

15.

System.err.println(

16.

"Escriba en la linea de comando algo asi:");

17.

System.err.println(

18.

"java OutputStreamWriterEjemplo archivo");

19. 20.

System.exit(0); }

21. 22.

FileReader fr = new FileReader(args[0]);

23.

/* Crear instancia de OutputStreamWriter */

24.

System.out.println(

25.

"Asociando OutputStreamWriter " +

26.

"con la salida standard\n");

27.

OutputStreamWriter osw;

28.

osw = new OutputStreamWriter(System.out);

29. 30.

/* Crear instancia de BufferedWriter */

31.

BufferedWriter bw = new BufferedWriter(osw);

32.

int c = fr.read();

33.

while (c != -1) {

Libro 2: Core Java


Core Java


34.

bw.write(c);

35.

c = fr.read();

36.

} // Fin del ciclo while

37. 38.

/* Cerrar FileReader y BufferedWriter */

39.

fr.close();

40.

bw.close();

41.


42.

System.out.println(

43.

"Archivo

44.

args[0] +

45.

" no encontrado");

46.

" +

System.exit(0);

47.


48.

System.out.println(

49.


50. 51. 52.



El código Java termina aquí La salida del programa anterior será la siguiente: Asociando OutputStreamWriter con la salida standard El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entrada

Fin del Ejemplo 1.24 Este programa lee caracteres de un archivo y los imprime en la salida estándar. El archivo de entrada contiene los siguientes datos: El BufferedReader es un tipo de Reader(lector). Se utiliza para leer los caracteres o Strings desde el flujo de entradaAsociando

Asuma que se quiere leer los caracteres del archivo miArchivo.txt. Al introducir el siguiente comando en la línea de comandos: Unidad 1: Archivos y Flujos




Core Java

java OutputStreamWriterEjemplo miArchivo.txt

Aquí, OutputStreamWriterEjemplo es el nombre del archivo del programa Java. miArchivo.txt es el nombre del archivo fuente del cual queremos leer los caracteres.

A continuación se explica la clase FileWriter.

7.5 La Clase FileWriter FileWriter es una clase que nos permite escribir datos de tipo carácter en un

archivo. Esta clase mantiene un buffer interno al escribir los datos, extiende a la clase OutputStreamWriter. Considere el Ejemplo 1.25, que muestra su uso:



2. import java.io.FileWriter; 3. import java.io.IOException; 4. import java.io.InputStreamReader; 5. import java.io.Reader; 6. import java.io.StringReader; 7. import java.io.Writer; 8. 9. /*Definicion de la clase FileWriterEjemplo comienza aqui*/ 10. public class FileWriterEjemplo { 11.


12.


13.

try {

14.


15.

BufferedReader br;

16.


17. 18. 19.

new InputStreamReader(System.in) ); String texto;

20. 21.

Libro 2: Core Java

/* Chequear que se ingresa algun texto */


Core Java 22.

Guía del Estudiante do {

23.

System.out.println(

24.

"Ingrese una linea de texto: ");

25.


26.


27.


28. 29.

/* Crear una instancia de Reader */

30.

Reader entrada = new StringReader(texto);

31. 32.

/* Crear una instancia de Writer */

33.

Writer salida;

34.

salida = new FileWriter("FileWriterEjemplo.txt");

35.

int caracter;

36.

char c;

37.

System.out.println(

38.

"\nEl contenido del archivo es: ");

39. 40.

/* Leer caracteres de Reader */

41.

while ((caracter = entrada.read()) != -1) {

42.

/* Convertir los caracteres a mayuscula */

43.

c = Character.toUpperCase((char) caracter);

44. 45.

/* Se almacena en el archivo especificado */

46.

salida.write(c);

47. 48.

/* Mostrar el caracter en mayuscula

49.

en la salida estandar */

50. 51.

System.out.print(c); }

52. 53.

/* Mostrar una linea en blanco */

54.


55. 56.

/* Escribir caracter de fin de linea en el archivo */

57.

salida.write('\n');

58.

System.out.println(





Core Java

59.

"\nLa salida es escrita en el " +

60.

"archivo FileWriterEjemplo.txt");

61. 62.

/* Vaciar el writer y cerrar */

63.

salida.flush();

64.

salida.close();

65.


66.


67.

System.exit(0);

68. 69.


70. }/* Definicion de la clase FileWriterEjemplo termina aqui */

El código Java termina aquí La salida de este programa es la siguiente: Ingrese una linea de texto: Bienvenido a IBM El contenido del archivo es: BIENVENIDO A IBM La salida es escrita en el archivo FileWriterEjemplo.txt

Fin del Ejemplo 1.25 En el programa anterior, se toma del usuario una línea. La línea de prueba es Bienvenido a IBM. Esta línea es escrita a un archivo llamado FileWriterEjemplo.txt usando el flujo FileWriter.

7.6 La Clase PipedWriter La clase PipedWriter es una subclase de la clase Writer, se usa para utilizar una “tubería” de caracteres en flujos de salida. Utilizar una “tubería” en un flujo de salida de caracteres implica abrir un flujo de caracteres de salida en el tope de otro. Esta clase también extiende a la clase Writer.

7.7 La Clase PrintWriter La clase PrintWriter extiende a Writer. Este objeto escritor puede ser usado para escribir datos string y datos objeto que están formateados como string, etc. Esta clase implementa todas las versiones del método print que están disponibles en PrintStream.

Libro 2: Core Java


Core Java


Se pueden leer datos de un archivo usando un FileReader envuelto usando un BufferedReader. Estos datos pueden escribirse a otro archivo, usando la misma aplicación Java, a través de un FileWriter encapsulado usando un PrintWriter. Esto se ilustra en la Figura 1.12.

Figura 1.12: Lectura y Escritura de un Archivo usando Flujos de Caracteres

Considere el Ejemplo 1.22, mostrado en la sección 7.1 referente a La clase BufferedWriter, este ejemplo muestra el uso de la clase PrintWriter.

1.1.1 7.7.1 Métodos de la clase PrintWriter El método printf(): public PrintWriter printf(String formato, Object ... args)

Este método provee gran poder y flexibilidad a la forma en que se verá la salida, tiene muchas opciones y un número variable de parámetros. Es un método de salida usado para escribir una cadena de caracteres formateada utilizando una cadena de formato y una lista de argumentos especificados. Si el flujo automático es habilitado, las llamadas a este método vaciarán hacia el buffer de salida.





Core Java

Una invocación de este método de la forma out.printf(formato, args) se comporta exactamente de la misma manera que la invocación out.format(formato, args).

Parámetros: formato – Es una cadena de formato la cual puede contener texto fijo y uno o más

especificadores de formato embedidos. args – Son argumentos referenciados por los especificadores de formato en la cadena de formato. Si hay más argumentos que especificadores de formato, los argumentos extras son ignorados. La cantidad de argumentos es variable y puede ser cero. El número máximo de argumentos es limitado por la máxima dimension de un arreglo Java tal como está definido por la Especificación de la Máquina Virtual de Java. El comportamiento sobre un argumento null depende de la conversión (general, de characteres, numérica, fecha/hora, porcentual).

El método printf() con otra firma: printf(Locale l, String format, Object ... args) Es un método de conveniencia que se usa para escribir una cadena de caracteres formateada para la clase Writer utilizando los argumentos y la cadena de formatos especificados. Si el flujo automático es habilitado, las llamadas a este método vaciarán el buffer de salida. Una invocación de este método de la forma out.printf(l, formato, args) se comporta exactamente de la misma manera que la invocación out.format(l, formato, args)

Parámetros: l –

Es el objeto Locale para aplicar durante el formateo. Si l es null entonces no se aplica la localización. formato –

Es una cadena de formato la cual puede contener texto fijo y uno o más especificadores de formato embedidos. args

– Son argumentos referenciados por los especificadores de formato en la cadena de formato. Si hay más argumentos que especificadores de formato, los argumentos extras son ignorados. La cantidad de argumentos es variable y puede ser cero. El número máximo de argumentos es limitado por la máxima dimension de un arreglo Java tal como está definido por la Especificación de la Máquina Virtual de Java. El comportamiento sobre un argumento null depende de la conversión (general, de characteres, numérica, fecha/hora, porcentual). Existe también un método llamado format, el cual se comporta exactamente de la misma manera que el método printf. El parámetro de este método es: Libro 2: Core Java


Core Java


format (String formato, Object... args)

7.8 La Clase StringWriter La clase StringWriter es una subclase de la clase Writer. El string que se quiere escribir a un flujo, primero se le asigna a un buffer. Los contenidos de este buffer son usados para construir un string y este último se usa finalmente para escribir en el flujo de caracteres.

8. La Clase Scanner La clase Scanner permite hacer lectura formateada desde un flujo de entrada. Esta clase está presente a partir de Java 5.0. La lectura se basa en un delimitador, que por defecto es uno o varios espacios en blanco. Considere el Ejemplo 1.26, que muestra su uso:


import java.util.Scanner;

2. 3. /*Definicion de la clase ScannerEjemplo comienza aqui*/ 4. public class ScannerEjemplo { 5.


6.


7.

System.out.println("Ingrese Nombre y Edad: ");

8. 9.

/* Crear instancia de Scanner */

10.

Scanner entrada = new Scanner(System.in);

11. 12.

/* Extrae del flujo un String */

13.

String nombre = entrada.next();

14. 15.

/* Extrae del flujo un entero */

16.

int edad = entrada.nextInt();

17. 18.

/* Cierre del flujo */

19.

entrada.close();

20.





Core Java

21.

/* Se muestra por la salida estandar lo capturado */

22.

System.out.println("Su Nombre es: " + nombre);

23.

System.out.println("Su Edad es: " + edad);

24.


25. }/* Definicion de la clase ScannerEjemplo termina aqui */

El código Java termina aquí La salida de este programa es la siguiente: Ingrese Nombre y Edad: Pedro 25 Su Nombre es: Pedro Su Edad es: 25

Fin del Ejemplo 1.26 En el programa anterior, se toma del usuario su nombre y su edad. Esta información se extrae a través de los métodos next() y nextInt() de la clase Scanner. Luego se cierra el flujo y se procede a mostrar el resultado de los datos ingresados por el usuario.

Libro 2: Core Java


Core Java



•

•

•

•

•

Explicar la clase File. Describir FileDescriptor. Explicar los flujos. Explicar los diferentes tipos de flujos de caracteres. Explicar los diferentes tipos de flujos de bytes. Describir la forma de trabajo con acceso aleatorio en archivos.





Core Java

Unidad 1: Examen de Autoevaluación 1) Los objetos de la clase File son inmutables. a) Verdadero b) Falso 2) Los objetos de la clase FileDescriptor se pueden usar para representar a) Un archivo abierto b) Un conector abierto c) Una fuente o receptor de bytes de datos d) Todas las anteriores 3) Los flujos se pueden usar para leer cuál de los siguientes tipos de datos a) Un objeto b) Un string c) Sonido d) Todas las anteriores 4) ¿Cuál de los siguientes flujos permite acceder a los datos en forma secuencial? a) Flujos de Caracteres b) Flujos de Bytes c) Ambos anteriores d) Ninguno de los anteriores 5) ¿Qué clase permite tener acceso aleatorio en archivos? a) File b) FileDescriptor c) RandomFileAccess d) Ninguna de las anteriores 6) Se pueden crear objetos de la clase Reader para leer caracteres. a) Verdadero b) Falso 7) Se puede especificar el tamaño del buffer interno de la clase BufferedReader. a) Verdadero b) Falso

Libro 2: Core Java


Core Java


8) ¿Cuál de las siguientes opciones son correctas en relación BufferedReader? a) BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

b) BufferedReader br

= new BufferedReader(new FileReader(

"archivo.txt"));

c) BufferedReader

br

=

new

BufferedReader(new

File(

"archivo.txt"));

d) BufferedReader br

= new BufferedReader(new InputStream(

"archivo.txt"));

9) ¿Cuál de los siguientes métodos se pueden usar para obtener los datos escritos usando un ByteArrayOutputStream? a) toByteArray() b) toString() c) toArray() d) Ninguno de los anteriores 10) La clase RandomAccessFile se usa para ____________. a) Lectura de archivos b) Escritura a archivos c) Ambos anteriores d) Ninguna de las anteriores





Core Java


a d d c d b a ayb ayb c

Libro 2: Core Java



Core Java

Unidad 2: Laboratorio de Archivos y Flujos Objetivos del Aprendizaje Al final de esta unidad, usted será capaz de: •

•

•

Crear archivos. Aprender a leer de y escribir a archivos. Desarrollar programas Java para acceder directorios y subdirectorios.

Libro 2: Core Java

Unidad 2: Laboratorio de Archivos y Flujos 141 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


Ejercicios de Laboratorio 1) Escribir un programa en Java que lea el contenido de un archivo e invierta cada palabra leída y la escriba a un archivo destino, cuyo contenido se lee y muestra usando el método printf de la clase PrintWriter.


•

•

•

•

•

•

Escriba una clase llamada Inversor. Abra un archivo fuente cuyos contenidos serán leídos. Abra un archivo destino en el cual se van a escribir los contenidos. Use FileInputStream para leer del archivo. Después de leer una palabra (conjunto de caracteres seguido de un espacio en blanco) convertirla a un String, e invertirla usando el método invertir(). El string invertido se convierte a un arreglo de caracteres y se escribe al archivo destino usando FileOutputStream. Los contenidos del archivo destino son leídos usando FileInputStream e impresosusando el método printf de la clase PrintWriter.

2) Escribir un programa en Java que lea el contenido de los archivos dat1 y dat2, ambos con el mismo número de líneas. Las líneas de dat1 y dat2 se leen alternativamente y se escriben a otro archivo dat3. Finalmente, el contenido del archivo dat3 se imprime usando el método printf de la clase PrintWriter.

Recomendaciones Útiles: Escriba una clase llamada Fusion. Abra un FileReader encapsulado usando un BufferedReader en los archivos dat1.txt y dat2.txt. •

•

•

•

•

•

•

•

Abra un FileWriter en dat3.txt. Lea una línea de dat1.txt y una de dat2.txt usando el método readLine() de FileReader. Escriba las líneas leídas a dat3.txt usando el método write() de FileWriter. Cierre todos los flujos. Abra un FileReader envuelto con un BufferedReader en dat3.txt. Lea los contenidos de dat3.txt usando el método readLine() FileReader e imprímalos usando el método printf de la clase PrintWriter. Cierre los flujos.

Unidad 2: Laboratorio de Archivos y Flujos




Core Java

3) Escribir un programa en Java que liste todos los subdirectorios del directorio actual.


•

•

•

Escriba una clase llamada Directorio. Declare una variable string e inicialícela con la ruta del directorio actual. Cree un objeto file con la variable String como parámetro. Declare un arreglo de string e inicialícelo con la lista de subdirectorios y archivos del objeto file representando el directorio actual usando el método list().

Comience un ciclo for que se ejecute tantas veces como número de elementos tenga el arreglo de string. Cree un objeto File que represente al directorio actual y un elemento del arreglo string como parámetros. Cada vez que se ejecuta el ciclo el índice en el arreglo de string se incrementa en uno. Revise si el objeto File recién creado representa a un directorio e imprima el nombre del subdirectorio en la salida estándar. 4) Escribir un programa en Java que lea el contenido de un archivo que tenga la siguiente estructura: •

•

•

•

123 456 789

pedro maria juan

s2m s3t s1n

Para ello haga uso de la clase Scanner. Finalmente, el contenido de cada líneadel archivo se imprime usando el método printf de la clase PrintWriter.


•

•

•

•

•

•

Escriba una clase llamada LectorArchivo. Cree un método estático que reciba un String que será el nombre del archivo. Cree un objeto File con la variable String como parámetro. Si el archivo existe, cree un objeto Scanner que reciba como parámetro el objeto File. Mientras exista una nueva línea en el archivo, extraiga los valores del mismo teniendo en cuenta los tipos de datos que representa cada columna e imprimalos usando el método printf de la clase PrintWriter. Recuerde cerrar el flujo del objeto Scanner después de culminar la lectura del archivo. Luego llame al método estático, pasandole el nombre del archivo a leer.

Libro 2: Core Java

Unidad 2: Laboratorio de Archivos y Flujos 143 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.


Core Java

Unidad 3: Serialización de Objetos Objetivos del Aprendizaje Al final de esta unidad, usted será capaz de: •

•

•

•

•

Explicar la serialización de objetos. Explicar la interfaz Serializable. Explicar la interfaz Externalizable. Explicar la clase ObjectOutputStream. Explicar la clase ObjectInputStream.

Libro 2: Core Java

Unidad 3: Serialización de Objetos 145 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Core Java


1. Introducción En Java, se trabaja principalmente con clases y objetos. Los objetos persisten en la memoria hasta tanto el programa esté activo. Una vez que el programa completa su ejecución, los objetos son destruidos. Sin embargo, es posible almacenar un objeto en un archivo durante la primera ejecución de un programa, de forma que el valor de dicho objeto esté disponible posteriormente. Los objetos pueden ser reconstruidos antes de la segunda ejecución del programa al recuperar sus valores del archivo donde se almacenaron. Este proceso de almacenar y recuperar el valor de un objeto se realiza a través de la serialización de objetos. A continuación se estudiará esto en detalle.

2. Serialización de Objetos La serialización de objetos es el proceso por el cual el estado actual de un objeto puede ser guardado en forma persistente. También se puede recuperar el objeto con su estado de la misma forma en que se guardo. El proceso de almacenar el objeto se llama serialización de objetos, mientras que el proceso de leer el objeto y recuperar el valor que había sido almacenado se llama deserialización de objetos. La serialización de objetos, aunque es un concepto simple, tiene muchos usos. La serialización de objetos se usa al pasar objetos a través de flujos, en RMI y en persistencia ligera, que se estará discutiendo más adelante en esta unidad. La Figura 3.1 muestra como ocurre la serialización de objetos en Java.

Figura 3.1: Serialización de Objetos

Hasta tanto el programa este ejecutándose, los objetos viven dentro de la JVM. A través de la serialización, los objetos se hacen persistentes fuera de la JVM aún después de que el programa finalice su ejecución. La serialización ayuda a escribir y leer grafos de objetos de la memoria al sistema de archivos y recuperar las asociaciones de memoria del sistema de archivos a los objetos. La serialización de objetos guarda los siguientes detalles acerca de un objeto que esta siendo serializado: •

Tipo del Objeto.

Unidad 3: Serialización de Objetos



Guía del Estudiante •

•

Core Java

Información Interna. Referencias a otros objetos.

Luego de esta introducción a la serialización de objetos, se discuten las aplicaciones de la serialización de objetos.

3. Aplicaciones de la Serialización de Objetos Existen innumerables aplicaciones basadas en la serialización de objetos. Las siguientes son tres aplicaciones que hacen uso de ésta: Aplicaciones Cliente-Servidor. Invocación a Métodos Remotos (Remote Method Invocation RMI). Persistencia de objetos.

3.1 Aplicaciones Cliente-Servidor Las aplicaciones Cliente-Servidor necesitan intercambiar datos. Típicamente, los datos intercambiados son de tipo texto. Si los objetos van a ser intercambiados, se usará la serialización de objetos. Los objetos pueden ser serializados antes de ser enviados por la red y pueden ser reconstruidos una vez que sean recibidos por el método remoto.

3.2 Invocación a Métodos Remotos (RMI) La serialización de objetos puede ser usada en RMI, que trata de la comunicación entre objetos a través de conectores (sockets). RMI provee un mecanismo por el cual un método en un objeto puede invocar a un método en otro objeto residente en una JVM diferente. En este caso, los objetos necesitan ser pasados por la red y por esto tienen que ser serializados.

3.3 Persistencia de Objetos Persistencia involucra el almacenaje de un objeto. Asuma que se necesita que los datos

contenidos en un objeto sean persistentes. Una forma de almacenar un objeto es almacenándolo en un archivo, con delimitadores, pero esto involucra muchas manipulaciones de cadenas de caracteres y de archivo. La otra forma, es lograr la persistencia a través de la serialización de objetos. Se pueden guardar objetos en forma persistente durante una ejecución del programa y recuperarlos durante otra ejecución. Una vez entendidos los principios básicos de la serialización y sus usos, se verá como Java implementa la serialización.

4. Implementando Serialización en Java La lectura y escritura de objetos en Java se lleva a cabo con la ayuda de dos flujos presentes en el paquete java.io son estos: ObjectInputStream y Libro 2: Core Java


Core Java


ObjectOutputStream. Estas clases son similares a los otros flujos de entrada y

salida de Java.

Las distintas clases que se usan en la serialización de objetos, se listan en la Figura 3.2 con su jerarquía.

Figura 3.2: Clases e Interfaces en la Serialización de Objetos

En esta unidad se aprenderá la forma de escribir clases cuyas instancias se pueden serializar mediante la interfaz Serializable. Luego se verá cómo tener control explícito sobre el proceso de serialización mediante la interfaz Externalizable. También se estudiará la forma de serializar objetos con la clase ObjectOutputStream y recuperar los objetos serializados con la clase ObjectInputStream. Se comenzará con la interfaz Serializable.

4.1 La interfaz Serializable La clase cuyas instancias pueden ser serializadas en Java, tiene que implementar la interfaz java.io.Serializable. La interfaz Serializable es una interfaz vacía. Una interfaz vacía es aquella que no contiene métodos. Se usa sólo para identificar la semántica de la serialización. Serializable es una interfaz marcadora y marca que la clase tiene la propiedad de la serialización. El estado de un objeto no puede ser serializado o de-serializado sin implementar la interfaz Serializable. Todas las subclases de una clase que implementa la interfaz Serializable pueden ser serializadas. La interfaz Serializable tiene que ser usada después de la cláusula implements en la declaración de la clase, como se muestra a continuación: class MiClase implements Serializable{





Core Java

// ... }

En el caso de una relación de herencia, si una superclase de una clase no es serializable, entonces la subclase puede tomar la responsabilidad de serializar y recuperar las variables public, protected y package de la superclase. Las variables private no son serializables de esta forma.

Nota: Ambas la superclase y la subclase deben estar presentes en el mismo paquete para lograr esto. Una subclase puede tomar la responsabilidad de serializar las variables sólo cuando la superclase tiene un constructor que no toma ningún parámetro para inicializar su estado, y es accesible por la subclase. Si existe una violación a la regla anterior, se detectará sólo en tiempo de ejecución. Las variables que son serializadas son aquellas que se usan para construir el objeto. Los campos en la superclase del objeto serializado son inicializados por el código en el constructor public o protected. Cuando se serializa un objeto, se recorre la jerarquía de clases de este objeto para serializar los campos y métodos heredados por este objeto. En la jerarquía de herencia de este objeto, se puede encontrar una clase que no implemente la interfaz Serializable y por esto no puede ser serializada. Cuando esto ocurre, se lanza una NotSerializableException. Durante la serialización y deserialización de objetos, algunas clases pueden necesitar manejar situaciones excepcionales en una forma especial. Estas clases pueden implementar los métodos writeObject() y readObject() . Los métodos readObject() y writeObject() sirven básicamente para personalizar el proceso de serialización. El método writeObject() permite controlar la forma de guardar el estado del objeto serializado en ObjectOutputStream y el estado de ese objeto se puede restaurar usando el método readObject() usando ObjectInputStream. Se puede usar el método writeObject() o los métodos declarados en la interfaz DataOutput para escribir al ObjectOutputStream para serializar los campos del objeto. Si no se quiere controlar la manera en la que los campos son serializados y es suficiente usar el método por defecto de serialización, se puede usar el método defaultWriteObject(). Si se usa este método, los campos que pertenecen a la superclase o a la subclase de la clase en consideración no serán serializados. El método readObject() restaura el estado del objeto que fue serializado usando el método writeObject() correspondiente. También permite actualizar el estado del objeto luego de haber sido restaurado.

Libro 2: Core Java


Core Java


La Figura 3.3. muestra como ObjetoEjemplo implementa la interfaz Serializable, colocando así, al objeto listo para serialización.

Figura 3.3: ObjetoEjemplo Listo para Serialización

Se puede usar el método defaultReadObject() para recuperar los campos que no sean static y no transient en la deserialización. Este método asigna los campos restaurados del objeto guardado a los campos correspondientes en el objeto actual. A este método no le concierne el estado de las superclases o subclases de la clase actual. Usando el método readObject() para leer del ObjectInputStream, se puede restaurar el estado de cada campo. Se puede también sustituir el objeto a ser usado cuando se escribe al flujo de salida. En estos casos, se usa el método writeReplace(). Éste puede ser accedido desde un método en la clase cuyo objeto está siendo serializado. Por esto, el método writeReplace() puede acceder a las variables private, protected, package y public de la clase. Cuando se accede al método writeReplace() desde una subclase, se siguen las reglas de accesibilidad de Java para los diferentes especificadores de acceso. Similarmente, cuando se tiene que sustituir el objeto a ser usado, cuando se lee de un flujo de entrada, se puede usar el método readResolve(). Este método puede ser accedido desde un método en la clase cuyo objeto esta siendo deserializado. Por esto, el método readResolve() puede acceder a las variables private, protected, package, y public de la clase actual. Cuando se accede al método readResolve() Unidad 3: Serialización de Objetos




Core Java

desde una subclase, se siguen las reglas de accesibilidad para los diferentes especificadores de acceso de Java. No se puede serializar los campos de un objeto que no implemente la interfaz Serializable. Una clase no serializable puede tener una subclase serializable. En este caso, la clase no serializable necesita tener un constructor que no tome ningún argumento, para inicializar sus campos. La subclase de esta clase no serializable debe hacerse cargo de serializar los campos de esta clase y recuperarlos. Usualmente, los campos de la superclase serán accesibles ( public, protected, package). Si los campos no son accesibles, la superclase deberá tener los métodos get y set que puedan ser usados para serializar y recuperar los campos de la superclase no serializable.

4.2 La Interfaz Externalizable La interfaz Serializable es una interfaz marcadora, realiza la mayoría de la actividad durante la serialización. Maneja implícitamente los campos con varios modificadores de acceso, campos que son compartidos con las clases herederas y las clases bases, etc. Si se quiere tener un mayor control y soluciones de serialización personalizadas, se debe acudir a la externalización, es decir, implementar la interfaz Externalizable, en vez de la interfaz Serializable. La interfaz Externalizable se aplica cuando una clase necesita coordinarse explícitamente con su superclase para serializarse a sí misma. Implementar una interfaz Externalizable da un control completo y explícito del proceso de serialización de la clase. A diferencia de las clases que implementa la interfaz Serializable, la clase ObjectOutputStream automáticamente guarda sólo la identidad de la clase que implementa la interfaz Externalizable. La clase que implementa la interfaz Externalizable es responsable de serializar y deserializar su estado y lo hace en coordinación con su superclase. La interfaz Externalizable extiende a la interfaz Serializable, tiene dos métodos ampliamente usados cuando se utiliza la externalización – writeExternal() y readExternal() . Estos métodos son implementados de manera que proporcionan un control completo del formato de la serialización. Esto es particularmente útil en el caso de la relación de herencia donde los campos de la superclase son también serializados. En la interfaz Serializable, los métodos que se usan para escribir los detalles del objeto en el almacenamiento permanente y para leer del almacenamiento permanente, se encargan de lo relacionado con el estado del objeto y de sus superclases. En el caso de la interfaz Externalizable, los métodos writeExternal() y readExternal() se implementan por el usuario para coordinar explícitamente con la superclase para guardar el estado del objeto. Las interfaces Serializable y Externalizable se usan también en los mecanismos para persistencia de objetos. Cuando se usa un formato definido fuera de

Libro 2: Core Java


Core Java


la clase, los métodos readExternal() y writeExternal() son los únicos responsables de preservar este formato particular cuando se leen y escriben objetos.

Nota: Estos dos métodos deben ser declarados como públicos. Dado que los métodos son declarados como public, existe un riesgo de hacer posible que un objeto externo escriba o lea información en el objeto Externalizable. Por lo que, es recomendable usar estos dos métodos sólo cuando no exista riesgo de seguridad. En una clase, los especificadores de control se usan para restringir el acceso a las variables y métodos. Las variables que tienen información sensible no deben ser serializadas. En estos casos, se puede recurrir a variables transitorias ( transient). Esto brinda una solución segura en el caso de la interfaz Serializable. Se debe poner un cuidado especial en el caso de la interfaz Externalizable. Adicionalmente, los objetos que implementan la interfaz Externalizable son propensos a ser sobrescritos dado que el método readExternal() es público. Un desarrollador puede invocar al método readExternal() , y pasar cualquier flujo definido por el usuario para leer los valores del objeto. Al hacer esto, el objeto destino es reinicializado. Por todo lo anterior, un comportamiento conservador debe tomarse cuando se serializan objetos. No se debe confiar en que los flujos sólo tienen representaciones válidas de objetos. Para este propósito, se debe asegurar que el estado sensible de un objeto no pueda ser recuperado y que la clase debe reverificar los contenidos que son recuperados. La serialización de objetos no debe realizarse hasta que sea absolutamente necesario. En caso de implementar estas interfaces, los campos sensibles que no deben ser serializados deben ser manejados con precaución. Las posibles formas de asegurar que no ocurra la serialización innecesaria de objetos son las siguientes: Marcar los campos como private o transient previene que sean serializados. Los métodos getter y setter de los campos que no deben ser serializados deben lanzar NotSerializableException, para que el proceso de serialización termine. Las clases que no necesitan ser serializadas no deben implementar la interfaz Serializable o Externalizable.

Nota: Los métodos writeReplace() y readResolve() pueden también ser usados para crear objetos duplicados de la clase que implementa la interfaz Externalizable.





Core Java

4.3 La Clase ObjectOutputStream La clase ObjectOutputStream se usa para escribir tipos de datos que están contenidos en objetos Java a un a clase OutputStream. Escriben la representación en memoria de los objetos a la clase OutputStream. Los objetos Java escritos usando ObjectOutputStream pueden leerse usando ObjectInputStream. Para guardar los objetos en forma persistente se puede usar un archivo donde el flujo escribe su salida. Se puede usar la clase ObjectOutputStream para serializar objetos, datos cadenas y también para tipos de datos primitivos. p rimitivos. Sólo los objetos de las clases que implementan la interfaz java.io.Serializable, permiten que las clases almacenen y recuperen la información mientras el flujo se lee o se escribe. El nombre y la firma de la clase, los valores de los campos y arreglos del objeto, y la clausura de cualquier otro objeto referenciado por los objetos iniciales se codifican durante el proceso de serialización. Se puede usar el método writeObject() cuando se quiere escribir un objeto a un flujo. Aún, los strings, arreglos y los tipos primitivos son tratados como objetos y son escritos usando el método writeObject(). Para recuperar los objetos guardados se deben leer los mismos tipos en el orden en que fueron almacenados. Para los tipos de datos primitivos, se tienen métodos como: writeIn()t , writeFloat() , etc. Sin embargo, una discusión más profunda sobre los métodos que están disponibles en esta clase esta fuera del alcance de esta discusión. El Ejemplo 3.1 ilustra el uso de ObjectOutputStream para serializar los campos de objetos.

Ejemplo 3.1 Este programa acepta los detalles de un empleado del usuario y los escribe en el archivo ObjetoEmpleado.txt.


import java.io.Buffered java.io.BufferedReader; Reader;

2. import java.io.FileOutputStream; java.io.FileOutputStream; 3. import java.io.IOException; java.io.IOException; 4. import java.io.InputStreamReader; java.io.InputStreamReader; 5. import java.io.ObjectOutputStream; java.io.ObjectOutputStream; 6. 7. /*Definicion de la clase comienza aqui*/ 8. public class ObjectOutputStreamEjemplo {

Libro 2: Core Java


Core Java


9.


10.


11.

try {

12.

// Crear una instancia de FileOutputStream;

13.

FileOutputStream fos;

14.

fos = new FileOutputStream("ObjetoEmpleado.txt"); FileOutputStream("ObjetoEmpleado.txt");

15. 16.

// Crear una instancia de ObjectOutputStream

17.

ObjectOutputStream ObjectOutputStre am oos;

18.

oos = new ObjectOutputStream(fos); ObjectOutputStream(fos);

19. 20.

// Crear una instancia de BufferedReader

21.

BufferedReader br;

22.


23. 24.

new InputStreamReade InputStreamReader(System.in) r(System.in) );

25. 26.

// Declaración de variables

27.

long empCodigo;

28.

String empNombre;

29.

int empEdad;

30. 31.

// Obtener la entrada del usuario

32.

System.out.println(

33.

"Ingrese los datos del Empleado:");

34. 35.

System.out.print("Codigo: System.out.print( "Codigo: ");

36.

empCodigo = Long.parseLong(br.readLine()); Long.parseLong(br.readLine());

37. 38.

System.out.print("Nombre: System.out.print( "Nombre: ");

39.

empNombre = br.readLine().trim(); br.readLine().trim();

40. 41.

System.out.print("Edad: System.out.print( "Edad: ");

42.

empEdad = Integer.parseInt(br.readLine() Integer.parseInt(br.readLine()); );

43. 44.

// Escribir los detalles del empleado en el archivo

45.

oos.writeLong(empCodigo);





Core Java

46.

oos.writeObject(empNombre);

47.

oos.writeInt(empEdad);

48. 49.

System.out.println(

50.

"Los datos del empleado fueron " +

51.

"escritos en ObjetoEmpleado.txt");

52. 53.

// Cerrar el ObjectOutputStream

54.

oos.flush();

55.

oos.close();

56.


57.


58.

System.exit(0);

59.


60.


61.

System.exit(0);

62. 63.



El código Java termina aquí El programa anterior acepta detalles del empleado y escribe el siguiente texto en el archivo ObjetoEmpleado.txt. Ingrese los datos del Empleado: Codigo: 123 Nombre: Alvaro Edad: 23 Los datos del empleado fueron escritos en ObjetoEmpleado.txt ObjetoEmpleado.txt contiene los siguientes datos:

Fin del Ejemplo 3.1 A continuación se estudia la clase ObjectInputStream.

4.4 La Clase ObjectInputStream La clase ObjectInputStream permite la deserialización de datos primitivos u objetos escritos por ObjectOutputStream. Estos dos flujos cuando se usan con Libro 2: Core Java


Core Java


FileInputStream y FileOutputStream proporcionan almacenamiento persistente

de objetos.

Durante la deserialización, se crean nuevos objetos; por lo tanto los viejos objetos no son sobrescritos. La memoria es asignada a los objetos nuevos y es inicializada en null. Los campos individuales que son leídos de la clase ObjectInputStream son asignados a los campos apropiados en el nuevo objeto. Si alguna excepción ocurre durante la deserialización, la clase ObjectInputStream la captura y el proceso de lectura concluye. Se puede usar el método readObject() para leer objetos de ObjectInputStream. El mecanismo de conversión proporcionado por Java se usa para obtener los objetos del tipo deseado. ObjectInputStream también permite leer tipos primitivos de datos. En caso de los tipos definidos por el usuario, son serializados usando writeObject(), y el correspondiente método readObject() se usa para deserealizar los datos en forma apropiada. Al método readObject() no le conciernen los estados (campos) de las superclase o subclases de la clase actual. Observe a continuación el Ejemplo 3.2.

Ejemplo 3.2 Este ejemplo muestra el uso de ObjectInputStream para recuperar los campos de los objetos.



2.


3.


4.

import java.io.ObjectInputStream;

5. 6.

/*Definicion de la clase comienza aqui*/

7.

public class ObjectInputStreamEjemplo {

8.


9.


10.

try {

11.

// Crear una instancia de FileInputStream

12.

FileInputStream fis;

13.

fis = new FileInputStream("ObjetoEmpleado.txt");

14. 15.

// Crear una instancia de ObjectInputStream





Core Java

16.

ObjectInputStream ois;

17.

ois = new ObjectInputStream(fis);

18. 19.

// Declaracion de variables

20.

long empCodigo;

21.

String empNombre;

22.

int empEdad;

23. 24.

System.out.println(

25.

"Leyendo los datos del Empleado " +

26.

"del archivo ObjetoEmpleado.txt\n");

27. 28.

// Leer valores del objeto del archivo

29.

empCodigo = ois.readLong();

30.

empNombre = (String) ois.readObject();

31.

empEdad = ois.readInt();

32. 33.

/* Mostrar los valores del empleado

34.

en la salisda estandar */

35.

System.out.println("Datos del Empleado");

36.

System.out.println("Codigo: " + empCodigo);

37.

System.out.println("Nombre: " + empNombre);

38.

System.out.println("Edad: " + empEdad);

39.

} catch (ClassNotFoundException e) {

40. 41.

System.out.println(e); } catch (FileNotFoundException e) {

42.

System.out.println("No se encuentra el archivo");

43.

System.exit(0);

44.


45.


46.

System.exit(0);

47. 48.



El código Java termina aquí

Libro 2: Core Java


Core Java


Este programa usa el archivo ObjetoEmpleado.txt como entrada. El contenido del archivo es lo que se obtiene como salida del programa que ilustra el uso de ObjectOutputStream en el Ejemplo 3.1. La salida del programa es la siguiente: Leyendo los datos del Empleado del archivo ObjetoEmpleado.txt Datos del Empleado Codigo: 123 Nombre: Alvaro Edad: 23

Fin del Ejemplo 3.2 El Ejemplo 3.2 ilustró como los campos que son almacenados en objetos pueden ser recuperados. A continuación otro ejemplo, que almacena y recupera los campos.

Ejemplo 3.3 Este ejemplo muestra como usar ObjectOutputStream y ObjectInputStream para una clase que implementa la interfaz java.io.Serializable, para almacenar y recuperar los campos de la clase Serializable.



2.


3.


4.


5.

import java.io.InputStreamReader;

6.


7.

import java.io.ObjectOutputStream;

8.

import java.io.Serializable;

9. 10. /* Definicion de la clase Empleado comienza aqui */ 11. class Empleado implements Serializable { 12.

// Datos miembros

13.

private int codigo;

14.

private String nombre;

15.

private float sueldo;

16. 17.

/* Constructor Empleado comienza aqui */

18.

public Empleado(int codigo, String nombre, float sueldo) {





super();

20.

this.codigo = codigo;

21.

this.nombre = nombre;

22.

this.sueldo = sueldo;

23.

Core Java

}/* Constructor Empleado termina aqui */

24. 25.

/* Metodo toString comienza aqui */

26.

public String toString() {

27.

StringBuffer datos = new StringBuffer();

28. 29.

datos.append("***Datos del empleado***\n");

30.

datos.append("Codigo: " + getCodigo() + "\n");

31.

datos.append("Nombre: " + getNombre() + "\n");

32.

datos.append("Sueldo: " + getSueldo());

33. 34. 35.

return datos.toString(); }/* Metodo toString termina aqui */

36. 37.

public int getCodigo() {

38.

return codigo;

39.

}

40.

public void setCodigo(int codigo) {

41. 42.

this.codigo = codigo; }

43. 44.

public String getNombre() {

45.

return nombre;

46.

}

47.

public void setNombre(String nombre) {

48. 49.

this.nombre = nombre; }

50. 51.

public float getSueldo() {

52.

return sueldo;

53.

}

54.

public void setSueldo(float sueldo) {

55.

this.sueldo = sueldo;

Libro 2: Core Java


Core Java 56.

Guía del Estudiante }

57. }/* Definicion de la clase Empleado termina aqui */ 58. 59. /*Definicion de la clase SerializableEjemplo comienza aqui*/ 60. public class SerializableEjemplo { 61.


62.


63.

try {

64.

int empCodigo;

65.

String empNombre;

66.

float empSueldo;

67. 68.

// Crear instancia de BufferedReader

69.

BufferedReader br;

70.


71. 72.


73. 74.

// Obtener detalles del empleado del usuario

75.

System.out.println(

76.

"Ingrese los datos del Empleado:");

77.

System.out.print("Codigo: ");

78.

empCodigo = Integer.parseInt(br.readLine());

79.

System.out.print("Nombre: ");

80.

empNombre = br.readLine().trim();

81.

System.out.print("Salario: ");

82.

empSueldo = Float.parseFloat(br.readLine());

83. 84.

// Crear una instancia de clase Empleado

85.

Empleado emp1;

86.

emp1 = new Empleado(

87.

empCodigo,

88.

empNombre,

89.

empSueldo

90.

);

91. 92.

// Crear una instancia de FileOutputStream





Core Java

93.

FileOutputStream fos;

94.

fos = new FileOutputStream(

95.

"SerializadoEmpleado.txt

96.

");

97. 98.

// Crear una instancia de ObjectOutputStream

99.

ObjectOutputStream oos;

100.

oos = new ObjectOutputStream(fos);

101. 102.

// Serializar detalles del empleado

103.

oos.writeObject(emp1);

104.

System.out.println(

105.

"\nLos datos del Empleado fueron " +

106.

"serializados en SerializadoEmpleado.txt");

107. 108.

// Cerrar ObjectOutputStream

109.

oos.flush();

110.

oos.close();

111.


112.


113.

System.exit(0);

114.


115.

System.out.println(

116.

"Exception durante la serializacion: " +

117.

e);

118. 119.

System.exit(0); }

120. 121.

// Ahora deserealizar detalles de empleado

122.

try {

123.

// Crear una referencia de la clase Empleado

124.

Empleado emp2;

125. 126.

// Crear una instancia de FileInputStream

127.

FileInputStream fis;

128.

fis = new FileInputStream(

129.

Libro 2: Core Java

"SerializadoEmpleado.txt"


Core Java


130.

);

131. 132.

// Crear una instancia de ObjectInputStream

133.

ObjectInputStream ois;

134.

ois = new ObjectInputStream(fis);

135. 136.

// Leer detalles de empleado

137.

emp2 = (Empleado) ois.readObject();

138. 139.

// Cerrar ObjectInputStream

140.

ois.close();

141. 142.

/* Mostrar detalle del empleado

143.

en la salida estandar */

144.

System.out.println(

145.

"\nEmpleado deserealizado desde " +

146.

"SerializadoEmpleado.txt\n" +

147.

emp2);

148.


149.

System.out.println(

150.

"Archivo no encontrado");

151. 152.

System.exit(0); } catch (Exception e) {

153.

System.out.println(

154.

"Exception durante la deserializacion: " + e);

155. 156. 157.


158. }/*Definicion de la clase SerializableEjemplo termina aqui*/

El código Java termina aquí La clase Empleado es inicializada con los datos introducidos por el usuario. La clase SerializableEjemplo escribe los datos al archivo SerializadoEmpleado.txt usando ObjectOutputStream. El programa lee los contenidos de este archivo usando ObjectInputStream, y los imprime en la salida estándar. El contenido del SerializadoEmpleado.txt es el siguiente:





Core Java

La salida del programa es la siguiente: Ingrese los datos del Empleado: Codigo: 123 Nombre: Alvaro Salario: 100000 Los datos del Empleado fueron serializados en SerializadoEmpleado.txt Empleado deserealizado desde SerializadoEmpleado.txt ***Datos del empleado*** Codigo: 123 Nombre: Alvaro Sueldo: 100000.0

Fin del Ejemplo 3.3 Considere el Ejemplo 3.4.

Ejemplo 3.4 El siguiente ejemplo muestra como ObjectOutputStream y ObjectInputStream se pueden usar en una clase que implementa la interfaz java.io.Externalizable para almacenar y recuperar sus campos.


import java.io.Externalizable;

2.


3.


4.


5.

import java.io.ObjectInput;

6.


7.

import java.io.ObjectOutput;

8.

import java.io.ObjectOutputStream;

9. 10. /*Definicion de la clase Brazil comienza aqui*/ 11. class Brazil implements Externalizable { 12.

/* Constructor Brazil comienza aqui */

13.

public Brazil() {

14. 15.

System.out.println("Brazil Constructor"); } /* Constructor Brazil termina aqui */

16. 17.

/* Metodo writeExternal comienza aqui */

Libro 2: Core Java


Core Java 18. 19.

Guía del Estudiante public void writeExternal(ObjectOutput out) throws IOException {

20. 21. 22.

System.out.println("Brazil.writeExternal"); } /* Metodo writeExternal termina aqui */

23. 24.

/* Metodo readExternal comienza aqui */

25.

public void readExternal(ObjectInput in)

26.

throws IOException,

27.

ClassNotFoundException {

28. 29. 30.

System.out.println("Brazil.readExternal"); } /* Metodo readExternal termina aqui */

31. }/* Definicion de la clase Brazil termina aqui */ 32. 33. /* Definicion de la clase comienza aqui */ 34. public class FutbolExternalizableEjemplo { 35.


36.


37. 38.

System.out.println( "Construyendo instancia de Brazil");

39.

Brazil objBrazil = new Brazil();

40.

try {

41.

ObjectOutputStream oos;

42.

oos = new ObjectOutputStream(

43. 44.

new FileOutputStream("Futbol.txt") );

45. 46.

System.out.println("Guardando objteo:");

47.

oos.writeObject(objBrazil);

48.

oos.close();

49. 50.

// Ahora regreselos:

51.

ObjectInputStream entrada;

52.

entrada = new ObjectInputStream(

53.

new FileInputStream(

54.

"Futbol.txt"





Core Java

55.

)

56.

);

57. 58.

System.out.println("Recuperando objeto:");

59.

objBrazil = (Brazil) entrada.readObject();

60.


61.


62.

} catch (ClassNotFoundException e) {

63.


64.


65.

e.printStackTrace();

66. 67.



El código Java termina aquí En este programa, se crea el objeto Brazil. Este objeto es serializado persistentemente y escrito en el archivo Futbol.txt. El contenido de Futbol.txt es el siguiente:

El programa produce la siguiente salida: Construyendo instancia de Brazil Brazil Constructor Guardando objteo: Brazil.writeExternal Recuperando objeto: Brazil Constructor Brazil.readExternal

Fin del Ejemplo 3.4

Libro 2: Core Java


Core Java



•

•

•

•

Explicar la serialización de objetos. Explicar la interfaz Serializable. Explicar la interfaz Externalizable. Explicar la clase ObjectOutputStream. Explicar la clase ObjectInputStream.





Core Java

Unidad 3: Examen de Autoevaluación 1) La serialización de objetos se usa en: a) Invocación de Métodos Remotos (Remote Method Invocation – RMI) b) Persistencia Ligera c) Ambas anteriores d) Ninguna de las anteriores 2) ¿Cuál de las siguientes es una interfaz vacía? a) ObjectOutput b) ObjectInput c) Externalizable d) Serializable 3) Si una superclase de una clase no es serializable, entonces la subclase puede asumir la responsabilidad de serializar los campos accesibles de la superclase y restaurarlos. a) Verdadero b) Falso 4) ¿Cuál de los siguientes modificadores hace que los campos sean no serializables? a) transient b) static c) Serializable d) Externalizable 5) ¿Qué ocurre cuando se encuentra un objeto no serializable mientras se recorre una jerarquía de objetos en la serialización? a) Se lanza NotSerializableException b) Su superclase serializable puede encargarse de serializar sus campos c) Su subclase serializable puede encargarse de serializar sus campos d) Ninguna de las anteriores 6) El método defaultReadObject usa el mecanismo por defecto para restaurar los campos no estáticos y no transient. a) Verdadero b) Falso

Libro 2: Core Java


Core Java


7) Para tener un objeto sustituto mientras se escribe a un ObjectOutputStream se usa el método writeReplace(). a) Verdadero b) Falso 8) Para tener un objeto sustituto mientras se lee de un ObjectInputStream, se aplica el método readReplace(). a) Verdadero b) Falso 9) ¿Cuál de las siguientes interfaces permite tener coordinación con la superclase de una clase durante la serialización y deserialización? a) Serializable b) Externalizable c) ObjectOutput y ObjectInput d) DataOutput y DataInput 10) ¿Cuáles de los siguientes métodos se implementan para proporcionar el control completo del formato de serialización, así como de los estados del objeto y los objetos de su superclase que van a ser serializados? a) writeExternal y readExternal b) writeObject y readObject c) writeReplace y readResolve d) Ninguna de las anteriores





Core Java


c d b (la super clase debe tener un constructor sin argumentos accesible) ayb ayc a a b b a

Libro 2: Core Java


Core Java


Unidad 4: Laboratorio de Serialización de Objetos Objetivos del Aprendizaje Al final de esta unidad, usted será capaz de: •

•

Trabajar con la serialización de objetos en Java. Usar las clases ObjectInputStream y ObjectOutputStream.

Unidad 4: Laboratorio de Serialización de Objetos




Core Java

Ejercicios de Laboratorio 1) Escriba un programa en Java para guardar la hora del sistema en un archivo.


•

•

•

•

•

•

•

•

Escriba una clase Serializable llamada MiClase. Declare una variable string y defina un método para recuperar la variable string. El valor de la variable string puede ser asignado usando el constructor de MiClase. Escriba una clase llamada HoraDelSistema. Cree un objeto File representado al archivo Hora.txt. Abra un FileOutputStream envuelto con un ObjectOutputStream en el objeto File. Cree una instancia de la clase Date y extraiga los detalles de la hora e imprímela en la salida estándar. Escriba los detalles de la hora en Hora.txt con ObjectOutputStream. Abra un FileInputStream envuelto con un ObjectInputStream sobre Hora.txt. Lea los contenidos de Hora.txt e imprímalos en la salida estándar.

2) La mayoría conoce el juego del tenis. Para aquellos que no conocen nada de tenis, se dará una breve introducción al juego. El juego se juega usualmente entre dos o cuatro jugadores. Un match (partido) entre dos jugadores se llama un match sencillo y entre cuatro jugadores, dos en cada equipo, se llama match doble. Los matches se clasifican según el género, de forma que se tienen: los matches sencillos y dobles de hombres, y los matches sencillos y dobles de mujeres, también hay matches dobles mixtos, que involucran a un hombre y una mujer por equipo. Para este ejercicio, se limitarán las reglas para match sencillo de tenis. El juego del tenis es único en varios aspectos, en términos de puntos, jugadores sirviendo, etc. De nuevo en el contexto de este ejercicio, nos limitaremos a las reglas sobre los puntos en un match. El sistema de puntaje en un match sencillo de tenis es diferente a otros juegos como el fútbol, básquetbol, voleibol, etc. Un match de tenis consiste de 3 o 5 sets. El jugador que gane los primeros 6 juegos es declarado ganador del set siempre y cuando el otro jugador no haya ganado 5 juegos. Si los jugadores están empatados en los 6 juegos, se introduce el tiebreak (empate). En un tiebreak, el jugador que gane los primeros siete puntos gana el juego y el set. Sin embargo, tiene que liderar a su rival por dos puntos. En el caso de que dos jugadores estén empatados a 6 puntos en el tiebreak, el juego se extiende hasta que el margen de dos puntos sea alcanzado por alguno de los jugadores. La división de los puntos en un juego también es diferente de otros juegos. El primer punto que un jugador gana en un juego le otorga 15 puntos. El próximo punto lleva su puntaje a 30. El tercer punto lleva su puntaje a 40 y el próximo punto gana el juego. En Libro 2: Core Java

Unidad 4: Laboratorio de Serialización de Objetos 171 © Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

IBM_Core Java - Libro 2

Recommend Documents