0Pricing
Java Academy · Lección

Utilidad Files: leer, escribir, copiar y mover

Use Files.readString, writeString, copy, move y delete para realizar operaciones habituales con archivos.

Utilidad Files: leer, escribir, copiar y mover es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

La clase Files

La clase java.nio.file.Files proporciona métodos de utilidad estáticos para leer, escribir, copiar, mover y consultar archivos. Sustituye el código repetitivo de FileInputStream/FileOutputStream.

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

Path file = Path.of("example.txt");
// All Files methods throw IOException — handle or propagate

Leer archivos

Métodos modernos para leer todo el contenido de un archivo:

Path path = Path.of("notes.txt");

// Read as a single String (Java 11+)
String content = Files.readString(path);
System.out.println(content);

// Read as List of lines
List<String> lines = Files.readAllLines(path);
lines.forEach(System.out::println);

// Read as byte array
byte[] bytes = Files.readAllBytes(path);

Escribir archivos

Escriba una cadena o una colección de líneas en un archivo con una sola llamada:

Path out = Path.of("output.txt");

// Write a String (overwrites by default)
Files.writeString(out, "Hello, NIO.2!");

// Write with StandardOpenOption.APPEND
Files.writeString(out, "\nAppended line", StandardOpenOption.APPEND);

// Write lines
List<String> lines = List.of("line1", "line2", "line3");
Files.write(out, lines);

Comprobar las propiedades de un archivo

Consulte los metadatos de un archivo sin abrirlo:

Path path = Path.of("data.txt");

System.out.println(Files.exists(path));       // true/false
System.out.println(Files.isRegularFile(path)); // true if not dir
System.out.println(Files.isDirectory(path));   // true if dir
System.out.println(Files.isReadable(path));    // readable?
System.out.println(Files.size(path));          // bytes
System.out.println(Files.getLastModifiedTime(path));

Copiar archivos

Files.copy(source, target) copia un archivo. Use StandardCopyOption para controlar el comportamiento:

Path src = Path.of("original.txt");
Path dst = Path.of("backup.txt");

// Throws if destination exists (default)
Files.copy(src, dst);

// Overwrite if exists:
Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);

// Copy preserving file timestamps:
Files.copy(src, dst, StandardCopyOption.COPY_ATTRIBUTES);

Mover y cambiar el nombre de archivos

Files.move() mueve o cambia el nombre de un archivo. Es posible realizar un movimiento atómico con ATOMIC_MOVE:

Path from = Path.of("temp.txt");
Path to   = Path.of("archive/report_2024.txt");

Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);

// Rename in same directory:
Path renamed = from.resolveSibling("new_name.txt");
Files.move(from, renamed, StandardCopyOption.REPLACE_EXISTING);

Eliminar archivos

Hay dos métodos de eliminación: uno produce una excepción si no se encuentra el archivo y el otro no:

Path file = Path.of("temp.txt");

// Throws NoSuchFileException if file doesn't exist:
Files.delete(file);

// Returns false if file didn't exist (no exception):
boolean deleted = Files.deleteIfExists(file);
System.out.println("Deleted: " + deleted);

Crear directorios

Cree directorios, incluidos todos los intermedios:

Path dir = Path.of("output/reports/2024");

// Creates all missing intermediate directories:
Files.createDirectories(dir);

// Creates a single directory (fails if parent missing):
Files.createDirectory(Path.of("output/reports/2025"));

Archivos y directorios temporales

Cree archivos temporales de forma segura; la JVM puede limpiarlos:

// Temp file in default temp directory
Path tmp = Files.createTempFile("prefix_", ".txt");
Files.writeString(tmp, "temp data");
System.out.println(tmp); // something like /tmp/prefix_12345.txt

// Temp directory
Path tmpDir = Files.createTempDirectory("work_");
System.out.println(tmpDir);

Transmitir líneas con Files.lines

Files.lines() devuelve un Stream<String> diferido, mejor que readAllLines para archivos grandes, ya que no carga todo en memoria:

try (var stream = Files.lines(Path.of("large.log"))) {
    long errorCount = stream
        .filter(l -> l.contains("ERROR"))
        .count();
    System.out.println("Errors: " + errorCount);
} // stream (and underlying reader) closed automatically

Leer recursos del classpath

Combínelo con getClass().getResourceAsStream() y la copia de NIO para cargar recursos:

try (var in = getClass().getResourceAsStream("/config.json")) {
    Path tmp = Files.createTempFile("config", ".json");
    Files.copy(in, tmp, StandardCopyOption.REPLACE_EXISTING);
    String json = Files.readString(tmp);
    System.out.println(json);
}

Comprobación rápida

¿Qué método debe usar para leer un archivo de registro grande sin cargar simultáneamente todas las líneas en memoria?

Resumen: utilidad Files

Aspectos clave:

  • Files.readString/readAllLines/readAllBytes — leen el archivo completo
  • Files.writeString/write — escriben una cadena o líneas
  • Files.copy/move con StandardCopyOption — copian, cambian el nombre o mueven
  • Files.delete/deleteIfExists — eliminan de forma segura
  • Files.lines — flujo diferido para archivos grandes (use try-with-resources)

Preguntas frecuentes

¿La lección «Utilidad Files: leer, escribir, copiar y mover» es gratis?

Sí — el texto completo de «Utilidad Files: leer, escribir, copiar y mover» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Utilidad Files: leer, escribir, copiar y mover»?

Use Files.readString, writeString, copy, move y delete para realizar operaciones habituales con archivos. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Utilidad Files: leer, escribir, copiar y mover»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Path: representación de ubicaciones de archivos
  2. Utilidad Files: leer, escribir, copiar y mover
  3. Recorrido de árboles de directorios con Files.walk
  4. WatchService: supervisión de cambios en archivos
← Volver a Java Academy