Java I/O Beheersen: Bestanden, Streams en Invoer/Uitvoer Fundamentals

Het java.io-pakket bevat bijna elke klasse die u ooit nodig zou kunnen hebben om invoer en uitvoer (I/O) in Java uit te voeren. Al deze streams vertegenwoordigen een invoerbron en een uitvoerdestinatie. De stream in het java.io-pakket ondersteunt veel data zoals primitieven, objecten, gelokaliseerde karakters, etc.

Stream

Een stream kan worden gedefinieerd als een sequentie van data. Er zijn twee soorten Streams –

• InPutStream – De InputStream wordt gebruikt om data van een bron te lezen.

• OutPutStream – De OutputStream wordt gebruikt voor het schrijven van data naar een bestemming.

Java biedt sterke maar flexibele ondersteuning voor I/O gerelateerd aan bestanden en netwerken, maar deze tutorial dekt zeer basisfunctionaliteit gerelateerd aan streams en I/O. We zullen de meest gebruikte voorbeelden een voor een bekijken –

Byte Streams

Java byte streams worden gebruikt om invoer en uitvoer van 8-bit bytes uit te voeren. Hoewel er veel klassen gerelateerd aan byte streams zijn, zijn de meest frequente gebruikte klassen FileInputStream en FileOutputStream. Hieronder volgt een voorbeeld dat gebruikmaakt van deze twee klassen om een invoerbestand te kopiëren naar een uitvoerbestand –

