Entrada/Salida de Archivos
## Objetivos de Aprendizaje
- Leer y escribir archivos de texto
- Trabajar con archivos binarios
- Usar try-with-resources
- Manejar excepciones de E/S
## Lectura de Archivos
### Scanner (Simple)
```java
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
try (Scanner scanner = new Scanner(new File("input.txt"))) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
}
} catch (FileNotFoundException e) {
System.out.println("File not found: " + e.getMessage());
}
```
### BufferedReader (Eficiente)
```java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
```
## Escritura de Archivos
### FileWriter (Simple)
```java
import java.io.FileWriter;
import java.io.IOException;
try (FileWriter writer = new FileWriter("output.txt")) {
writer.write("Hello, World!\n");
writer.write("Second line");
} catch (IOException e) {
e.printStackTrace();
}
```
### BufferedWriter (Eficiente)
```java
import java.io.BufferedWriter;
import java.io.FileWriter;
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello");
writer.newLine();
writer.write("World");
} catch (IOException e) {
e.printStackTrace();
}
```
## Flujos Bufferizados
### Por qué Buffer?
| Clase | Caso de Uso |
|-------|-------------|
| BufferedReader | Leer texto eficientemente |
| BufferedWriter | Escribir texto eficientemente |
| BufferedInputStream | Leer binario eficientemente |
| BufferedOutputStream | Escribir binario eficientemente |
## Archivos Binarios
### DataInputStream / DataOutputStream
```java
// Escritura
try (DataOutputStream out = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream("data.bin")))) {
out.writeInt(42);
out.writeDouble(3.14);
out.writeUTF("Hello");
} catch (IOException e) {
e.printStackTrace();
}
// Lectura
try (DataInputStream in = new DataInputStream(
new BufferedInputStream(new FileInputStream("data.bin")))) {
int num = in.readInt();
double d = in.readDouble();
String s = in.readUTF();
} catch (IOException e) {
e.printStackTrace();
}
```
## Serialización de Objetos
### Serializar Objetos
```java
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
### Escribir/Leer Objetos
```java
import java.io.*;
try (ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("person.bin"))) {
Person p = new Person("Alice", 25);
out.writeObject(p);
} catch (IOException e) {
e.printStackTrace();
}
try (ObjectInputStream in = new ObjectInputStream(
new FileInputStream("person.bin"))) {
Person p = (Person) in.readObject();
System.out.println(p.name + " - " + p.age);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
```
## Clase File
### Operaciones de Archivo
```java
import java.io.File;
File file = new File("example.txt");
// Verificar propiedades
file.exists();
file.isFile();
file.isDirectory();
file.length(); // Tamaño del archivo en bytes
file.lastModified(); // Timestamp
// Crear/Eliminar
file.createNewFile();
file.mkdir(); // Crear directorio
file.mkdirs(); // Crear directorio + padres
file.delete();
// Renombrar
file.renameTo(new File("new_name.txt"));
```
### Listar Directorio
```java
File dir = new File("myfolder");
if (dir.isDirectory()) {
File[] files = dir.listFiles();
for (File f : files) {
System.out.println(f.getName() + " - " + (f.isFile() ? "File" : "Dir"));
}
}
```
## Path (Java NIO)
### Manejo Moderno de Rutas
```java
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("folder", "subfolder", "file.txt");
// Operaciones
path.getFileName();
path.getParent();
path.getRoot();
path.toAbsolutePath();
path.normalize(); // Remover redundancias
// Operaciones de archivo
Files.exists(path);
Files.readAllLines(path);
Files.write(path, "content".getBytes());
```
## Leer Todas las Líneas
### One-Liner Java 11+
```java
import java.nio.file.Files;
String content = Files.readString(Path.of("file.txt"));
List lines = Files.readAllLines(Path.of("file.txt"));
```
## Rutas de Archivos
### Separadores
```java
// Usar File.separator o /
String path = "folder" + File.separator + "file.txt";
String path2 = "folder/file.txt";
// O Path
Path path3 = Paths.get("folder", "file.txt");
```
## Try-with-Resources
### Auto-Cierre
```java
try (Scanner scanner = new Scanner(new File("input.txt"));
FileWriter writer = new FileWriter("output.txt")) {
// Usar scanner y writer
} catch (IOException e) {
e.printStackTrace();
}
```
## Patrones Comunes
### Copiar Archivo
```java
Files.copy(source, target);
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
```
### Leer Archivo Completo
```java
String content = Files.readString(Path.of("file.txt"));
```
### Escribir Archivo Completo
```java
Files.writeString(Path.of("file.txt"), "content");
```
## Resumen
- Usar Scanner para entrada simple; BufferedReader para lectura eficiente de texto
- Usar FileWriter para salida simple; BufferedWriter para escritura eficiente
- Clase File para operaciones de archivo/directorio
- Path (NIO) para manejo moderno de archivos
- Try-with-resources para limpieza automática
- Serializable para persistencia de objetos
- Clase Files para operaciones comunes
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →