0Pricing
Java Academy · Lezione

Utility Files: leggere, scrivere, copiare e spostare

Utilizzi Files.readString, writeString, copy, move e delete per le operazioni comuni sui file.

Utility Files: leggere, scrivere, copiare e spostare è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

La classe Files

La classe java.nio.file.Files fornisce metodi statici di utilità per leggere, scrivere, copiare, spostare e interrogare i file. Sostituisce il codice boilerplate prolisso di FileInputStream/FileOutputStream.

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

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

Lettura dei file

Metodi moderni per leggere l'intero contenuto di un file:

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);

Scrittura dei file

Scriva una String o una raccolta di righe in un file con una sola chiamata:

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);

Verifica delle proprietà dei file

Interroghi i metadati di un file senza aprirlo:

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));

Copia dei file

Files.copy(source, target) copia un file. Utilizzi StandardCopyOption per controllarne il comportamento:

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);

Spostamento e ridenominazione dei file

Files.move() sposta o rinomina un file. È possibile eseguire uno spostamento atomico 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);

Eliminazione dei file

Due metodi di eliminazione: uno genera un'eccezione se il file non viene trovato, l'altro 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);

Creazione delle directory

Crei directory, comprese tutte quelle intermedie:

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"));

File e directory temporanei

Crei file temporanei in modo sicuro: la JVM può occuparsi della loro eliminazione:

// 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);

Streaming delle righe con Files.lines

Files.lines() restituisce uno Stream<String> lazy, preferibile a readAllLines per i file di grandi dimensioni poiché non carica tutto in 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

Lettura delle risorse dal classpath

Combini getClass().getResourceAsStream() con la copia NIO per caricare le risorse:

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);
}

Verifica rapida

Quale metodo dovrebbe utilizzare per leggere un file di log di grandi dimensioni senza caricare contemporaneamente tutte le righe in memoria?

Riepilogo: utility Files

Punti chiave:

  • Files.readString/readAllLines/readAllBytes — leggono l'intero file
  • Files.writeString/write — scrivono una stringa o delle righe
  • Files.copy/move con StandardCopyOption — copiano/rinominano/spostano
  • Files.delete/deleteIfExists — eliminazione sicura
  • Files.lines — stream lazy per file di grandi dimensioni (utilizzi try-with-resources)

Domande Frequenti

La lezione «Utility Files: leggere, scrivere, copiare e spostare» è gratuita?

Sì — il testo completo di «Utility Files: leggere, scrivere, copiare e spostare» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Utility Files: leggere, scrivere, copiare e spostare»?

Utilizzi Files.readString, writeString, copy, move e delete per le operazioni comuni sui file. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Utility Files: leggere, scrivere, copiare e spostare»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Path: rappresentare i percorsi dei file
  2. Utility Files: leggere, scrivere, copiare e spostare
  3. Attraversare gli alberi di directory con Files.walk
  4. WatchService: monitorare le modifiche ai file
← Torna a Java Academy