Sök…


Syntax

  • int read (byte [] b) kastar IOException

Anmärkningar

Observera att du oftast INTE använder InputStream direkt utan använder BufferedStream eller liknande. Detta beror på att InputStream läser från källan varje gång InputStream anropas. Detta kan orsaka betydande CPU-användning när kontext växlar in och ut ur kärnan.

Läsa InputStream in a String

Ibland kanske du vill läsa byte-inmatning i en sträng. För att göra detta måste du hitta något som konverterar mellan byte och den "ursprungliga Java" UTF-16 kodpunkter som används som char . Det görs med en InputStreamReader .

För att påskynda processen lite är det "vanligt" att tilldela en buffert, så att vi inte har för mycket omkostnader när vi läser från Input.

Java SE 7
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();
}

Omvandla detta exempel till Java SE 6 (och lägre) -kompatibel kod lämnas som en övning för läsaren.

Skriva byte till en OutputStream

Skriva byte till en OutputStream en byte åt gången

OutputStream stream = object.getOutputStream();

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

Skriva en byte-grupp

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

stream.write( bytes );

Skriva ett avsnitt av en byte-grupp

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

stream.write( bytes, offset, length );

Stäng strömmar

De flesta strömmar måste stängas när du är klar med dem, annars kan du lägga till en minnesläcka eller lämna en fil öppen. Det är viktigt att bäckar stängs även om ett undantag kastas.

Java SE 7
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 
}

Kom ihåg: försök med resurser garanterar, att resurserna har stängts när blocket lämnas, vare sig det händer med det vanliga kontrollflödet eller på grund av ett undantag.

Java SE 6

Ibland är try-with-resources inte ett alternativ, eller kanske stöder du äldre version av Java 6 eller tidigare. I detta fall är korrekt hantering att använda ett finally block:

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...
    }
}

Observera att stängning av en omslagström också kommer att stänga den underliggande strömmen. Det betyder att du inte kan linda in en ström, stänga inslaget och sedan fortsätta använda den ursprungliga strömmen.

Kopierar ingångsström till utgångsström

Denna funktion kopierar data mellan två strömmar -

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

Exempel -

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

Inpackning av ingångs- / utgångsströmmar

OutputStream och InputStream har många olika klasser, var och en med en unik funktionalitet. Genom att slå en ström runt en annan får du båda strömmarnas funktionalitet.

Du kan slå in en ström som helst, bara notera beställningen.

Användbara kombinationer

Att skriva tecken till en fil medan du använder en buffert

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

Komprimera och kryptera data innan du skriver till en fil medan du använder en buffert

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

Lista med in- / utmatningsströmmar

Omslag Beskrivning
BufferedOutputStream / BufferedInputStream Medan OutputStream skriver data en bit i taget, skriver BufferedOutputStream data i bitar. Detta minskar antalet systemsamtal, vilket förbättrar prestandan.
DeflaterOutputStream / DeflaterInputStream Utför datakomprimering.
InflaterOutputStream / InflaterInputStream Utför datadekompression.
CipherOutputStream / CipherInputStream Krypterar / dekrypterar data.
DigestOutputStream / DigestInputStream Genererar Message Digest för att verifiera dataintegriteten.
CheckedOutputStream / CheckedInputStream Genererar en CheckSum. CheckSum är en mer trivial version av Message Digest.
DataOutputStream / DataInputStream Tillåter skrivning av primitiva datatyper och strängar. Avsedd för att skriva byte. Plattformsoberoende.
Print Tillåter skrivning av primitiva datatyper och strängar. Avsedd för att skriva byte. Plattformberoende.
OutputStreamWriter Konverterar en OutputStream till en Writer. En OutputStream handlar om bytes medan Writers behandlar karaktärer
PrintWriter Ringer automatiskt OutputStreamWriter. Tillåter skrivning av primitiva datatyper och strängar. Strikt för att skriva tecken och bäst för att skriva tecken

DataInputStream-exempel

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+"-");  
    }  
  }  
}


Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow