Excepties en bestanden in Java

Een exceptie is een object dat een probleem beschrijft dat een actief programma onderbreekt. Het opwerpen ervan stopt de huidige instructie. Java slaat de resterende normale werkzaamheden over totdat een passende exceptieafhandelaar wordt gevonden; zonder zo’n afhandelaar wordt de exceptie teruggegeven via de methoden die de betreffende methode hebben aangeroepen.

Herken het soort probleem

Een ontbrekende puntkomma is een compilatiefout: het programma kan niet compileren. Een exceptie treedt op wanneer gecompileerde code wordt uitgevoerd met gegevens die een probleem veroorzaken.

Array-indexen beginnen bij 0, dus bij lengte 3 zijn de geldige indexen 0, 1 en 2. Voor deling met zwevendekommagetallen gelden andere regels: 10.0 / 0 levert Infinity op; er wordt geen exceptie voor geheeltallige deling opgeworpen.

Lees een stacktrace vanaf de bovenkant

Hier staat een volledige klasse, zonder lege regels vóór de eerste regel:

public class Average {
    static int average(int[] values) {
        int sum = 0;
        for (int value : values) sum += value;
        return sum / values.length;
    }
    public static void main(String[] args) {
        int[] values = new int[0];
        System.out.println(average(values));
    }
}

De array is leeg, dus de lengte is 0. De deling op regel 5 mislukt. De stacktrace is:

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Average.average(Average.java:5)
    at Average.main(Average.java:9)

1. Lees op de eerste regel de exceptieklasse en de melding.
2. Lees het bovenste at-frame voor de plaats waar het probleem is vastgesteld.
3. Lees naar beneden voor de aanroepers: main riep average aan op regel 9.
4. Als de bovenste frames bij de bibliotheek van Java horen, zoek dan het eerste frame dat je eigen klasse noemt. Bij een mislukte Integer.parseInt kunnen bibliotheekframes vóór de aanroep in je code staan.

De stacktrace volgt de aanroepstack, de keten van actieve methodeaanroepen. Die vertelt je waar je moet zoeken, maar de ongeldige waarde kan eerder zijn ontstaan. Hier stelt de deling het probleem vast; de aanroeper gaf de lege array door. Bepaal of lege invoer moet worden afgewezen of afgehandeld voordat je een gemiddelde berekent.

Bekijk het exceptieobject

e.getMessage() geeft de melding terug en kan null teruggeven. e.toString() bevat de klassenaam en, indien aanwezig, de melding. e.printStackTrace() schrijft de stacktrace naar de standaardfoutstroom. Een onderdeel Caused by: toont een eerdere exceptie die in een wrapper is bewaard.

Door de JVM gegenereerde meldingen van NullPointerException geven normaal gesproken aan welke expressie null was. Een expliciet aangemaakte exceptie kan daarentegen een eigen melding of geen melding hebben. Volg de referentie terug naar de plaats waar die een object had moeten krijgen.

Een niet-afgehandelde exceptie die main verlaat, beëindigt de hoofdthread; daarmee eindigt een programma met één thread. Herstel programmeerfouten zoals verkeerde indexen in de code. Bereid herstel voor bij verwachte externe problemen, zoals een ontbrekend bestand of ongeldige gebruikersinvoer.

Exceptieklassen gebruiken de overervingsregels die je al kent. Een opgeworpen object van een subklasse behoort ook tot de superklasse. Dat verklaart zowel de exceptiecategorieën van Java als hoe een passende afhandelaar wordt gevonden.

Volg de hiërarchie

Alleen objecten van Throwable of de subklassen daarvan kunnen worden opgeworpen. Daaronder staan twee hoofdtakken:

Throwable
  Error
    OutOfMemoryError
    StackOverflowError
  Exception
    RuntimeException
      IllegalArgumentException
        NumberFormatException
      NullPointerException
      IndexOutOfBoundsException
        ArrayIndexOutOfBoundsException
    IOException
      FileNotFoundException
      NoSuchFileException

Error beschrijft ernstige fouten van de uitvoeringsomgeving. Een gewone applicatie moet niet proberen te herstellen van een uitgeputte heap of een stack die door eindeloze recursie is uitgeput. Exception beschrijft problemen die een applicatie kan afhandelen, inclusief de tak RuntimeException.

Beide soorten worden tijdens de uitvoering opgeworpen. Het woord “gecontroleerd” beschrijft dat de compiler je afhandeling controleert, niet dat de fout op een eerder moment optreedt. Ongecontroleerd betekent ook niet onschadelijk: een niet-afgehandelde null-referentie kan een programma stoppen.

Pas opvangen of declareren toe

Een bestand lezen kan ook in correcte code mislukken. Een hulpmethode kan de beslissing aan de aanroeper overlaten:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

class Names {
    static List<String> load(Path file) throws IOException {
        return Files.readAllLines(file);
    }
}

Files.readAllLines kan de gecontroleerde IOException opwerpen. De declaratie geeft die mogelijkheid door aan de aanroeper, die de exceptie ook moet opvangen of declareren. Als je throws IOException verwijdert zonder een afhandelaar toe te voegen, compileert de hulpmethode niet. Een methode die Integer.parseInt gebruikt, heeft geen vergelijkbare verplichting van de compiler omdat NumberFormatException ongecontroleerd is.

Gecontroleerde fouten beschrijven vaak omstandigheden waarop een aanroeper zich kan voorbereiden, zoals een bestand dat verdwijnt. Uitvoeringsfouten wijzen vaak op programmeerfouten of ongeldige argumenten. Dat zijn nuttige redenen voor het ontwerp, maar de keten van superklassen bepaalt de categorie. Een eigen klasse die RuntimeException uitbreidt, blijft ongecontroleerd, ook als een aanroeper kan herstellen.

Koppel afhandelaars via overerving

catch (IOException e) kan een FileNotFoundException of NoSuchFileException afhandelen. catch (Exception e) vangt ook uitvoeringsexcepties op; die kan een programmeerfout veranderen in een misleidende invoermelding. catch (Throwable e) bereikt ook de tak Error en is zelden geschikt voor normaal herstel.

Om een onbekende klasse in te delen, volg je de overerving omhoog in de API-documentatie. InputMismatchException breidt NoSuchElementException uit, dat RuntimeException uitbreidt, dus is die ongecontroleerd. InterruptedException breidt Exception uit buiten de uitvoeringstak en is dus gecontroleerd. Een ongecontroleerd type declareren in een throws-clausule is toegestaan, maar verandert de categorie niet.

Een try-blok markeert werkzaamheden die kunnen mislukken. Een passend catch-blok geeft het programma een nuttige volgende actie, zoals om een andere waarde vragen. De exceptie afhandelen probeert de mislukte instructie niet vanzelf opnieuw.

Volg de paden

System.out.println("A");
try {
    System.out.println("B");
    int value = Integer.parseInt("4x");
    System.out.println("C");
} catch (NumberFormatException e) {
    System.out.println("D: " + e.getMessage());
}
System.out.println("E");

De uitvoer is A, B, D: For input string: "4x" en E, elk op een eigen regel. De conversie mislukt, dus slaat Java C over en gaat naar de passende afhandelaar. Wanneer die afhandelaar normaal eindigt, gaat de uitvoering na de volledige instructie verder. Als de conversie slaagt, wordt de afhandelaar overgeslagen. Als het blok een ArithmeticException opwerpt, past deze afhandelaar niet; die exceptie wordt doorgegeven.

Probeer opnieuw met nieuwe invoer

Lees een hele regel voordat je die omzet. De onderstaande lus accepteert een geheel getal en handelt het einde van de toetsenbordinvoer af door te melden dat geen waarde is opgegeven:

import java.util.Scanner;

class WholeNumbers {
    static int readWholeNumber(Scanner in) {
        while (in.hasNextLine()) {
            String line = in.nextLine();
            try {
                return Integer.parseInt(line.trim());
            } catch (NumberFormatException e) {
                System.out.println("Please enter a whole number.");
            }
        }
        throw new IllegalStateException("No number supplied");
    }
}

Bij de invoer “twenty” en “20” geeft de afhandelaar één keer een melding weer, leest de lus een nieuwe regel en retourneert de methode 20. trim() verwijdert omringende witruimte: Integer.parseInt(" 20") mislukt anders. De conversie accepteert een optioneel teken en cijfers die een geheel getal binnen het bereik voorstellen.

Een scanner die met tokens werkt, heeft een andere oplossing nodig. Wanneer nextInt() “ten” tegenkomt, laat de bijbehorende InputMismatchException die token ongelezen. Opvangen en opnieuw nextInt() aanroepen herhaalt de fout eindeloos. Verbruik de ongeldige token met next() of sla de regel over met nextLine() voordat je het opnieuw probeert. hasNextInt() kan een token vóór de conversie controleren.

Houd de herstelde toestand bruikbaar

Een variabele die binnen try is gedeclareerd, bestaat alleen in dat blok. Als latere code het resultaat nodig heeft, declareer die dan erbuiten en laat elk pad dat doorgaat een geldige waarde toewijzen:

int quantity;
try {
    quantity = Integer.parseInt("bad");
} catch (NumberFormatException e) {
    quantity = 0;
}
System.out.println(quantity);

Nul is hier alleen geschikt als het programma die waarde als een geldig alternatief definieert. Als quantity in de afhandelaar geen waarde krijgt, veroorzaakt dat een compilatiefout omdat de variabele niet op alle paden zeker een waarde heeft gekregen.

Vang het specifieke type op dat je kunt afhandelen. Een lege afhandelaar laat het probleem ongemerkt verloren gaan; een brede catch (Exception e) kan een null-referentiefout als een ongeldig getal aanduiden. Bij herstel kun je opnieuw om invoer vragen, één element overslaan, een geldige standaardwaarde kiezen, een fout melden of een betekenisvolle exceptie doorgeven. Controleer bij eenvoudige voorspelbare grenzen eerst: index >= 0 && index < list.size() voorkomt zowel negatieve als te grote lijstindexen.

Een bestand kan ontbreken, onleesbaar zijn of vol onjuist gevormde records staan. Die fouten vragen om verschillende reacties. Met meerdere afhandelaars kan één try ze onderscheiden, terwijl de plaats van het blok bepaalt hoeveel werk stopt als er iets mislukt.

Zet specifieke afhandelaars voorop

Java toetst afhandelaars van boven naar beneden en voert de eerste passende afhandelaar uit. Daarna worden geen andere afhandelaars voor dezelfde exceptie uitgevoerd.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;

class FirstCount {
    static void show(Path file) {
        try {
            int count = Integer.parseInt(Files.readString(file).trim());
            System.out.println(count);
        } catch (NoSuchFileException e) {
            System.out.println("File not found: " + file.toAbsolutePath());
        } catch (IOException e) {
            System.out.println("Could not read: " + file.toAbsolutePath());
        } catch (NumberFormatException e) {
            System.out.println("The file must contain one whole number.");
        }
    }
}

NoSuchFileException breidt IOException uit en moet dus eerst komen. Als je de volgorde omdraait, wordt de specifieke afhandelaar onbereikbaar en compileert de code niet. De conversie-exceptie is niet verwant aan IOException, dus die twee afhandelaars mogen in beide volgordes staan.

Een afhandelaar voor een gecontroleerde exceptie moet ook relevant zijn voor de beschermde werkzaamheden. IOException opvangen rond alleen int count = 5; wordt afgewezen omdat dat blok de exceptie niet kan opwerpen. Deze beperking geldt niet op dezelfde manier voor ongecontroleerde typen of de brede typen Exception en Throwable.

Deel een afhandelaar als de reactie hetzelfde is

Een meervoudige catch-clausule verbindt niet-verwante exceptietypen met |:

try {
    String[] parts = "Ana".split(",");
    int age = Integer.parseInt(parts[1]);
    System.out.println(age);
} catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Invalid record: " + e.getMessage());
}

Hier veroorzaakt het ontbrekende tweede veld de indexexceptie. Een aanwezig veld dat geen getal bevat, zou de conversie-exceptie veroorzaken en beide krijgen dezelfde reactie. De parameter van de meervoudige catch-clausule is impliciet final. Alternatieven kunnen geen subklasse en de bijbehorende superklasse zijn: FileNotFoundException | IOException is ongeldig omdat IOException beide al omvat.

Bepaal wat één fout moet overslaan

Bekijk de teksten “3”, “x” en “5”. Met een try rond de hele lus stopt de verwerking bij “x” en is de som tot dan toe 3. Zet de try binnen de lus om voor elk element afzonderlijk te herstellen:

int sum = 0;
for (String text : new String[] {"3", "x", "5"}) {
    try {
        sum += Integer.parseInt(text);
    } catch (NumberFormatException e) {
        System.out.println("Skipped: " + text);
    }
}
System.out.println(sum);

Dit geeft Skipped: x en daarna 8 weer. De lus gaat verder omdat de lusbody de fout van dat record heeft afgehandeld. Bij geneste afhandelaars wordt vanuit het binnenste beschermde blok naar buiten gezocht; als een binnenste afhandelaar niet past, krijgt een buitenste de kans. Kies de kleinste werkeenheid die in haar geheel moet mislukken: één record voor ongeldige gegevens, de bestandsbewerking voor een leesfout.

Sommige werkzaamheden moeten gebeuren ongeacht of een bewerking slaagt of mislukt. Een finally-blok wordt uitgevoerd wanneer de uitvoering de bijbehorende try-instructie verlaat, ook wanneer een exceptie wordt doorgegeven of een methode terugkeert.

Volg een exceptie zonder passende afhandelaar

try {
    System.out.println("1");
    int[] values = new int[2];
    values[2] = 7;
    System.out.println("2");
} catch (NumberFormatException e) {
    System.out.println("3");
} finally {
    System.out.println("4");
}
System.out.println("5");

Alleen 1 en 4 worden weergegeven voordat de ArrayIndexOutOfBoundsException wordt doorgegeven. Index 2 valt buiten de array met twee elementen. De afhandelaar past niet, maar finally wordt toch uitgevoerd. De instructie die 5 weergeeft, staat buiten het opruimblok en wordt daarom door de doorgegeven exceptie overgeslagen.

Als de beschermde werkzaamheden in plaats daarvan een passende NumberFormatException opwerpen na het weergeven van 1, geeft de afhandelaar 3 weer, geeft de opruimcode 4 weer en gaat de uitvoering verder naar 5. Als alles slaagt, wordt geen afhandelaar uitgevoerd, maar wel de opruimcode.

Retourwaarden worden vóór het opruimen voorbereid

class Cleanup {
    static int result() {
        try {
            return 1;
        } finally {
            System.out.println("cleanup");
        }
    }
}

Eerst wordt de retour­expressie geëvalueerd. Java geeft daarna cleanup weer en de aanroeper ontvangt 1. Een break of continue die een beschermd codegebied verlaat, voert ook de bijbehorende opruimcode uit voordat de overdracht van de uitvoering plaatsvindt.

Houd return buiten finally. Een return 2; daarin zou de wachtende retourwaarde vervangen en zelfs een wachtende exceptie kunnen laten vervallen. Een exceptie die door de opruimcode wordt opgeworpen, kan op dezelfde manier de oorspronkelijke fout vervangen. Opruimcode moet geen tweede concurrerend resultaat opleveren. De compileroptie -Xlint:finally waarschuwt wanneer een finally-blok niet normaal kan eindigen.

Sluit een object alleen als het is geopend

Het oudere handmatige patroon heeft een variabele nodig die zichtbaar is voor het opruimblok:

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.Scanner;

class ManualRead {
    static void firstLine(Path file) throws IOException {
        Scanner sc = null;
        try {
            sc = new Scanner(file, StandardCharsets.UTF_8);
            if (sc.hasNextLine()) System.out.println(sc.nextLine());
            if (sc.ioException() != null) throw sc.ioException();
        } finally {
            if (sc != null) sc.close();
        }
    }
}

Als het openen mislukt, is sc nog steeds null, zodat de controle voorkomt dat de opruimcode een nieuwe null-referentie-exceptie opwerpt. Voor objecten die kunnen worden gesloten, neemt try-with-resources dit beheerwerk weg en handelt het concurrerende fouten veiliger af.

