Archivos

De Datos En Java
(Paquete java.io)

Presentado por: Richard Meza

José Medrano Jhonatan Gómez
Juan David Hernández Felipe Licona
Mateo Beltran
 Conceptualización
¿Qué son los archivos de datos en Java?
Los archivos de datos son una manera en la cual un programa en Java puede enviar información a un medio externo
(Archivo) o bien recibirla para leerla dentro del programa y utilizarla. En este tema principalmente se usan los streams
(Su nombre se refiere a un flujo de información) junto con un conjunto de métodos presentes en el paquete java.io. Los
streams se utilizan para proporcionar una abstracción de bajo nivel de entrada/salida de datos, permitiendo al
programador leer o escribir grandes cantidades de datos de manera eficiente y flexible, sin tener que preocuparse por la
implementación subyacente.
 Conceptualización
Los Streams como flujos de información
Cualquier programa realizado en Java que necesite llevar a cabo una operación de I/O lo hará a través de un stream.
Un stream, cuya traducción literal es "flujo", es una abstracción de todo aquello que permite introducir o extraer
información. Así, un stream de teclado es un flujo de entrada para el programa y un stream de pantalla es un flujo de
salida del programa.

La vinculación de este stream al dispositivo físico (teclado, pantalla, archivo, impresora, etc.) la hace el sistema de
entrada y salida de Java. En java tenemos una serie de clases que hacen parte del paquete java.io Que son las que
nos permiten fabricar estos strems mas tarde enfocaremos mas en esto.
 Conceptualización
Conceptos a tener en cuenta

1. El paquete System define tres clases:

- in (entrada estándar)
- out (salida estándar)
- err (salida de errores estándar)

2. La escritura hacia pantalla se hace con System.out:

System.out.println("Hola Mundo"); // Añade nueva línea al final
System.out.print ("Adiós"); // NO añade nueva línea al final

3. La lectura desde teclado se hace con System.in.

4. Para archivos tendremos flujos de:

Entrada (input stream), lectura de archivo
Salida (output stream), escritura de archivo
 Conceptualización
Las clases abstractas
En Java tenemos estas dos clases abstractas: OutputStream y InputStream, las cuales son imposible instanciar, sin
embargo definen una serie de métodos útiles para el flujo de datos.
Con los OutputStream podemos enviar información hacia afuera o consumirla desde afuera, es decir, con
InputStream.
De estas clases abstractas mediante java.io se pueden instanciar métodos los cuales sí podemos instanciar para
trabajar enviando información hacia afuera o consumiendo información de afuera.
 Conceptualización
Funcionamiento de OutputStream e InputStream
En la clase abstracta OutputStream existen métodos a través de los cuales podemos enviar información, como el objeto
File. Además, hay objetos "out" que se envuelven como una caja; dentro de esa caja hay otra que procesa la
información y la caja más pequeña se encarga de enviar esa información. Por último, tenemos las salidas estándar, que
ya están listas para usar por defecto en la consola.
Por otro lado, con InputStream también podemos instanciar métodos para recibir información y manejarla. Además,
podemos crear objetos "input" que envuelven la información, similar al ejemplo de la clase OutputStream. A diferencia
de OutputStream, con InputStream podemos crear conexiones con servidores u otros métodos para recibir datos de
forma estándar.
 Paquete java.io
El paquete java.io de Java proporciona una amplia variedad de clases y métodos para trabajar con entrada y
salida de datos. A continuación, se describen algunos de los conceptos más importantes que ofrece según su
funcionamiento:

1. Lectura y escritura de bytes 2. Escritura de bytes en archivo 3. Lectura de bytes de archivo

- InputSream - FileOutputStream - FileOutputStream
- OutputStream - BufferedOutputStream - BufferedOutputStream
- Read
- Close
- Write
- Flush

4. Gestión de excepciones y 5. Lectura y escritura 6. Escritura de caracteres

cierre automático de recursos de caracteres en archivo
- Try with resources - Reader - FileWriter
- Writer - BufferedWriter
 Paquete java.io
