¿Qué es la Entrada/Salida de Archivos?
1.1 Entrada/Salida (I/O)
La entrada y salida (Input/Output) se refiere al proceso de transferencia de datos entre dispositivos y programas. Por ejemplo, cuando descargamos archivos desde internet, subimos archivos a la red, o guardamos datos desde la memoria hacia el disco duro, estamos realizando operaciones de entrada/salida de archivos.
La dirección del flujo de datos determina si es una entrada o una salida. Según las convenciones establecidas:
- Entrada (Input): Cuando los datos fluyen hacia el procesador (CPU).
- Salida (Output): Cuando los datos fluyen away del procesador (CPU).
1.2 Archivos
En el contexto de los sistemas operativos, un archivo es una colección de datos almacenada con un nombre específico. Aunque en sistemas operativos muchos recursos se abstraen como archivos, en esta nos centraremos en archivos狭义 (狭义 significa "en sentido estricto"), es decir, los archivos almacenados en discos duros.
Las carpetas también son consideradas archivos, específicamente archivos de directorio, y también se almacenan en el disco duro. En el sistema de archivos, los archivos y directorios forman una estructura de árbol similar a un N-árbol.
1.2.1 Rutas
Para identificar un archivo específico en el sistema, utilizamos rutas. Una ruta es una secuencia de directorios desde el nodo raíz hasta el archivo objetivo.
Existen dos tipos de rutas:
- Ruta absoluta: Comienza con la letra de la unidad (ej: C:, D:).
- Ruta relativa: Comienza desde cualquier directorio especificado.
Los directorios en las rutas se separen con "/" o "\\". Sin embargo, "\" solo funciona en sistemas Windows, mientras que "/" es compatible con todos los sistemas operativos.
Algunos puntos importantes a considerar:
- Uso de "./": Representa el directorio actual. Por ejemplo, si ejecutamos "qq.exe" desde "D:\\QQNT", "./" se refiere a "D:\\QQNT".
- Uso de "../": Representa el directorio padre. Por ejemplo, "../" desde "D:\\QQNT" se refiere a "D\\".
1.2.2 Clasificación de Archivos
Los archivos se pueden clasificar de diferentes maneras. Aquí nos enfocaremos en una clasificación relacionada con la codificación: archivos binarios y archivos de texto.
La diferencia principle es:
- Archivos de texto: Legibles por humanos, se abren correctamente con editores de texto como el Bloc de Notas.
- Archivos binarios: No legibles directamente por humanos, muestran caracteres extraños al abrirse con editores de texto.
Ejemplos comunes:
- Archivos binarios: docx, pdf, pptx, mp4, mp3
- Archivos de texto: md, html, java, c
Los archivos de texto están diseñados para ser leídos por personas, mientras que los archivos binarios están diseñados para ser procesados por programas.
Operaciones en el Sistema de Archivos con Java
Java proporciona la clase File en el paquete java.io para realizar operaciones en el sistema de archivos, como crear, eliminar, renombrar archivos y directorios.
Es importante recordar que al crear un objeto File, la ruta especificada no necesita existir físicamente en el sistema.
Ejemplo 1: Métodos Básicos de la Clase File
package operacionesArchivos;
import java.io.File;
public class EjemploBasico {
public static void main(String[] args) {
// Crear objeto File con ruta absoluta
File archivo = new File("F:/documento.txt");
// Obtener información del archivo
System.out.println("Directorio padre: " + archivo.getParent());
System.out.println("Ruta del archivo: " + archivo.getPath());
System.out.println("Nombre del archivo: " + archivo.getName());
System.out.println("Ruta absoluta: " + archivo.getAbsolutePath());
// Crear objeto File con ruta relativa
File archivoRelativo = new File("./documento.txt");
System.out.println("\nRuta relativa - Directorio padre: " + archivoRelativo.getParent());
System.out.println("Ruta relativa - Nombre del archivo: " + archivoRelativo.getName());
System.out.println("Ruta relativa - Ruta completa: " + archivoRelativo.getPath());
System.out.println("Ruta relativa - Ruta absoluta: " + archivoRelativo.getAbsolutePath());
}
}
Ejemplo 2: Creación y Verificación de Archivos
package operacionesArchivos;
import java.io.File;
import java.io.IOException;
public class CreacionArchivos {
public static void main(String[] args) throws IOException {
File nuevoArchivo = new File("./nuevoDocumento.txt");
// Crear el archivo si no existe
if (!nuevoArchivo.exists()) {
nuevoArchivo.createNewFile();
System.out.println("Archivo creado exitosamente");
} else {
System.out.println("El archivo ya existe");
}
// Verificar propiedades del archivo
System.out.println("El archivo existe: " + nuevoArchivo.exists());
System.out.println("Es un archivo regular: " + nuevoArchivo.isFile());
System.out.println("Es un directorio: " + nuevoArchivo.isDirectory());
}
}
Ejemplo 3: Eliminación de Archivos
package operacionesArchivos;
import java.io.File;
import java.util.Scanner;
public class EliminacionArchivos {
public static void main(String[] args) {
File archivoAEliminar = new File("./temporal.txt");
// Crear archivo para demostración
try {
if (!archivoAEliminar.exists()) {
archivoAEliminar.createNewFile();
}
} catch (IOException e) {
System.out.println("Error al crear archivo: " + e.getMessage());
return;
}
System.out.println("El archivo existe antes de eliminar: " + archivoAEliminar.exists());
// Eliminar archivo cuando el programa termine
archivoAEliminar.deleteOnExit();
System.out.println("Presiona Enter para continuar...");
new Scanner(System.in).nextLine();
System.out.println("El archivo existe después de eliminar: " + archivoAEliminar.exists());
}
}
El método deleteOnExit() es particularmente útil para archivos temporales. Similar a cómo Microsoft Word crea archivos temporales durante la edición, estos se eliminan automáticamente al cerrar el programa. Este mecanismo asegura que los cambios no se pierdan incluso si hay un corte de energía repentino.
Ejemplo 4: Creación de Directorios
package operacionesArchivos;
import java.io.File;
public class CreacionDirectorios {
public static void main(String[] args) {
// Crear directorio simple
File directorioSimple = new File("./directorioSimple");
boolean creadoSimple = directorioSimple.mkdir();
System.out.println("Directorio simple creado: " + creadoSimple);
// Crear estructura de directorios anidados
File directorioAnidado = new File("./directorioAnidado/subdir1/subdir2/subdir3");
boolean creadoAnidado = directorioAnidado.mkdirs();
System.out.println("Directorios anidados creados: " + creadoAnidado);
// Verificar si es un directorio
System.out.println("directorioSimple es directorio: " + directorioSimple.isDirectory());
}
}
Ejemplo 5: Renombrar y Mover Archivos
package operacionesArchivos;
import java.io.File;
public class RenombrarArchivos {
public static void main(String[] args) {
File archivoOriginal = new File("./archivoOriginal.txt");
File archivoDestino = new File("./directorioAnidado/subdir1/subdir2/subdir3/archivoRenombrado.txt");
try {
// Crear archivo original si no existe
if (!archivoOriginal.exists()) {
archivoOriginal.createNewFile();
System.out.println("Archivo original creado para demostración");
}
// Renombrar/mover archivo
boolean renombrado = archivoOriginal.renameTo(archivoDestino);
if (renombrado) {
System.out.println("Archivo renombrado/movido exitosamente");
System.out.println("Archivo original existe: " + archivoOriginal.exists());
System.out.println("Archivo destino existe: " + archivoDestino.exists());
} else {
System.out.println("No se pudo renombrar/mover el archivo");
System.out.println("¿El archivo de destino ya existe? " + archivoDestino.exists());
}
} catch (Exception e) {
System.out.println("Error al renombrar/mover archivo: " + e.getMessage());
}
}
}
Las operaciones en el sistema de archivos se realizan principalmente mediante métodos de la clase File, que proporciona una interfaz sencilla y directa para interactuar con el sistema de archivos del sistema operativo.