Manejo de Archivos en Java

// Para archivos binarios (bytes) - como imágenes
InputStream entrada = new FileInputStream("imagen.png");

// Para archivos de texto (caracteres)
Reader lector = new FileReader("documento.txt");

// Sin buffer: una llamada al sistema por cada carácter (LENTO)
FileReader lento = new FileReader("datos.txt");

// Con buffer: lee bloques grandes, sirve desde memoria (RÁPIDO)
BufferedReader rapido = new BufferedReader(new FileReader("datos.txt"));

import java.nio.file.Path;

// Crear Path desde un String simple
Path archivo = Path.of("datos.txt");

// Crear Path con ruta absoluta en Linux/macOS
Path rutaAbsoluta = Path.of("/home/usuario/documentos/datos.txt");

// Crear Path con ruta absoluta en Windows
Path rutaWindows = Path.of("C:\\Users\\usuario\\datos.txt");

// Crear Path combinando componentes (funciona en cualquier SO)
Path ruta = Path.of("home", "usuario", "documentos", "datos.txt");
// Java automáticamente usa el separador correcto (/ o \)

import java.nio.file.Path;

Path ruta = Path.of("/home/usuario/documentos/informe.txt");

// Obtener solo el nombre del archivo (sin la ruta)
String nombre = ruta.getFileName().toString();    // "informe.txt"

// Obtener el directorio padre
Path padre = ruta.getParent();                    // "/home/usuario/documentos"

// Obtener la raíz del sistema de archivos
Path raiz = ruta.getRoot();                       // "/"

// Convertir ruta relativa a absoluta
Path relativa = Path.of("datos.txt");
Path absoluta = relativa.toAbsolutePath();        // Ej: "/home/usuario/proyecto/datos.txt"

// Combinar rutas (resolver una ruta relativa a partir de otra)
Path directorio = Path.of("/home/usuario");
Path completa = directorio.resolve("documentos/archivo.txt");
// Resultado: "/home/usuario/documentos/archivo.txt"

import java.nio.file.Files;
import java.nio.file.Path;

Path archivo = Path.of("datos.txt");

// Verificar si el archivo o directorio existe
boolean existe = Files.exists(archivo);

// Verificar si es un archivo regular (no directorio ni enlace especial)
boolean esArchivo = Files.isRegularFile(archivo);

// Verificar si es un directorio
boolean esDirectorio = Files.isDirectory(archivo);

// Verificar permisos de acceso
boolean sePuedeLeer = Files.isReadable(archivo);
boolean sePuedeEscribir = Files.isWritable(archivo);
boolean sePuedeEjecutar = Files.isExecutable(archivo);

// Obtener el tamaño del archivo en bytes
long tamanioBytes = Files.size(archivo);

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.io.IOException;

public static void leerArchivoCompleto(String rutaArchivo) {
    Path archivo = Path.of(rutaArchivo);
    
    try {
        // readAllLines() devuelve una Lista con todas las líneas del archivo
        // Cada elemento de la lista es una línea (sin el salto de línea al final)
        List<String> lineas = Files.readAllLines(archivo);
        
        // Recorrer e imprimir cada línea
        for (String linea : lineas) {
            System.out.println(linea);
        }
        
        // También podés acceder por índice:
        // String primeraLinea = lineas.get(0);
        // int cantidadLineas = lineas.size();
        
    } catch (IOException e) {
        System.out.println("Error al leer archivo: " + e.getMessage());
    }
}