finally biedt geen garantie als de machine stopt. System.exit beëindigt de JVM zonder deze opruimcode uit te voeren; ook een crash of stroomuitval verhindert de uitvoering. Een oneindige lus die het blok nooit verlaat, bereikt de bijbehorende finally evenmin.

Je methoden kunnen ongeldige verzoeken afwijzen voordat ze een object wijzigen. Kies een exceptie die het probleem aanduidt en de aanroeper laat reageren.

Werp direct een object op

class Percentage {
    private int value;

    public void setPercentage(int value) {
        if (value < 0 || value > 100) {
            throw new IllegalArgumentException(
                "percentage must be 0 to 100, was " + value);
        }
        this.value = value;
    }
}

De aanroep setPercentage(120) werpt een exceptie op met de melding percentage must be 0 to 100, was 120. De toewijzing is niet uitgevoerd, dus het veld behoudt zijn vorige waarde. Dit is vroegtijdig afbreken: meld het ongeldige verzoek op de plaats waar je het kunt uitleggen. Dezelfde controle in een constructor voorkomt dat een ongeldig object wordt teruggegeven.

throw heeft een exceptieobject nodig, zoals in throw new IllegalArgumentException("bad quantity");. Een klassenaam alleen is geen object. Een gewone instructie direct na een onvoorwaardelijke throw in hetzelfde blok is onbereikbaar.

Objects.requireNonNull(name, "name must not be null") uit java.util.Objects is een handige controle op null. Een al verzonden bestelling die een extra artikel afwijst, heeft een toestandsprobleem; een negatief aantal artikelen is een argumentprobleem.

Declareer wat de methode kan verlaten

Een hulpmethode die een bestand leest, kan de bijbehorende gecontroleerde fout declareren:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

class NameLoader {
    static List<String> loadNames(Path file) throws IOException {
        return Files.readAllLines(file);
    }
}

throw is een uitvoerbare instructie. throws hoort bij de methodedeclaratie en vertelt aanroepers welke gecontroleerde fouten ze moeten afhandelen. Het vangt een fout niet op en laat de methode na een fout ook niet doorgaan. Elke aanroeper moet IOException opvangen of op zijn beurt declareren. Een catch kan hetzelfde object ook opnieuw opwerpen met throw e;.

Vang een exceptie op waar een nuttige reactie mogelijk is. Een hulpmethode kan de gebruiker meestal niet vragen een ander bestand te kiezen, maar main kan dat wel. “fout” weergeven en een lege lijst teruggeven zou een ontbrekend bestand verwarren met een daadwerkelijk leeg bestand. Bij een klein experiment mag main throws IOException declareren; een afgerond programma handelt verwachte fouten af met nuttige meldingen. Ongecontroleerde typen mogen ter documentatie worden gedeclareerd, ook al vereist de compiler dat niet.

Respecteer het overgeërfde contract

Als een interface read() throws IOException declareert, mag een overschrijvende methode IOException, een specifiekere gecontroleerde subklasse of geen gecontroleerde exceptie declareren. De methode mag de declaratie niet verbreden tot Exception. Ongecontroleerde typen declareren mag wel. Een overschrijving van Object.toString() kan geen IOException toevoegen, omdat de overgeërfde methode geen gecontroleerde excepties declareert. Aanroepen via het interfacetype moeten de gedeclareerde IOException nog steeds afhandelen, ook wanneer een implementatie geen exceptie declareert.

Een standaardexceptie is vaak voldoende. Maak een eigen klasse als aanroepers een specifiek probleem van het programma moeten herkennen, zoals onvoldoende voorraad of een onjuist gevormd gegevensrecord, en er anders op moeten reageren.

Kies de superklasse bewust

Door Exception uit te breiden maak je een gecontroleerde exceptie. Door RuntimeException uit te breiden maak je een ongecontroleerde exceptie. Kies het gecontroleerde ontwerp wanneer aanroepers rekening moeten houden met een domeinfout waarvan herstel mogelijk is; kies het ongecontroleerde ontwerp bij verkeerd gebruik of een programmeerfout.

class OutOfStockException extends Exception {
    public OutOfStockException(String message) {
        super(message);
    }
}

super(message) slaat de melding op via de overgeërfde exceptiefunctionaliteit, zodat getMessage() die teruggeeft. De klassenaam eindigt volgens afspraak op Exception. Extra velden en getters kunnen gestructureerde details beschikbaar maken, zoals het gevraagde en het beschikbare aantal.

Laat de voorraad na een fout ongewijzigd

import java.util.HashMap;

class Inventory {
    private final HashMap<String, Integer> stock = new HashMap<>();

    Inventory() {
        stock.put("pens", 12);
    }

    void remove(String item, int quantity) throws OutOfStockException {
        if (quantity <= 0) {
            throw new IllegalArgumentException("quantity must be positive");
        }
        int available = stock.getOrDefault(item, 0);
        if (quantity > available) {
            throw new OutOfStockException("Requested " + quantity
                + " of " + item + ", only " + available + " in stock");
        }
        stock.put(item, available - quantity);
    }
}

Als je begint met 12 pennen, blijven er na het verwijderen van 5 nog 7 over. Een later verzoek om 10 werpt een exceptie op en er blijven 7 over, omdat de bijwerking na alle controles komt. De aanroeper moet de gecontroleerde voorraadexceptie afhandelen of declareren; de exceptie voor een ongeldig aantal is ongecontroleerd. Een programma dat een afzonderlijke reactie op een onbekend artikel nodig heeft, kan een verwante UnknownItemException gebruiken, met beide domeintypen onder een basisklasse InventoryException.

