Introducción a los archivos y las imágenes

1. Introducción

En programación casi siempre hay que trabajar con archivos. Los ejemplos son conocidos por todos: guardar el texto de una nota, el progreso de un juego, copiar una imagen o leer ajustes desde un archivo de configuración.

En Java hay herramientas modernas y cómodas para ello: Path y Files del paquete java.nio.file. Permiten, en pocas líneas de código, abrir un archivo, leer su contenido, escribir texto o incluso copiar una imagen.

Ruta a un archivo (Path)

Un archivo siempre está en algún lugar del disco y, para acceder a él, hay que indicar la ruta. Para ello en Java está la clase Path, y se puede crear un nuevo objeto con el método Path.of().

Path path = Path.of("hello.txt"); // ruta relativa
Path absPath = Path.of("C:/Users/Me/image.png"); // ruta absoluta (Windows)

Explicación:

• Una ruta relativa busca el archivo en la carpeta actual del proyecto (por ejemplo, "hello.txt").
• Una ruta absoluta indica la dirección completa: unidad, carpetas y nombre de archivo.

2. Trabajo con archivos de texto

Desde el punto de vista de Java, todos los archivos se dividen en 2 tipos — de texto y binarios. Si su contenido puede representarse como texto comprensible para una persona — es un archivo de texto. En todos los demás casos — es simplemente un conjunto de bytes (archivo binario).

Escritura de texto en un archivo — writeString

Para escribir una cadena en un archivo, usamos el método writeString.

Path p = Path.of("hello.txt");
Files.writeString(p, "¡Hola, archivo!");

Qué ha pasado aquí:

1. creamos un objeto Path que apunta a "hello.txt";
2. con el método writeString escribimos ahí la cadena;
3. si el archivo no existía, se creará automáticamente.

Así es fácil guardar notas o mensajes en un archivo de texto.

Lectura de texto desde un archivo — readString

El método readString permite cargar todo el archivo de una vez en una cadena.

Path p = Path.of("hello.txt");
String content = Files.readString(p);
System.out.println(content);

Ahora en la variable content se guarda el contenido del archivo. Es útil para archivos pequeños: configuraciones, textos y documentos JSON.

3. Trabajo con archivos binarios

No todos los archivos constan de texto. Imágenes, música, archivos comprimidos — son conjuntos de bytes. Para trabajar con ellos hay métodos write y readAllBytes.

Escritura de bytes en un archivo — write

El método write() permite escribir en un archivo un array de bytes. También se le llama búfer (byte buffer).

byte[] data = {65, 66, 67, 68}; // caracteres A B C D
Files.write(Path.of("letters.bin"), data);

Aquí hemos escrito en el archivo un array de bytes. Si lo abres como texto, dentro aparecerán las letras "ABCD".

Lectura de bytes — readAllBytes

Para obtener de vuelta el contenido del archivo en forma de array de bytes, usamos el método readAllBytes.

byte[] buffer = Files.readAllBytes(Path.of("letters.bin"));

// imprimimos en pantalla el array de bytes leído
for (byte b : buffer) 
{
    System.out.print((char)b + " ");
}

Aparecerá en pantalla:

A B C D

Este método se utiliza para trabajar con cualquier archivo binario — imágenes, documentos, música.

4. Escenarios populares de trabajo con archivos

El escenario más popular de trabajo con archivos es, probablemente, copiar un archivo.

Copiar archivos

Para copiar un archivo, se puede simplemente leerlo en un array de bytes y escribirlo en otro archivo.

Path in = Path.of("logo.png");
Path out = Path.of("logo_copy.png");

byte[] bytes = Files.readAllBytes(in);
Files.write(out, bytes);

De este modo se pueden copiar imágenes, documentos y cualquier otro archivo, sin preocuparse por su formato.

Comprobar existencia y tamaño

A veces hay que asegurarse de que el archivo existe y conocer su tamaño. Para ello están los métodos exists y size.

Path p = Path.of("hello.txt");
if (Files.exists(p)) 
{
    long size = Files.size(p);
    System.out.println("Archivo encontrado, tamaño: " + size + " bytes");
} 
else 
{
    System.out.println("¡Archivo no encontrado!");
}

Esto es útil para el diagnóstico: sabrás con certeza si estás trabajando con el archivo correcto.

5. Excepciones

El trabajo con archivos puede terminar con un error: no existe el archivo, no hay permisos de acceso, el disco está lleno o el archivo está ocupado por otro programa. Por eso hay que envolver el trabajo con el disco en try-catch, o bien propagar las excepciones hacia fuera con throws.

try 
{
    String content = Files.readString(Path.of("hello.txt"));
    System.out.println(content);
} 
catch (IOException e) 
{
    System.out.println("Error al leer: " + e.getMessage());
}

De este modo, el programa no se «caerá», sino que informará al usuario de forma clara de lo que ha ocurrido. Si es necesario, se puede propagar la excepción IOException más arriba en la pila de llamadas mediante un método con la palabra clave throws.