import java.io.*;
public class CopyFile {
    public static void main(String args[]) throws IOException {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("input.txt");
            out = new FileOutputStream("output.txt");
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Laten we nu een bestand input.txt hebben met de volgende inhoud –

Dit is een test voor kopiëren bestand.

Als volgende stap, compileer het bovenstaande programma en voer het uit, wat resulteert in het creëren van output.txt bestand met dezelfde inhoud als we in input.txt hebben. Laten we de bovenstaande code in CopyFile.java bestand zetten en het volgende doen –

$javac CopyFile.java
$java CopyFile

Character Streams

Java Byte streams worden gebruikt om invoer en uitvoer van 8-bit bytes uit te voeren, terwijl Java Character streams worden gebruikt om invoer en uitvoer uit te voeren voor 16-bit unicode. Hoewel er veel klassen gerelateerd aan character streams zijn, zijn de meest frequente gebruikte klassen FileReader en FileWriter. Hoewel FileReader intern FileInputStream gebruikt en FileWriter FileOutputStream gebruikt, is het grote verschil hier dat FileReader twee bytes tegelijk leest en FileWriter twee bytes tegelijk schrijft.

We kunnen het bovenstaande voorbeeld herschrijven, dat gebruikmaakt van deze twee klassen om een invoerbestand (met unicode-karakters) te kopiëren naar een uitvoerbestand –

import java.io.*;
public class CopyFile {
    public static void main(String args[]) throws IOException {
        FileReader in = null;
        FileWriter out = null;
        try {
            in = new FileReader("input.txt");
            out = new FileWriter("output.txt");
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Laten we nu een bestand input.txt hebben met de volgende inhoud –

Dit is een test voor kopiëren bestand.

Als volgende stap, compileer het bovenstaande programma en voer het uit, wat resulteert in het creëren van output.txt bestand met dezelfde inhoud als we in input.txt hebben. Laten we de bovenstaande code in CopyFile.java bestand zetten en het volgende doen –

$javac CopyFile.java
$java CopyFile

Standaard Streams

Alle programmeertalen bieden ondersteuning voor standaard I/O waar het programma van de gebruiker invoer kan nemen van een toetsenbord en dan een uitvoer produceren op het computerscherm. Als u bekend bent met C of C++ programmeertalen, dan moet u bekend zijn met drie standaard apparaten STDIN, STDOUT en STDERR. Op dezelfde manier biedt Java de volgende drie standaard streams –

• Standaard Invoer – Dit wordt gebruikt om de data aan het programma van de gebruiker te voeden en meestal wordt een toetsenbord gebruikt als standaard invoerstroom en vertegenwoordigd als System.in.

• Standaard Uitvoer – Dit wordt gebruikt om de data geproduceerd door het programma van de gebruiker uit te voeren en meestal wordt een computerscherm gebruikt voor standaard uitvoerstroom en vertegenwoordigd als System.out.

• Standaard Fout – Dit wordt gebruikt om de foutdata geproduceerd door het programma van de gebruiker uit te voeren en meestal wordt een computerscherm gebruikt voor standaard foutstroom en vertegenwoordigd als System.err.

Het volgende is een eenvoudig programma, dat InputStreamReader creëert om standaard invoerstroom te lezen tot de gebruiker een "q" typt –

import java.io.*;
public class ReadConsole {
    public static void main(String args[]) throws IOException {
        InputStreamReader cin = null;
        try {
            cin = new InputStreamReader(System.in);
            System.out.println("Voer karakters in, 'q' om te stoppen.");
            char c;
            do {
                c = (char) cin.read();
                System.out.print(c);
            } while(c != 'q');
        } finally {
            if (cin != null) {
                cin.close();
            }
        }
    }
}

Laten we de bovenstaande code in ReadConsole.java bestand bewaren en proberen te compileren en uit te voeren zoals getoond in het volgende programma. Dit programma blijft lezen en dezelfde karakter uitvoeren tot we 'q' indrukken –

$javac ReadConsole.java
$java ReadConsole
Voer karakters in, 'q' om te stoppen.
1 1
e e
q q

Bestanden Lezen en Schrijven

Zoals eerder beschreven, kan een stream worden gedefinieerd als een sequentie van data. De InputStream wordt gebruikt om data van een bron te lezen en de OutputStream wordt gebruikt voor het schrijven van data naar een bestemming.

Hier is een hiërarchie van klassen om met Input en Output streams om te gaan.

De twee belangrijke streams zijn FileInputStream en FileOutputStream, die in deze tutorial besproken zullen worden.

FileInputStream

Deze stream wordt gebruikt voor het lezen van data uit bestanden. Objecten kunnen worden gecreëerd met het trefwoord new en er zijn verschillende typen constructors beschikbaar.

De volgende constructor neemt een bestandsnaam als string om een input stream-object te creëren om het bestand te lezen –

InputStream f = new FileInputStream("C:/java/hello");

De volgende constructor neemt een file-object om een input stream-object te creëren om het bestand te lezen. Eerst maken we een file-object met File() methode als volgt –

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Eenmaal u InputStream object in handen heeft, dan is er een lijst van helper-methodes die kunnen worden gebruikt om de stream te lezen of andere operaties op de stream uit te voeren.

Er zijn andere belangrijke input streams beschikbaar, voor meer details kunt u naar de volgende links verwijzen –

• ByteArrayInputStream

• DataInputStream

FileOutputStream

FileOutputStream wordt gebruikt om een bestand te creëren en data in te schrijven. De stream zou een bestand creëren, als het nog niet bestaat, voordat het geopend wordt voor uitvoer.

Hier zijn twee constructors die kunnen worden gebruikt om een FileOutputStream-object te creëren.

De volgende constructor neemt een bestandsnaam als string om een input stream-object te creëren om het bestand te schrijven –

OutputStream f = new FileOutputStream("C:/java/hello")

De volgende constructor neemt een file-object om een output stream-object te creëren om het bestand te schrijven. Eerst maken we een file-object met File() methode als volgt –

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Eenmaal u OutputStream object in handen heeft, dan is er een lijst van helper-methodes, die kunnen worden gebruikt om naar de stream te schrijven of andere operaties op de stream uit te voeren.

Er zijn andere belangrijke output streams beschikbaar, voor meer details kunt u verwijzen naar de volgende links –

• ByteArrayOutputStream

• DataOutputStream

Voorbeeld

Het volgende is het voorbeeld om InputStream en OutputStream te demonstreren –

import java.io.*;
public class fileStreamTest {
    public static void main(String args[]) {
        try {
            byte bWrite[] = {11,21,3,40,5};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // schrijft de bytes
            }
            os.close();
            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
            for(int i = 0; i < size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

De bovenstaande code zou bestand test.txt creëren en de gegeven getallen in binair formaat schrijven. Hetzelfde zou de uitvoer op het stdout-scherm zijn.

Bestandsnavigatie en I/O

Er zijn diverse andere klassen die we zullen doorlopen om de basis van Bestandsnavigatie en I/O te leren kennen.

• File Klasse

• FileReader Klasse

• FileWriter Klasse

Directories in Java

Een directory is een File die een lijst van andere bestanden en directories kan bevatten. U gebruikt File object om directories te creëren, om bestanden beschikbaar in een directory op te sommen. Voor complete details, check een lijst van alle methodes die u kunt aanroepen op File-object en wat gerelateerd is aan directories.

Directories Creëren

Er zijn twee nuttige File utility-methodes, die kunnen worden gebruikt om directories te creëren –

• De mkdir() methode creëert een directory, retourneert true bij succes en false bij falen. Falen geeft aan dat het pad gespecificeerd in het File-object al bestaat, of dat de directory niet kan worden gecreëerd omdat het hele pad nog niet bestaat.

• De mkdirs() methode creëert zowel een directory als alle ouders van de directory.

Het volgende voorbeeld creëert "/tmp/user/java/bin" directory –

import java.io.File;
public class CreateDir {
    public static void main(String args[]) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        // Creëer directory nu.
        d.mkdirs();
    }
}

Compileer en voer de bovenstaande code uit om "/tmp/user/java/bin" te creëren.

Let op – Java zorgt automatisch voor pad-scheidingstekens op UNIX en Windows volgens conventies. Als u een forward slash (/) gebruikt op een Windows-versie van Java, zal het pad nog steeds correct oplossen.

Directories Lijsten

U kunt de list() methode gebruiken die door File object wordt geleverd om alle bestanden en directories beschikbaar in een directory op te sommen als volgt –

import java.io.File;
public class ReadDir {
    public static void main(String[] args) {
        File file = null;
        String[] paths;
        try {
            // maak nieuw file-object
            file = new File("/tmp");
            // array van bestanden en directory-paden
            paths = file.list();
            // voor elke naam in de path-array
            for(String path:paths) {
                // print bestandsnaam en directory-naam
                System.out.println(path);
            }
        } catch (Exception e) {
            // als een fout optreedt
            e.printStackTrace();
        }
    }
}

Dit zal het volgende resultaat produceren gebaseerd op de directories en bestanden beschikbaar in uw /tmp directory –

test1.txt
test2.txt
ReadDir.java
ReadDir.class