Java Language
InputStreams en OutputStreams

Syntaxis

• int read (byte [] b) gooit IOException

Opmerkingen

InputStream in een string lezen

Soms wilt u byte-invoer in een string lezen. Om dit te doen moet je iets vinden dat converteert tussen byte en de "native Java" UTF-16 Codepunten die als char . Dat gebeurt met een InputStreamReader .

Om het proces een beetje te versnellen, is het "gebruikelijk" om een buffer toe te wijzen, zodat we niet teveel overhead hebben bij het lezen van Input.

public String inputStreamToString(InputStream inputStream) throws Exception {
     StringWriter writer = new StringWriter();

     char[] buffer = new char[1024];
     try (Reader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"))) {
           int n;
           while ((n = reader.read(buffer)) != -1) {
                // all this code does is redirect the output of `reader` to `writer` in
                // 1024 byte chunks
                writer.write(buffer, 0, n);
           }
     }
     return writer.toString();
}

Het transformeren van dit voorbeeld naar code die compatibel is met Java SE 6 (en lager) wordt weggelaten als oefening voor de lezer.

Bytes schrijven naar een OutputStream

Bytes tegelijkertijd naar een OutputStream schrijven

OutputStream stream = object.getOutputStream();

byte b = 0x00;
stream.write( b );

Een byte-array schrijven

byte[] bytes = new byte[] { 0x00, 0x00 };

stream.write( bytes );

Een sectie van een bytearray schrijven

int offset = 1;
int length = 2;
byte[] bytes = new byte[] { 0xFF, 0x00, 0x00, 0xFF };

stream.write( bytes, offset, length );

Streams sluiten

De meeste streams moeten worden afgesloten als je klaar bent, anders kun je een geheugenlek introduceren of een bestand open laten. Het is belangrijk dat streams worden gesloten, zelfs als een uitzondering wordt gegenereerd.

try(FileWriter fw = new FileWriter("outfilename");
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //handle this however you 
}

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt");
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //handle this however you want
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //typically not much you can do here...
    }
}

Merk op dat het sluiten van een wrapper-stream ook de onderliggende stream zal sluiten. Dit betekent dat u een stream niet kunt verpakken, de verpakking sluit en vervolgens de originele stream blijft gebruiken.

Invoerstroom naar uitvoerstroom kopiëren

Deze functie kopieert gegevens tussen twee streams -

void copy(InputStream in, OutputStream out) throws IOException {
    byte[] buffer = new byte[8192];
    while ((bytesRead = in.read(buffer)) > 0) {
        out.write(buffer, 0, bytesRead);
    }
}

Voorbeeld -

 // reading from System.in and writing to System.out
copy(System.in, System.out);

Invoer- / uitvoerstromen verpakken

OutputStream en InputStream hebben veel verschillende klassen, elk met een unieke functionaliteit. Door een stream om een andere te wikkelen, krijg je de functionaliteit van beide streams.

Je kunt een stream een willekeurig aantal keren inpakken, let gewoon op de bestelling.

Handige combinaties

Tekens naar een bestand schrijven terwijl u een buffer gebruikt

File myFile = new File("targetFile.txt");
PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(myFile)));

Gegevens comprimeren en coderen voordat naar een bestand wordt geschreven terwijl een buffer wordt gebruikt

Cipher cipher = ... // Initialize cipher
File myFile = new File("targetFile.enc");
BufferedOutputStream outputStream = new BufferedOutputStream(new DeflaterOutputStream(new CipherOutputStream(new FileOutputStream(myFile), cipher)));

Lijst van Input / Output Stream-wrappers

DataInputStream Voorbeeld

package com.streams;  
import java.io.*;    
public class DataStreamDemo {  
  public static void main(String[] args) throws IOException {  
    InputStream input = new FileInputStream("D:\\datastreamdemo.txt");  
    DataInputStream inst = new DataInputStream(input);  
    int count = input.available();  
    byte[] arr = new byte[count];  
    inst.read(arr);  
    for (byte byt : arr) {  
      char ki = (char) byt;  
      System.out.print(ki+"-");  
    }  
  }  
}