Java - Bestanden en I/O

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 stromen vertegenwoordigen een invoerbron en een uitvoerbestemming. De stream in het java.io-pakket ondersteunt veel gegevens zoals primitieven, objecten, gelokaliseerde tekens, enz.

Streamen

Een stroom kan worden gedefinieerd als een reeks gegevens. Er zijn twee soorten streams −

• InPutStream − De InputStream wordt gebruikt om gegevens van een bron te lezen.

• OutPutStream − De OutputStream wordt gebruikt om gegevens naar een bestemming te schrijven.

Java biedt krachtige maar flexibele ondersteuning voor I/O met betrekking tot bestanden en netwerken, maar deze tutorial behandelt zeer basisfunctionaliteit met betrekking tot streams en I/O. We zullen de meest gebruikte voorbeelden één voor één bekijken −

Bytestreams

Java-bytestreams worden gebruikt om invoer en uitvoer van 8-bits bytes uit te voeren. Hoewel er veel klassen zijn die verband houden met bytestreams, maar de meest gebruikte klassen zijn, FileInputStream en FileOutputStream . Hieronder volgt een voorbeeld dat gebruik maakt van deze twee klassen om een ​​invoerbestand naar een uitvoerbestand te kopiëren −

Voorbeeld

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 −

This is test for copy file.

Als volgende stap compileert u het bovenstaande programma en voert u het uit, wat resulteert in het maken van een output.txt-bestand met dezelfde inhoud als in input.txt. Dus laten we de bovenstaande code in het bestand CopyFile.java plaatsen en het volgende doen −

$javac CopyFile.java
$java CopyFile

Karakterstreams

Java Byte streams worden gebruikt om invoer en uitvoer van 8-bits bytes uit te voeren, terwijl Java Teken streams worden gebruikt om invoer en uitvoer uit te voeren voor 16-bits unicode. Hoewel er veel klassen zijn die verband houden met tekenstromen, maar de meest gebruikte klassen zijn, 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.

We kunnen het bovenstaande voorbeeld herschrijven, waarbij deze twee klassen worden gebruikt om een ​​invoerbestand (met unicode-tekens) naar een uitvoerbestand te kopiëren −

Voorbeeld

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 −

This is test for copy file.

Als volgende stap compileert u het bovenstaande programma en voert u het uit, wat resulteert in het maken van een output.txt-bestand met dezelfde inhoud als in input.txt. Dus laten we de bovenstaande code in het bestand CopyFile.java plaatsen en het volgende doen −

$javac CopyFile.java
$java CopyFile

Standaard streams

Alle programmeertalen bieden ondersteuning voor standaard I/O waarbij het programma van de gebruiker invoer van een toetsenbord kan nemen en vervolgens een uitvoer op het computerscherm kan produceren. Als je bekend bent met C of C++; programmeertalen, dan moet u op de hoogte zijn van drie standaardapparaten STDIN, STDOUT en STDERR. Evenzo biedt Java de volgende drie standaardstreams −

• Standaard invoer − Dit wordt gebruikt om de gegevens naar het programma van de gebruiker te sturen en meestal wordt een toetsenbord gebruikt als standaard invoerstroom en weergegeven als System.in .

• Standaard uitvoer − Dit wordt gebruikt om de gegevens uit te voeren die door het gebruikersprogramma zijn geproduceerd en meestal wordt een computerscherm gebruikt voor de standaard uitvoerstroom en weergegeven als System.out .

• Standaardfout − Dit wordt gebruikt om de foutgegevens uit te voeren die door het gebruikersprogramma zijn geproduceerd en meestal wordt een computerscherm gebruikt voor de standaard foutstroom en weergegeven als System.err .

Hieronder volgt een eenvoudig programma dat InputStreamReader . maakt om de standaard invoerstroom te lezen totdat de gebruiker een "q" typt −

Voorbeeld

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("Enter characters, 'q' to quit.");
         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 het bestand ReadConsole.java houden en proberen het te compileren en uit te voeren zoals weergegeven in het volgende programma. Dit programma blijft hetzelfde teken lezen en uitvoeren totdat we op 'q' drukken −

$javac ReadConsole.java
$java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Bestanden lezen en schrijven

