Lezioni

In questa lezione analizziamo come scrivere collector personalizzati per lo Stream API tramite Collector e quando ciò è davvero giustificato, nonché come implementare un proprio Spliterator per un'iterazione dei dati efficiente sia sequenziale sia parallela. Esamineremo passo passo i componenti di un collector ( supplier, accumulator, combiner, finisher, characteristics), esempi per multi‑mappe e top‑N, le strategie di trySplit e anche l'impostazione corretta delle caratteristiche ( ORDERED, SIZED, SUBSIZED ecc.).

In questa lezione analizziamo le collezioni immutabili in Java 9+: metodi factory List.of, Set.of, Map.of e Map.ofEntries. Le confronteremo con i wrapper Collections.unmodifiableList, discuteremo le limitazioni (divieto di modifiche, divieto di null, divieto di duplicati per i set e per le chiavi delle mappe), l’ordine degli elementi e le prestazioni. Considereremo il limite di 10 coppie per Map.of e le eccezioni tipiche: UnsupportedOperationException, NullPointerException, IllegalArgumentException. Inoltre esempi pratici su quando tali collezioni semplificano il design e aumentano la thread-safety in lettura.

In questa lezione analizziamo le copie immutabili delle collezioni introdotte in Java 10: List.copyOf, Set.copyOf e Map.copyOf. Scoprirete in cosa differiscono dai wrapper Collections.unmodifiable*, quali vincoli si applicano (divieto di null, immutabilità), quando viene restituito lo stesso oggetto e perché non bisogna fare affidamento su un'implementazione concreta. Sono mostrati scenari pratici d'uso ed errori tipici, inclusa la confusione con Map.of e Map.ofEntries.

In questa lezione analizziamo due approcci alla «protezione» delle collezioni: i wrapper immutabili di Collections.unmodifiable* e i metodi di factory List.of/ Set.of/ Map.of, nonché le strutture thread-safe CopyOnWriteArrayList e CopyOnWriteArraySet dal package java.util.concurrent. Capiremo in cosa un wrapper differisce dalla vera immutabilità, dove tornano utili le strutture CopyOnWrite e quali errori tipici si incontrano nella pratica.

In questa lezione analizziamo le differenze tra collezioni mutabili e immutabili in Java: quando scegliere ArrayList/ HashSet e quando — le collezioni factory di Java 9+ ( List.of, Set.of, Map.of) e le copie tramite copyOf. Discuteremo sicurezza, thread-safety, facilità di debug, insidie dei wrapper Collections.unmodifiableList e casi pratici d'uso, nonché errori tipici e come evitarli.

In Java 21 sono state introdotte le interfacce per collezioni ordinate — SequencedCollection, SequencedSet e SequencedMap. Aggiungono un contratto unificato per lavorare con l'ordine degli elementi: accesso rapido al primo/ultimo elemento e inversione della collezione tramite reversed(). In questa lezione vedremo quali collezioni standard le implementano già, quali metodi sono stati introdotti, come applicarli nel codice reale, nonché errori tipici e sfumature d'uso.

Questa lezione è una guida rapida all’evoluzione dell’I/O su file in Java: dal pacchetto «classico» java.io con le classi File, i flussi FileInputStream/ FileOutputStream e i caratteri Reader/ Writer fino al moderno java.nio.file (NIO.2) con Path, Files e FileSystem. Vedremo in cosa differiscono gli approcci, dove vince l’I/O asincrono, come migrare in sicurezza ( File . toPath() ⇄ Path . toFile()) e analizzeremo anche esempi pratici, una promemoria per la scelta dell’API e gli errori tipici.

In questa lezione analizziamo tre entità chiave dell’API file di Java: lo storico File, l’astrazione moderna del percorso Path di NIO.2 e la classe di utilità‑«coltellino svizzero» Files. Nella pratica vedremo come creare oggetti, convertire File ↔ Path, «concatenare» i percorsi in modo sicuro con resolve, ottenere percorsi relativi con relativize, normalizzarli con normalize ed eseguire operazioni come Files.exists, Files.copy, Files.move, Files.readAllLines/ Files.write. Risultato — una comprensione chiara di quando usare ciascun approccio e quali errori si incontrano più spesso.

In questa lezione vediamo modi rapidi per lavorare con i file tramite le utility java.nio.file.Files: leggiamo l’intero file ( readAllBytes, readAllLines) e scriviamo i dati ( write) con codifica esplicita StandardCharsets.UTF_8. Discuteremo la gestione delle eccezioni IOException, mostreremo esempi pratici, vedremo quando servono le API basate su flussi ( BufferedReader, BufferedWriter) e analizzeremo gli errori tipici.

In questa lezione analizziamo le modalità di lavoro con i file in Java: sovrascrittura e append, combinazioni delle opzioni StandardOpenOption (ad esempio, APPEND, CREATE, TRUNCATE_EXISTING, CREATE_NEW), lavoro con testo e byte tramite Files.write()/ Files.readAllBytes(), quando scegliere gli stream ( BufferedReader/ BufferedWriter) e come gestire correttamente le eccezioni ( IOException ecc.). Molti esempi pratici e analisi degli errori tipici.

Lezione pratica sull’uso del file system tramite java.nio.file: creiamo cartelle con Files.createDirectory e Files.createDirectories, eliminiamo con Files.delete e Files.deleteIfExists, visualizziamo il contenuto con Files.list, analizziamo l’eliminazione ricorsiva con Files.walkFileTree. Esempi passo‑passo, un mini file manager e una sezione con errori tipici ti aiuteranno a lavorare con le cartelle su qualsiasi sistema operativo.

Perché leggere e scrivere file «con un cucchiaino» è costoso: analizziamo come la bufferizzazione accelera l’I/O testuale in Java. Vedremo come BufferedReader e BufferedWriter lavorano sopra FileReader/ FileWriter, useremo la lettura riga per riga tramite readLine(), la scrittura e l’andata a capo tramite write()/ newLine(), lo svuotamento forzato flush(), imposteremo la dimensione del buffer e chiariremo le codifiche tramite InputStreamReader/ OutputStreamWriter. Quando applicare la bufferizzazione, quando no — e quali errori si incontrano più spesso.