Che cos'è InputStream e Output Stream? Perché e quando li usiamo?

Qualcuno mi spiega cosa InputStreame cosa OutputStreamsono?

Sono confuso sui casi d'uso per entrambi InputStreame OutputStream.

Se anche tu potessi includere un frammento di codice per accompagnare la tua spiegazione, sarebbe fantastico. Grazie!

L'obiettivo di InputStreame OutputStreamè quello di astrarre diversi modi di input e output: se lo stream è un file, una pagina web o lo schermo non dovrebbe importare. Tutto ciò che conta è che tu riceva informazioni dallo stream (o invii informazioni nello stream).

InputStream è usato per molte cose da cui leggi.

OutputStream è usato per molte cose a cui scrivi.

Ecco un po 'di codice di esempio. Presuppone InputStream instrche OutputStream osstrsiano già stati creati:

int i;

while ((i = instr.read()) != -1) {
    osstr.write(i);
}

instr.close();
osstr.close();

InputStream viene utilizzato per la lettura, OutputStream per la scrittura. Sono collegati tra loro come decoratori in modo tale da poter leggere / scrivere tutti i diversi tipi di dati da tutti i diversi tipi di fonti.

Ad esempio, è possibile scrivere dati primitivi in ​​un file:

File file = new File("C:/text.bin");
file.createNewFile();
DataOutputStream stream = new DataOutputStream(new FileOutputStream(file));
stream.writeBoolean(true);
stream.writeInt(1234);
stream.close();

Per leggere i contenuti scritti:

File file = new File("C:/text.bin");
DataInputStream stream = new DataInputStream(new FileInputStream(file));
boolean isTrue = stream.readBoolean();
int value = stream.readInt();
stream.close();
System.out.printlin(isTrue + " " + value);

È possibile utilizzare altri tipi di flussi per migliorare la lettura / scrittura. Ad esempio, è possibile introdurre un buffer per l'efficienza:

DataInputStream stream = new DataInputStream(
    new BufferedInputStream(new FileInputStream(file)));

Puoi scrivere altri dati come oggetti:

MyClass myObject = new MyClass(); // MyClass have to implement Serializable
ObjectOutputStream stream = new ObjectOutputStream(
    new FileOutputStream("C:/text.obj"));
stream.writeObject(myObject);
stream.close();

Puoi leggere da altre fonti di input diverse:

byte[] test = new byte[] {0, 0, 1, 0, 0, 0, 1, 1, 8, 9};
DataInputStream stream = new DataInputStream(new ByteArrayInputStream(test));
int value0 = stream.readInt();
int value1 = stream.readInt();
byte value2 = stream.readByte();
byte value3 = stream.readByte();
stream.close();
System.out.println(value0 + " " + value1 + " " + value2 + " " + value3);

Per la maggior parte dei flussi di input esiste anche un flusso di output. Puoi definire i tuoi flussi per leggere / scrivere cose speciali e ci sono flussi complessi per leggere cose complesse (ad esempio ci sono flussi per leggere / scrivere in formato ZIP).

Dal tutorial Java :

Un flusso è una sequenza di dati.

Un programma utilizza un flusso di input per leggere i dati da una fonte, un elemento alla volta:

Un programma utilizza un flusso di output per scrivere i dati in una destinazione, un elemento alla volta:

L'origine e la destinazione dei dati nella foto sopra possono essere qualsiasi cosa che contiene, genera o consuma dati. Ovviamente questo include i file del disco , ma una sorgente o destinazione può anche essere un altro programma, un dispositivo periferico, un socket di rete o un array .

Codice di esempio dal tutorial di Oracle:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyBytes {
    public static void main(String[] args) throws IOException {

        FileInputStream in = null;
        FileOutputStream out = null;

        try {
            in = new FileInputStream("xanadu.txt");
            out = new FileOutputStream("outagain.txt");
            int c;

            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Questo programma usa byte di flussi di copiare xanadu.txt file outagain.txt , scrivendo un byte alla volta

Dai un'occhiata a questa domanda SE per conoscere maggiori dettagli sui flussi di personaggi avanzati, che sono wrapper in cima ai flussi di byte:

flusso di byte e flusso di caratteri

leggi da un InputStream e scrivi in ​​un OutputStream.

per esempio, supponiamo che tu voglia copiare un file. Dovresti creare un FileInputStream per leggere dal file sorgente e un FileOutputStream per scrivere nel nuovo file.

Se i tuoi dati sono un flusso di caratteri, puoi utilizzare un FileReader anziché un InputStream e un FileWriter anziché un OutputStream, se preferisci.

InputStream input = ... // many different types
OutputStream output = ... // many different types

byte[] buffer = new byte[1024];
int n = 0;
while ((n = input.read(buffer)) != -1)
    output.write(buffer, 0, n);

input.close();
output.close();

OutputStream è una classe astratta che rappresenta l'output di scrittura. Esistono molte classi OutputStream diverse e scrivono su determinate cose (come lo schermo, o File, o array di byte, connessioni di rete, ecc.). Le classi InputStream accedono alle stesse cose, ma leggono i dati da esse.

Ecco un buon esempio di base dell'utilizzo di FileOutputStream e FileInputStream per scrivere i dati in un file, quindi rileggerli.

Un flusso è un flusso continuo di liquido, aria o gas.

Il flusso Java è un flusso di dati da un'origine a una destinazione. L'origine o la destinazione possono essere un disco, una memoria, un socket o altri programmi. I dati possono essere byte, caratteri o oggetti. Lo stesso vale per i flussi C # o C ++. Una buona metafora per i flussi Java è l'acqua che scorre da un rubinetto in una vasca da bagno e successivamente in un drenaggio.

I dati rappresentano la parte statica del flusso; i metodi di lettura e scrittura della parte dinamica del flusso.

InputStreamrappresenta un flusso di dati dall'origine, OutputStreamrappresenta un flusso di dati verso la destinazione. Infine, InputStreame OutputStreamsono astrazioni più di accesso di basso livello ai dati, come ad esempio i puntatori file C.

Stream : in parole povere stream è dato, lo stream più generico è la rappresentazione binaria di dati.

Flusso di input : se stai leggendo dati da un file o da qualsiasi altra fonte, il flusso utilizzato è il flusso di input. In termini più semplici, il flusso di input funge da canale per leggere i dati.

Flusso di output : se si desidera leggere ed elaborare i dati da una sorgente (file, ecc.), È innanzitutto necessario salvare i dati, il mezzo per archiviare i dati è il flusso di output.

Un flusso di output è generalmente correlato ad alcune destinazioni di dati come un file o una rete, ecc. Nel flusso di output java è una destinazione in cui i dati vengono infine scritti e termina

import java.io.printstream;

class PPrint {
    static PPrintStream oout = new PPrintStream();
}

class PPrintStream {
    void print(String str) { 
        System.out.println(str)
    }
}

class outputstreamDemo {
    public static void main(String args[]) {
        System.out.println("hello world");
        System.out.prinln("this is output stream demo");
    }
}