Pak in zonder het oorspronkelijke probleem te verliezen

Een parser kan een conversiefout van een lager niveau omzetten in een fout op recordniveau:

class InvalidRecordException extends Exception {
    public InvalidRecordException(String message) {
        super(message);
    }
    public InvalidRecordException(String message, Throwable cause) {
        super(message, cause);
    }
}

Binnen de parsemethode kan een afhandelaar dit doen:

catch (NumberFormatException e) {
    throw new InvalidRecordException(
        "Line 3: quantity is not a number: x", e);
}

De wrapper geeft de aanroeper een betekenisvolle categorie en een regelnummer. De methode getCause() geeft de oorspronkelijke NumberFormatException terug en een weergegeven stacktrace behoudt een onderdeel Caused by:. Als je een nieuwe exceptie maakt met alleen de oude melding, gaan het oorspronkelijke object en de bijbehorende stacktrace verloren.

java.io.UncheckedIOException is een kant-en-klare ongecontroleerde wrapper speciaal voor IOException. De constructoren accepteren de oorzaak, met een optionele melding. De wrapper kan een bestandsfout doorgeven via een overschrijvende methode die geen gecontroleerde declaratie mag toevoegen. Inpakken verandert het type dat de aanroeper ziet; het herstelt het bestandsprobleem niet. Gebruik voor gewone beslissingen in een lus voorwaarden en break, zonder excepties te bedenken voor het normale verloop.

Een bestand slaat bytes op, terwijl je programma met tekens en getallen werkt. Voor een geslaagde leesbewerking zijn de juiste locatie, de juiste tekencodering en een duidelijke afspraak voor regels en tekst met getallen nodig.

Zoek de werkelijke locatie

Een relatief pad begint vanuit de werkmap van het programma. Het begint niet vanuit de map met de broncode. Een absoluut pad begint bij de hoofdmap van het bestandssysteem, zoals /home/ana/data/scores.txt, of bij de hoofdmap van een schijf op Windows.

Path file = Path.of("data", "scores.txt");
System.out.println(System.getProperty("user.dir"));
System.out.println(file.toAbsolutePath());
System.out.println(file.getFileName());

Importeer java.nio.file.Path. Als je deze Path aanmaakt, wordt niets geopend en wordt niet gecontroleerd of iets bestaat. toAbsolutePath() laat zien waar Java zal zoeken en getFileName() geeft scores.txt. Een IDE gebruikt vaak de projectmap als werkmap. Schuine strepen in "data/scores.txt" werken op Windows, Linux en macOS. In een Windows-padliteral met backslashes moeten die worden verdubbeld, zoals in "C:\\data\\scores.txt". Ook de oudere java.io.File stelt een locatie voor; zet de vormen om met toPath() of toFile().

Koppel bytes aan tekens

UTF-8 codeert elk Unicode-teken. Latijnse basistekens nemen één byte in; andere twee tot vier. De tekst “café” bevat vier tekens maar vijf UTF-8-bytes omdat “é” er twee inneemt. Als je die bytes als ISO-8859-1 leest, kan “café” ontstaan. Gebruik de codering die bij het schrijven is gebruikt.

De tekstmethoden van Files gebruiken standaard UTF-8. Klassen zoals FileWriter en een scanner die zonder tekenset is geopend, gebruiken de standaardtekenset, die vanaf Java 18 UTF-8 is; bij oudere installaties kan die anders zijn. Met StandardCharsets.UTF_8 uit java.nio.charset maak je de keuze expliciet. Ongeldige bytes die door Files.readAllLines worden gelezen, leiden tot MalformedInputException, een subklasse van IOException.

Lees regels zonder achtergebleven regeleinden

Met een afsluiting na elke regel hebben “a” en “b” vier bytes nodig met LF-regeleinden en zes met CRLF-regeleinden. BufferedReader.readLine(), Files.readAllLines en Scanner.nextLine() verwijderen herkende regeleinden. Als je een volledige string splitst met split("\n"), blijft de Windows-\r staan, zodat het omzetten van "12\r" met parseInt mislukt. Gebruik bij voorkeur methoden die regels lezen of verwijder de omringende witruimte. System.lineSeparator() en opmaakspecificatie %n produceren het regeleinde van het huidige systeem.

Houd bestanden met getallen consistent

Integer.parseInt accepteert tekst met een geheel getal zonder decimaalteken. Double.parseDouble("3.5") accepteert een punt; Double.parseDouble("3,5") mislukt. Deze parseermethoden negeren de taal- en regio-instelling. Numerieke methoden van Scanner en gewone decimale opmaak volgen die instelling wel, zodat Duitse of Nederlandse instellingen “3,5” kunnen verwachten en “3,50” kunnen produceren. Gebruik scanner.useLocale(Locale.ROOT) en String.format(Locale.ROOT, "%.2f", value) voor gegevens met een decimale punt; importeer java.util.Locale.

Ontbrekende locaties leiden vaak tot NoSuchFileException bij Files of Scanner(Path), terwijl oudere constructoren met een bestandsnaam FileNotFoundException kunnen geven. Ontbrekende toestemming kan AccessDeniedException opleveren. Dit zijn gecontroleerde invoer- en uitvoerfouten: een correcte padexpressie alleen kan ze niet voorkomen.

Een open bestand gebruikt een systeembron van het besturingssysteem. Sluiten geeft die vrij en schrijft de nog aanwezige uitvoer van een bestandsschrijver door. Als je vergeet te sluiten, kun je de limiet voor open bestanden bereiken, gebufferde tekst verliezen of een ander programma verhinderen het bestand te wijzigen.

Declareer systeembronnen in de try-kop

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

class Lines {
    static void show(Path file) throws IOException {
        try (BufferedReader in =
                Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
            String line;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

De kop opent de lezer. De body gebruikt die en Java sluit de lezer wanneer de body normaal eindigt, terugkeert of een exceptie opwerpt. Een afzonderlijke finally is niet nodig. Hier is geen afhandelaar, dus wordt elke gecontroleerde fout nog steeds via throws IOException aan de aanroeper doorgegeven.

Een systeembron moet AutoCloseable implementeren. Die interface declareert close() en staat Exception toe; de subinterface Closeable beperkt de gedeclareerde gecontroleerde fout tot IOException. Bestandslezers, bestandsschrijvers en Scanner voldoen daaraan. Een String niet. Variabelen in de kop zijn impliciet final en beschikbaar in de body, maar niet in de catch- of finally-blokken van die instructie. Java 9 en later staan ook een bestaande final of effectief final variabele toe: try (in) { ... }.

Sluit in omgekeerde volgorde

Scheid systeembronnen met puntkomma’s:

try (BufferedReader in = Files.newBufferedReader(source);
     java.io.BufferedWriter out = Files.newBufferedWriter(target)) {
    String line;
    while ((line = in.readLine()) != null) {
        out.write(line);
        out.newLine();
    }
}

Dit is een blok binnen een methode die IOException declareert, met verschillende paden voor source en target. Java opent eerst in, daarna out, en sluit out vóór in. Als het openen van out mislukt, wordt de al geopende lezer toch gesloten. Als je een schrijver opent op het invoerpad, wordt die invoer afgekapt. Daarom moeten de paden voor deze directe kopie verschillen.

Systeembronnen worden gesloten vóór de catch- en finally-clausules van dezelfde instructie. Die afhandelaars kunnen fouten ontvangen die ontstaan bij het openen, gebruiken of sluiten van de systeembronnen.

Houd de hoofdfout zichtbaar

Stel dat de body een recordexceptie opwerpt en dat het sluiten van de lezer daarna een IOException opwerpt. Try-with-resources geeft de exceptie uit de body door en voegt de sluitfout toe als onderdrukte exceptie. getSuppressed() haalt die op en de stacktrace geeft een onderdeel Suppressed: weer. De oorspronkelijke fout uit de body blijft zichtbaar. Als de body slaagt en alleen het sluiten mislukt, wordt de sluitexceptie normaal doorgegeven.

Bij meerdere fouten tijdens het sluiten probeert Java de overige systeembronnen nog steeds te sluiten. Een gewone finally { resource.close(); } kan daarentegen een wachtende fout uit de body vervangen door een opruimfout.

Gebruik dit patroon voor bestandssysteembronnen die je code zelf beheert. Als je een scanner op System.in sluit, sluit je ook de toetsenbordinvoer van het programma, waardoor later lezen niet meer mogelijk is. Laat het beheer van gedeelde standaardinvoer op programmaniveau in plaats van die in een hulpmethode te sluiten.

Lezen levert tekst op. Parsen geeft die tekst betekenis: een aantal, een leeftijd of een object. Houd die twee bewerkingen gescheiden, zodat een ongeldig record niet lijkt op een mislukte bestandslezing.

Kies hoeveel je in het geheugen bewaart

Importeer java.nio.file.Files en Path, plus de typen voor lezers of collecties die je gebruikt. Tekstmethoden van Files gebruiken standaard UTF-8. Een BufferedReader hoort in try-with-resources en meldt leesfouten met IOException. Door één regel tegelijk te lezen voorkom je dat de hele invoer in het geheugen staat, tenzij je verwerking daarna alle records opslaat.

Ook een scanner moet worden gesloten en heeft een extra foutcontrole nodig:

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.Scanner;

class ScanFile {
    static void show(Path file) throws IOException {
        try (Scanner sc = new Scanner(file, StandardCharsets.UTF_8)) {
            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }
            if (sc.ioException() != null) throw sc.ioException();
        }
    }
}

Bij het openen kan direct een exceptie worden opgeworpen. Tijdens het lezen behandelt Scanner een onderliggende invoer- of uitvoerfout als het einde van de invoer en slaat die op; ioException() maakt de fout beschikbaar. Zonder die laatste controle kan een gedeeltelijke leesbewerking geslaagd lijken.

Tel de daadwerkelijke regels en parse daarna

Verhoog bij de invoerregels “12”, “15”, “abc”, een lege regel en “9” het regelnummer voordat je beslist of je een lege regel overslaat. Zet elke niet-lege regel om met Integer.parseInt(line.trim()) binnen een eigen try. Meld “Line 3: not a number: abc” en ga verder. De som van de geldige getallen is 36 en het aantal is 3, wat een gemiddelde van 12,0 geeft. Bereken (double) sum / count om een resultaat met een deel achter de komma te behouden en controleer eerst of het aantal niet nul is.

Controleer velden voordat je indexen gebruikt

Eenvoudige kommagescheiden gegevens kunnen objecten worden. Hier is de eerste regel een verplichte kopregel; elk volgend record heeft een niet-lege naam en een gehele leeftijd:

String[] parts = line.split(",", -1);
if (parts.length != 2 || parts[0].isBlank() || parts[1].isBlank()) {
    System.out.println("Line " + lineNumber + ": expected name and age");
    continue;
}
try {
    int age = Integer.parseInt(parts[1].trim());
    people.add(new Person(parts[0].trim(), age));
} catch (NumberFormatException e) {
    System.out.println("Line " + lineNumber + ": invalid age");
}

Dit fragment uit de lusbody gaat uit van line, lineNumber, een List<Person> met de naam people en een constructor Person(String, int). Sla de kopregel “name,age” over vóór deze parseerstap; anders mislukt de numerieke conversie van “age”. De records “Ana,34”, “Ben,29” en “Chen,41” hebben samen 104 jaar en gemiddeld ongeveer 34,67 jaar.

Een gewone split(",") laat lege velden aan het einde weg: “Eve,” levert maar één deel op. De limiet -1 behoudt het lege tweede veld, zodat de validatie dit kan melden. Controleer altijd de lengte vóór parts[1]. Alleen splitsen kan niet omgaan met komma’s tussen aanhalingstekens, zoals bij de naam in “"Smith, Ana",34”; voor volledige CSV is een CSV-parser nodig.

Het openen van een uitvoerbestand kan het bestand direct veranderen. Kies vóór het openen van de schrijver tussen vervangen en achteraan toevoegen, en sluit de schrijver aan het einde zodat gebufferde uitvoer niet in het geheugen achterblijft.

Vervangen of achteraan toevoegen

Files.writeString(path, text) schrijft één string. Files.write(path, lines) schrijft een doorloopbare verzameling regels en voegt na elke regel het regelscheidingsteken van het systeem toe, ook na de laatste. Met hun standaardopties maken beide een ontbrekend bestand aan en kappen ze een bestaand bestand af.

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

class RunLog {
    static void recordStart(Path log) throws IOException {
        Files.writeString(log, "started" + System.lineSeparator(),
            StandardCharsets.UTF_8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    }
}

CREATE maakt een nieuw bestand mogelijk; APPEND behoudt oude inhoud en voegt aan het einde toe. Alleen APPEND mislukt als het bestand ontbreekt. Achteraan toevoegen plaatst geen ontbrekend scheidingsteken vóór je tekst: als een bestaand bestand halverwege een regel eindigt, gaan de volgende tekens op die regel verder.

De oudere FileWriter heeft een vlag voor achteraan toevoegen: new FileWriter("log.txt", StandardCharsets.UTF_8, true). Zonder die vlag kapt een nieuwe FileWriter of een PrintWriter met bestandsnaam een bestaand bestand ook af. Open nooit een schrijver die vervangt op invoer die je nog moet lezen.

Kies een schrijver en merk fouten op

BufferedWriter ondersteunt write en newLine() en meldt schrijffouten als gecontroleerde excepties:

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Locale;

class ReportWriter {
    static void write(Path file) throws IOException {
        try (BufferedWriter out =
                Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
            out.write("Readings: 3");
            out.newLine();
            out.write(String.format(Locale.ROOT, "Average: %.2f", 3.0));
            out.newLine();
        }
    }
}

Het bestand heeft twee regels: “Readings: 3” en “Average: 3.00”. Locale.ROOT legt de decimale punt vast. newLine(), println en %n gebruiken allemaal het regeleinde van het platform; een letterlijke \n schrijft op elk systeem LF.

Een PrintWriter biedt de handige methoden print, println en printf, maar die registreren invoer- en uitvoerfouten in plaats van ze op te werpen. checkError() schrijft de buffer door en geeft de foutvlag terug. Als je ook op fouten bij de definitieve sluiting controleert, zorg dan dat je toegang tot de schrijver houdt en controleer na het sluiten. Gebruik BufferedWriter of de Files-methoden voor code die schrijffouten betrouwbaar moet doorgeven.

Maak de kringloop rond

Bestandsschrijvers bufferen uitvoer. flush() stuurt wachtende tekst verder; close() schrijft de buffer door en geeft het bestand vrij. Try-with-resources zorgt dat bij elke manier van verlaten wordt geprobeerd te sluiten, maar kan een schrijfbewerking naar de schijf niet laten slagen.

Om een persoon op te slaan, schrijf je de naam, een komma en de gehele leeftijd, gevolgd door een regeleinde. Maak kommagetallen op met Locale.ROOT, zodat een latere Double.parseDouble ze kan lezen. Een ontbrekende bovenliggende map wordt niet aangemaakt door een bestand te openen: gebruik Files.createDirectories(folder) als het de bedoeling is die aan te maken, of meld de fout. Een schrijfbewerking kan mislukken na het afkappen of na gedeeltelijke uitvoer; gebruik tijdelijke uitvoer en een atomaire verplaatsing wanneer het doelbestand moet worden beschermd.

Een robuust programma voor bestandsverwerking heeft twee herstelniveaus nodig. Een ongeldig record kan worden overgeslagen en gemeld; als het lezen of opslaan van het bestand mislukt, stopt de taak. Bereken een volledig resultaat voordat je het doelbestand aanraakt.

Lezen, valideren, berekenen, opslaan

Het volledige programma hieronder leest de optionele kopregel “date,temperature”, gevolgd door eenvoudige records met twee velden. Datums zijn niet-lege labels; temperaturen zijn eindige getallen in graden Celsius. Het slaat onjuist gevormde records over en meldt die, inclusief lege regels. De geneste gecontroleerde exceptie houdt recordproblemen gescheiden van bestandsproblemen.

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.List;
import java.util.Locale;

public class TemperatureReport {
    static class InvalidRecordException extends Exception {
        InvalidRecordException(String message) { super(message); }
        InvalidRecordException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    static List<String> readLines(Path file) throws IOException {
        return Files.readAllLines(file, StandardCharsets.UTF_8);
    }

    static double parseTemperature(String line, int lineNumber)
            throws InvalidRecordException {
        String[] parts = line.split(",", -1);
        if (parts.length != 2 || parts[0].isBlank()
                || parts[1].isBlank()) {
            throw new InvalidRecordException("Line " + lineNumber
                + ": expected a date label and a temperature");
        }
        try {
            double value = Double.parseDouble(parts[1].trim());
            if (!Double.isFinite(value)) {
                throw new InvalidRecordException("Line " + lineNumber
                    + ": temperature must be finite");
            }
            return value;
        } catch (NumberFormatException e) {
            throw new InvalidRecordException("Line " + lineNumber
                + ": not a number: " + parts[1], e);
        }
    }

    static String summarize(List<String> lines) {
        int count = 0;
        int skipped = 0;
        double sum = 0;
        double min = Double.POSITIVE_INFINITY;
        double max = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i);
            if (i == 0 && line.equals("date,temperature")) continue;
            try {
                double value = parseTemperature(line, i + 1);
                sum += value;
                count++;
                min = Math.min(min, value);
                max = Math.max(max, value);
            } catch (InvalidRecordException e) {
                skipped++;
                System.err.println(e.getMessage());
            }
        }
        if (count == 0) {
            return String.format(Locale.ROOT,
                "No valid readings%nSkipped lines: %d%n", skipped);
        }
        return String.format(Locale.ROOT,
            "Valid readings: %d%nAverage (°C): %.2f%n"
                + "Minimum (°C): %.2f%nMaximum (°C): %.2f%n"
                + "Skipped lines: %d%n",
            count, sum / count, min, max, skipped);
    }

    static void writeSummary(Path file, String text) throws IOException {
        Path target = file.toAbsolutePath();
        Path temp = Files.createTempFile(target.getParent(), "report-", ".tmp");
        try {
            Files.writeString(temp, text, StandardCharsets.UTF_8);
            Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE);
        } catch (IOException e) {
            try {
                Files.deleteIfExists(temp);
            } catch (IOException cleanup) {
                e.addSuppressed(cleanup);
            }
            throw e;
        }
    }

    public static void main(String[] args) {
        Path input = Path.of("readings.csv");
        Path output = Path.of("summary.txt");
        try {
            List<String> lines = readLines(input);
            String report = summarize(lines);
            writeSummary(output, report);
            System.out.println("Saved: " + output.toAbsolutePath());
        } catch (NoSuchFileException e) {
            System.err.println("File or folder not found: " + e.getFile());
        } catch (AtomicMoveNotSupportedException e) {
            System.err.println("Could not save atomically: "
                + output.toAbsolutePath());
        } catch (IOException e) {
            System.err.println("Could not process " + input.toAbsolutePath()
                + " or save " + output.toAbsolutePath() + ": " + e.getMessage());
        }
    }
}

Volg één uitvoering

Gebruik deze vijf invoerregels zonder kopregel:

2026-03-01,4.5
2026-03-02,6.0
2026-03-03,abc
2026-03-04,-1.5
missing comma

Regels 1, 2 en 4 leveren drie geldige metingen op. De som is 9,0; het gemiddelde is 3,00 °C, het minimum is -1,50 °C en het maximum is 6,00 °C. Regels 3 en 5 leveren foutmeldingen op en het rapport vermeldt twee overgeslagen regels. De parseerafhandelaar staat binnen de lus, zodat na elk ongeldig record de latere records bereikbaar blijven. Door totalen pas na geslaagd parsen bij te werken, blijven afgewezen waarden buiten de totalen.

Double.parseDouble accepteert speciale strings zoals “NaN” en “Infinity”. Double.isFinite wijst die hier af omdat ze niet als gewone gemeten temperaturen kunnen dienen. Een leeg bestand, een bestand met alleen een kopregel of uitsluitend ongeldige records bereikt de tak voor een aantal van nul voordat wordt gedeeld of het oorspronkelijke minimum en maximum worden gebruikt.

Bescherm het doelbestand

Het lezen en berekenen zijn voltooid voordat het opslaan begint. Files.writeString opent en sluit zelf een bestand, maar kan mislukken nadat een deel is geschreven. Het programma schrijft daarom naar een tijdelijk bestand in de doelmap, sluit dat en vraagt om ATOMIC_MOVE. De verplaatsing maakt het voltooide resultaat, als de bewerking wordt ondersteund, in één bestandssysteembewerking zichtbaar.

Of een bestaand doelbestand atomair kan worden vervangen, hangt af van de implementatie. Het programma meldt een niet-ondersteunde verplaatsing of vervanging en probeert nooit opnieuw met een niet-atomaire verplaatsing. Een opruimfout wordt aan de oorspronkelijke exceptie toegevoegd in plaats van die te vervangen. Atomaire zichtbaarheid garandeert niet dat het resultaat een stroomuitval overleeft.

Vooraf Files.exists(input) controleren kan de latere leesbewerking niet garanderen: een bestand kan na de controle verdwijnen of ontoegankelijk worden. Handel de daadwerkelijke bewerking af. Probeer voordat je op een verwerkingsprogramma vertrouwt ontbrekende invoer, ontbrekende uitvoermappen, lege bestanden en bestanden met alleen een kopregel, CRLF-regeleinden, tekst met accenttekens en onjuist gevormde records. Gebruikersmeldingen moeten het pad noemen waarbij de fout optrad; voor het opsporen van fouten in een wrapper zijn ook de oorspronkelijke oorzaak en stacktrace nodig.