import java.io.BufferedReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public static void leerLineaPorLinea(String rutaArchivo) {
    Path archivo = Path.of(rutaArchivo);
    
    // try-with-resources: el BufferedReader se cierra automáticamente
    try (BufferedReader reader = Files.newBufferedReader(archivo)) {
        String linea;
        int numeroLinea = 1;
        
        // readLine() devuelve null cuando llega al final del archivo
        while ((linea = reader.readLine()) != null) {
            System.out.println(numeroLinea + ": " + linea);
            numeroLinea = numeroLinea + 1;
        }
    } catch (IOException e) {
        System.out.println("Error al leer: " + e.getMessage());
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public static String leerComoString(String rutaArchivo) throws IOException {
    Path archivo = Path.of(rutaArchivo);
    return Files.readString(archivo);  // Disponible desde Java 11
}

// Uso:
String contenido = leerComoString("poema.txt");
System.out.println("El archivo tiene " + contenido.length() + " caracteres");

// Podés buscar texto dentro del contenido:
if (contenido.contains("palabra buscada")) {
    System.out.println("Se encontró la palabra");
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.io.IOException;

public static void escribirLineas(String rutaArchivo) {
    Path archivo = Path.of(rutaArchivo);
    
    // Arrays.asList() crea una lista a partir de elementos individuales
    List<String> lineas = Arrays.asList(
        "Primera línea",
        "Segunda línea",
        "Tercera línea"
    );
    
    try {
        // write() crea el archivo si no existe
        // Si el archivo ya existe, lo SOBRESCRIBE completamente
        Files.write(archivo, lineas);
        System.out.println("Archivo escrito correctamente");
    } catch (IOException e) {
        System.out.println("Error al escribir: " + e.getMessage());
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public static void escribirString(String rutaArchivo, String contenido) {
    Path archivo = Path.of(rutaArchivo);
    
    try {
        Files.writeString(archivo, contenido);
        System.out.println("Contenido guardado");
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
}

// Uso:
escribirString("mensaje.txt", "Hola, mundo!\nEsta es la segunda línea.");

import java.io.BufferedWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public static void escribirConBuffer(String rutaArchivo, String[] datos) {
    Path archivo = Path.of(rutaArchivo);
    
    try (BufferedWriter writer = Files.newBufferedWriter(archivo)) {
        for (String linea : datos) {
            writer.write(linea);      // Escribe el texto
            writer.newLine();         // Agrega salto de línea del sistema
        }
    } catch (IOException e) {
        System.out.println("Error al escribir: " + e.getMessage());
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.io.IOException;
import java.util.Collections;

public static void agregarLinea(String rutaArchivo, String nuevaLinea) {
    Path archivo = Path.of(rutaArchivo);
    
    try {
        // Collections.singletonList() crea una lista con un único elemento
        Files.write(archivo, 
                   Collections.singletonList(nuevaLinea),
                   StandardOpenOption.APPEND,   // Agregar al final (no sobrescribir)
                   StandardOpenOption.CREATE);  // Crear el archivo si no existe
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
}

// Uso:
agregarLinea("log.txt", "2024-03-15 10:30:00 - Usuario ingresó al sistema");
agregarLinea("log.txt", "2024-03-15 10:31:15 - Usuario consultó saldo");
// Cada llamada agrega una línea al final del archivo

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

// Crear un directorio simple
Path nuevoDir = Path.of("nuevo_directorio");
Files.createDirectory(nuevoDir);  // Falla si el padre no existe

// Crear directorios anidados (crea todos los padres necesarios)
// Equivalente a "mkdir -p" en Linux
Path directorios = Path.of("a/b/c/d");
Files.createDirectories(directorios);  // Crea a, luego a/b, luego a/b/c, luego a/b/c/d

// Crear archivo vacío
Path nuevoArchivo = Path.of("nuevo.txt");
Files.createFile(nuevoArchivo);  // Falla si ya existe

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.io.IOException;

// Copiar un archivo
Path origen = Path.of("original.txt");
Path destino = Path.of("copia.txt");
Files.copy(origen, destino);  // Falla si destino ya existe

// Copiar sobrescribiendo si ya existe
Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);

// Mover/Renombrar un archivo
Path viejo = Path.of("viejo_nombre.txt");
Path nuevo = Path.of("nuevo_nombre.txt");
Files.move(viejo, nuevo);  // Renombra el archivo

// Mover a otro directorio
Path archivoEnCarpeta = Path.of("carpeta/archivo.txt");
Files.move(origen, archivoEnCarpeta, StandardCopyOption.REPLACE_EXISTING);

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

// Eliminar un archivo
Path aEliminar = Path.of("temporal.txt");

// delete() lanza excepción si el archivo no existe
Files.delete(aEliminar);

// deleteIfExists() no lanza excepción si no existe
// Retorna true si eliminó algo, false si no existía
boolean eliminado = Files.deleteIfExists(aEliminar);
if (eliminado) {
    System.out.println("Archivo eliminado");
} else {
    System.out.println("El archivo no existía");
}

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public static void leerArchivoSeguro(String ruta) {
    Path archivo = Path.of(ruta);
    
    try {
        List<String> lineas = Files.readAllLines(archivo);
        for (String linea : lineas) {
            System.out.println(linea);
        }
        
    } catch (NoSuchFileException e) {
        // Más específica: el archivo no existe
        // e.getFile() devuelve la ruta del archivo que no se encontró
        System.out.println("Error: El archivo no existe: " + e.getFile());
        System.out.println("Verificá que la ruta sea correcta.");
        
    } catch (AccessDeniedException e) {
        // Específica: sin permisos de lectura
        System.out.println("Error: No tenés permisos para leer: " + e.getFile());
        System.out.println("Intentá ejecutar el programa con otros permisos.");
        
    } catch (IOException e) {
        // General: cualquier otro error de I/O no capturado arriba
        System.out.println("Error de I/O inesperado: " + e.getMessage());
    }
}

try {
    // operaciones de archivo
    Files.copy(origen, destino);
} catch (NoSuchFileException | AccessDeniedException e) {
    // Mismo manejo para ambas: problema de acceso al archivo
    System.out.println("No se puede acceder al archivo: " + e.getMessage());
} catch (IOException e) {
    // Otros errores de I/O
    System.out.println("Error de I/O: " + e.getMessage());
}

BufferedReader reader = new BufferedReader(new FileReader("datos.txt"));
String linea = reader.readLine();
// Si readLine() lanza una excepción, nunca llegamos a close()
System.out.println(linea);
reader.close();  // Esta línea no se ejecuta si hubo excepción

import java.io.*;

public static void leerConFinally(String ruta) {
    BufferedReader reader = null;  // Declarar fuera del try para acceder en finally
    
    try {
        reader = new BufferedReader(new FileReader(ruta));
        String linea;
        while ((linea = reader.readLine()) != null) {
            System.out.println(linea);
        }
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    } finally {
        // Este bloque se ejecuta SIEMPRE, haya o no excepción
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                // El close() también puede lanzar excepción
                System.out.println("Error al cerrar: " + e.getMessage());
            }
        }
    }
}

import java.io.*;
import java.nio.file.*;

public static void leerConTryResources(String ruta) {
    Path archivo = Path.of(ruta);
    
    // El recurso se declara dentro de los paréntesis del try
    try (BufferedReader reader = Files.newBufferedReader(archivo)) {
        String linea;
        while ((linea = reader.readLine()) != null) {
            System.out.println(linea);
        }
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
    // reader.close() se llama AUTOMÁTICAMENTE al salir del try
    // Incluso si ocurre una excepción
}

import java.io.*;
import java.nio.file.*;

public static void copiarArchivo(String origen, String destino) {
    Path archivoOrigen = Path.of(origen);
    Path archivoDestino = Path.of(destino);
    
    // Ambos recursos se declaran en el try
    try (BufferedReader reader = Files.newBufferedReader(archivoOrigen);
         BufferedWriter writer = Files.newBufferedWriter(archivoDestino)) {
        
        String linea;
        while ((linea = reader.readLine()) != null) {
            writer.write(linea);
            writer.newLine();
        }
        
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
    // Ambos se cierran automáticamente, en orden INVERSO:
    // Primero writer, luego reader
}

// Scanner implementa AutoCloseable
try (Scanner scanner = new Scanner(System.in)) {
    System.out.print("Ingrese un número: ");
    int numero = scanner.nextInt();
    System.out.println("El doble es: " + (numero * 2));
}
// scanner.close() se llama automáticamente

import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.io.IOException;
import java.util.List;

// Lectura con codificación explícita
List<String> lineas = Files.readAllLines(
    Path.of("datos.txt"), 
    StandardCharsets.UTF_8
);

// Escritura con codificación explícita
Files.write(
    Path.of("salida.txt"),
    lineas,
    StandardCharsets.UTF_8
);

// BufferedReader con codificación explícita
try (BufferedReader reader = Files.newBufferedReader(
        Path.of("datos.txt"), 
        StandardCharsets.UTF_8)) {
    // leer...
}

import java.io.*;

// ❌ Sin buffer: una llamada al sistema por cada byte leído
// Si el archivo tiene 1 millón de bytes = 1 millón de llamadas al sistema
InputStream sinBuffer = new FileInputStream("datos.bin");

// ✅ Con buffer: lee bloques de ~8KB a la vez
// Si el archivo tiene 1 millón de bytes ≈ 125 llamadas al sistema
InputStream conBuffer = new BufferedInputStream(
    new FileInputStream("datos.bin")
);

// NIO.2: Files.newBufferedReader ya incluye buffering automáticamente
BufferedReader reader = Files.newBufferedReader(Path.of("datos.txt"));

// Si por alguna razón usás la API clásica:
// NO hagas esto:
FileReader sinBuffer = new FileReader("datos.txt");

// Hacé esto:
BufferedReader conBuffer = new BufferedReader(new FileReader("datos.txt"));

// Pero mejor aún, usá NIO.2 que ya incluye buffer:
BufferedReader mejor = Files.newBufferedReader(Path.of("datos.txt"));

import java.nio.file.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ProcesadorCSV {
    
    /**
     * Lee un archivo CSV y devuelve los datos como lista de arreglos de String.
     * Cada elemento de la lista es una fila del CSV.
     * Cada arreglo contiene los valores de esa fila (un elemento por columna).
     * 
     * @param rutaArchivo Ruta al archivo CSV
     * @return Lista con los datos (sin el encabezado)
     */
    public static List<String[]> leerCSV(String rutaArchivo) {
        List<String[]> datos = new ArrayList<>();
        Path archivo = Path.of(rutaArchivo);
        
        try (BufferedReader reader = Files.newBufferedReader(archivo)) {
            String linea;
            
            // Saltar la primera línea (encabezado)
            // Si no querés saltarla, comentá esta línea
            reader.readLine();
            
            // Leer el resto de líneas
            while ((linea = reader.readLine()) != null) {
                // split(",") divide el String por comas
                // "Juan,20,7.5" se convierte en ["Juan", "20", "7.5"]
                String[] campos = linea.split(",");
                datos.add(campos);
            }
            
        } catch (NoSuchFileException e) {
            System.out.println("Error: Archivo no encontrado: " + rutaArchivo);
        } catch (IOException e) {
            System.out.println("Error al leer CSV: " + e.getMessage());
        }
        
        return datos;
    }
    
    /**
     * Escribe datos en formato CSV.
     * 
     * @param rutaArchivo Ruta donde guardar el archivo
     * @param encabezados Nombres de las columnas
     * @param datos Lista de filas (cada fila es un arreglo de valores)
     */
    public static void escribirCSV(String rutaArchivo, 
                                   String[] encabezados, 
                                   List<String[]> datos) {
        Path archivo = Path.of(rutaArchivo);
        
        try (BufferedWriter writer = Files.newBufferedWriter(archivo)) {
            // Escribir encabezados
            // String.join(",", encabezados) une los elementos con comas
            // ["nombre", "edad"] se convierte en "nombre,edad"
            writer.write(String.join(",", encabezados));
            writer.newLine();
            
            // Escribir cada fila de datos
            for (String[] fila : datos) {
                writer.write(String.join(",", fila));
                writer.newLine();
            }
            
            System.out.println("CSV escrito: " + datos.size() + " filas");
            
        } catch (IOException e) {
            System.out.println("Error al escribir CSV: " + e.getMessage());
        }
    }
    
    // Ejemplo de uso
    public static void main(String[] args) {
        // Leer un CSV existente
        List<String[]> alumnos = leerCSV("alumnos.csv");
        
        // Procesar los datos
        for (String[] alumno : alumnos) {
            String nombre = alumno[0];
            String edad = alumno[1];
            String promedio = alumno[2];
            System.out.println(nombre + " tiene " + edad + " años");
        }
        
        // Crear datos nuevos
        List<String[]> nuevos = new ArrayList<>();
        nuevos.add(new String[]{"Ana", "19", "9.2"});
        nuevos.add(new String[]{"Pedro", "23", "7.0"});
        
        // Guardar en otro archivo
        String[] columnas = {"nombre", "edad", "promedio"};
        escribirCSV("nuevos_alumnos.csv", columnas, nuevos);
    }
}

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;
import java.io.IOException;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

class LectorArchivosTest {
    
    // JUnit crea este directorio automáticamente antes de cada test
    // y lo elimina automáticamente después
    @TempDir
    Path directorioTemporal;
    
    @Test
    void leerArchivo_conContenido_retornaLineas() throws IOException {
        // Arrange: crear un archivo dentro del directorio temporal
        Path archivo = directorioTemporal.resolve("datos.txt");
        Files.write(archivo, List.of("línea 1", "línea 2", "línea 3"));
        
        // Act: leer el archivo
        List<String> resultado = Files.readAllLines(archivo);
        
        // Assert: verificar
        assertEquals(3, resultado.size());
        assertEquals("línea 1", resultado.get(0));
    }
    
    @Test
    void leerArchivo_vacio_retornaListaVacia() throws IOException {
        // Crear archivo vacío
        Path archivo = directorioTemporal.resolve("vacio.txt");
        Files.createFile(archivo);
        
        List<String> resultado = Files.readAllLines(archivo);
        
        assertTrue(resultado.isEmpty());
    }
}

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;

import static org.junit.jupiter.api.Assertions.*;

class ManejadorArchivosTest {
    
    @TempDir
    Path directorioTemporal;
    
    @Test
    void leerArchivo_noExiste_lanzaNoSuchFileException() {
        // El archivo no existe - nunca lo creamos
        Path archivoInexistente = directorioTemporal.resolve("no_existe.txt");
        
        // assertThrows verifica que se lance la excepción esperada
        assertThrows(NoSuchFileException.class, () -> {
            Files.readAllLines(archivoInexistente);
        });
    }
    
    @Test
    void crearArchivo_yaExiste_lanzaFileAlreadyExistsException() throws IOException {
        Path archivo = directorioTemporal.resolve("existente.txt");
        Files.createFile(archivo);  // Crear el archivo primero
        
        // Intentar crear el mismo archivo de nuevo debe fallar
        assertThrows(FileAlreadyExistsException.class, () -> {
            Files.createFile(archivo);
        });
    }
}

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;
import java.io.IOException;

import static org.junit.jupiter.api.Assertions.*;

class ProcesadorCSVTest {
    
    @TempDir
    Path dirTemp;
    
    @Test
    void procesarCSV_datosValidos_calculaPromedioCorrectamente() throws IOException {
        // ARRANGE: Crear el archivo CSV de entrada
        Path entrada = dirTemp.resolve("notas.csv");
        Files.writeString(entrada, 
            "nombre,nota\n" +
            "Juan,8\n" +
            "María,6\n" +
            "Pedro,10\n"
        );
        
        // ACT: Ejecutar el método que queremos testear
        double promedio = calcularPromedioNotas(entrada);
        
        // ASSERT: Verificar el resultado
        assertEquals(8.0, promedio, 0.001);  // 0.001 es la tolerancia para comparar doubles
    }
    
    @Test
    void procesarCSV_archivoVacio_retornaCero() throws IOException {
        Path entrada = dirTemp.resolve("vacio.csv");
        Files.writeString(entrada, "nombre,nota\n");  // Solo encabezado
        
        double promedio = calcularPromedioNotas(entrada);
        
        assertEquals(0.0, promedio, 0.001);
    }
    
    // Método auxiliar (en un test real, este sería el método que estás testeando)
    private double calcularPromedioNotas(Path archivo) throws IOException {
        var lineas = Files.readAllLines(archivo);
        if (lineas.size() <= 1) return 0.0;  // Solo encabezado
        
        double suma = 0;
        for (int i = 1; i < lineas.size(); i++) {  // Saltear encabezado
            String[] campos = lineas.get(i).split(",");
            suma = suma + Double.parseDouble(campos[1]);
        }
        return suma / (lineas.size() - 1);
    }
}