7. Lectura de caracteres 8. Escritura de objetos 9. Lectura de objetos
de archivo - ObjectOutputStream - ObjectInputStream
- FileReader
- BufferedReader

10. Manipulación de 11. Conversión de bytes 12. Escritura de caracteres

puntero de lectura a caracteres y viceversa formateados
- Mark - Reader - PrintWriter
- Reset - Writer

13. Otras funciones

- Append
- Println
- Print
- PrintStream
- System.out
- System.in
01 Lectura y
Escritura de Bytes
// InputStream: // Write:
InputStream is = new FileInputStream("archivo.txt"); os.write(“Hola, mundo!”.getBytes());

// OutputStream:
// Close:
OutputStream os = new FileOutputStream("archivo.txt");
os.close();

// Read: // Flush:
Int b = is read(); os.flush();
02 Escritura de Bytes
En Archivo
// FileOutputStream:
FileOutputStream fos = new FileOutputStream("archivo.txt");

// BufferedOutputStream:
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("archivo.txt"));
03 Lectura de
Bytes de Archivo
// FileInputStream:
FileInputStream fis = new FileInputStream("archivo.txt");

// BufferedInputStream:
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("archivo.txt"));
04 Gestión de Excepciones
y Cierre automático de Recursos
// Try with resources:
try (OutputStream os = new FileOutputStream("archivo.txt")) {
os.write("Hola, mundo!".getBytes());
} catch (IOException e) {e.printStackTrace();
}
05 Lectura y Escritura
de Caracteres
// Reader:
Reader reader = new FileReader("archivo.txt");

// Writer:
Writer writer = new FileWriter("archivo.txt");
06 Escritura de
Caracteres en Archivo
// FileWriter:
FileWriter fw = new FileWriter("archivo.txt");

// BufferedWriter:
BufferedWriter bw = new BufferedWriter(new FileWriter("archivo.txt"));
07 Lectura de
Caracteres en Archivo
// FileReader:
FileReader fr = new FileReader("archivo.txt");

// BufferedReader:
BufferedReader br = new BufferedReader(new FileReader("archivo.txt"));
08 Escritura de
Objetos
// ObjectOutputStream:
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objeto.dat"));
oos.writeObject(new MiObjeto());
09 Lectura de
Objetos
// ObjectInputStream:
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("objeto.dat"));
MiObjeto miObjeto = (MiObjeto) ois.readObject();

// readObject:
MiObjeto miObjeto = (MiObjeto) ois.readObject();
10 Manipulación de
Puntero de Lectura
// Mark:
bis.mark(0);

// Reset:
bis.reset();
11 Conversión de Bytes a
Caracteres y Viceversa
// InputStreamReader:
InputStreamReader isr = new InputStreamReader(new FileInputStream("archivo.txt"));

// OutputStreamWriter:
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("archivo.txt"));
12 Escritura de
Caracteres Formateados
// PrintWriter:
PrintWriter pw = new PrintWriter(new FileWriter("archivo.txt"));
13 Otras
Funciones
// Append: // System.in:
FileWriter fw = new FileWriter("archivo.txt", true); Scanner scanner = new Scanner(System.in);
fw.append("Hola, mundo!"); String linea = scanner.nextLine();
// Print: // System.out:
pw.print("Hola, "); System.out.println("Hola, mundo!");
pw.print("mundo!");

// PrintStream: // Println:
PrintStream ps = new PrintStream(new FileOutputStream("archivo.txt")); pw.println("Hola, mundo!");
ps.println("Hola, mundo!");
¡GRACIAS POR SU
ATENCIÓN!
Próxima clase: Presentación de Códigos
 Bibliografía
- Vídeo: Curso completo y gratuito de Java IO
https://www.youtube.com/watch?v=gqrRieAbHws
Autor: makigas: aprende a programar
Fecha: 23 de agosto de 2022

- Documento: Java: Archivos

https://slideplayer.es/slide/5424500/
Autor: Margarita Padilla Flores
Fecha: 2016