Zoals eerder beschreven, kan een stroom worden gedefinieerd als een reeks gegevens. De InputStream wordt gebruikt om gegevens uit een bron te lezen en de OutputStream wordt gebruikt om gegevens naar een bestemming te schrijven.

Hier is een hiërarchie van klassen om met invoer- en uitvoerstromen om te gaan.

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

FileInputStream

Deze stream wordt gebruikt voor het lezen van gegevens uit de bestanden. Objecten kunnen worden gemaakt met het trefwoord nieuw en er zijn verschillende soorten constructors beschikbaar.

De volgende constructor neemt een bestandsnaam als tekenreeks om een ​​invoerstroomobject te maken om het bestand te lezen −

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

De volgende constructor neemt een bestandsobject om een ​​invoerstroomobject te maken om het bestand te lezen. Eerst maken we als volgt een bestandsobject met de methode File() −

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

Zodra u InputStream . heeft object in de hand, dan is er een lijst met hulpmethoden die kunnen worden gebruikt om te streamen of om andere bewerkingen op de stream uit te voeren.

Er zijn andere belangrijke invoerstromen beschikbaar, voor meer details kunt u de volgende links raadplegen −

• ByteArrayInputStream

• DataInputStream

FileOutputStream

FileOutputStream wordt gebruikt om een ​​bestand te maken en er gegevens in te schrijven. De stream zou een bestand maken, als het nog niet bestaat, voordat het wordt geopend voor uitvoer.

Hier zijn twee constructors die kunnen worden gebruikt om een ​​FileOutputStream-object te maken.

De volgende constructor neemt een bestandsnaam als tekenreeks om een ​​invoerstroomobject te maken om het bestand te schrijven −

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

De volgende constructor neemt een bestandsobject om een ​​uitvoerstroomobject te maken om het bestand te schrijven. Eerst maken we als volgt een bestandsobject met de methode File() −

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

Zodra u OutputStream . heeft object in de hand, dan is er een lijst met hulpmethoden die kunnen worden gebruikt om naar stream te schrijven of om andere bewerkingen op de stream uit te voeren.

Er zijn andere belangrijke uitvoerstromen beschikbaar, voor meer details kunt u de volgende links raadplegen −

• ByteArrayOutputStream

• DataOutputStream

Voorbeeld

Hieronder volgt 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] );   // writes the 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 maken en gegeven getallen in binair formaat schrijven. Hetzelfde zou de uitvoer op het stdout-scherm zijn.

Bestandsnavigatie en I/O

Er zijn verschillende andere lessen die we zouden volgen om de basisprincipes van bestandsnavigatie en I/O te leren kennen.

• Bestandsklasse

• FileReader-klasse

• FileWriter-klasse

Mappen in Java

Een map is een bestand dat een lijst met andere bestanden en mappen kan bevatten. U gebruikt Bestand object om mappen aan te maken, om de beschikbare bestanden in een map op te sommen. Bekijk voor volledige details een lijst met alle methoden die u op File-object kunt aanroepen en wat gerelateerd is aan mappen.

Mappen maken

Er zijn twee handige Bestanden hulpprogramma's die kunnen worden gebruikt om mappen te maken −

• De mkdir( ) methode maakt een map aan en retourneert waar bij succes en onwaar bij mislukking. Een fout geeft aan dat het pad dat is opgegeven in het File-object al bestaat, of dat de map niet kan worden gemaakt omdat het volledige pad nog niet bestaat.

• De mkdirs() methode maakt zowel een map als alle bovenliggende mappen aan.

Het volgende voorbeeld maakt de map "/tmp/user/java/bin" aan −

Voorbeeld

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

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

Opmerking − Java zorgt automatisch voor padscheidingen op UNIX en Windows volgens conventies. Als u een schuine streep (/) gebruikt op een Windows-versie van Java, wordt het pad nog steeds correct opgelost.

Mappen weergeven

U kunt lijst( ) . gebruiken methode geleverd door Bestand object om alle bestanden en mappen die beschikbaar zijn in een map als volgt weer te geven −

Voorbeeld

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Dit levert het volgende resultaat op, gebaseerd op de mappen en bestanden die beschikbaar zijn in uw /tmp map −

Uitvoer

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