Wat is InputStream & Uitgangsstroom? Waarom en wanneer gebruiken we ze?

Iemand legt me uit wat InputStreamen OutputStreamzijn?

Ik ben in de war over de gebruiksscenario’s voor zowel InputStreamals OutputStream.

Als je ook een codefragment zou kunnen toevoegen aan je uitleg, zou dat geweldig zijn. Bedankt!


Antwoord 1, autoriteit 100%

Het doel van InputStreamen OutputStreamis om verschillende manieren van invoer en uitvoer te abstraheren: of de stream nu een bestand, een webpagina of het scherm is materie. Het enige dat telt is dat u informatie van de stream ontvangt (of informatie naar die stream stuurt.)

InputStreamwordt gebruikt voor veel dingen waarvan je leest.

OutputStreamwordt gebruikt voor veel dingen waarnaar u schrijft.

Hier is een voorbeeldcode. Het gaat ervan uit dat de InputStream instren OutputStream osstral zijn gemaakt:

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

Antwoord 2, autoriteit 40%

InputStream wordt gebruikt voor lezen, OutputStream voor schrijven. Ze zijn als decorateurs met elkaar verbonden, zodat u alle verschillende soorten gegevens uit alle verschillende soorten bronnen kunt lezen/schrijven.

U kunt bijvoorbeeld primitieve gegevens naar een bestand schrijven:

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

Om de geschreven inhoud te lezen:

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);

Je kunt andere soorten streams gebruiken om het lezen/schrijven te verbeteren. U kunt bijvoorbeeld een buffer invoeren voor efficiëntie:

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

U kunt andere gegevens zoals objecten schrijven:

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

U kunt lezen uit andere verschillende invoerbronnen:

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);

Voor de meeste invoerstromen is er ook een uitvoerstroom. Je kunt je eigen streams definiëren om speciale dingen te lezen/schrijven en er zijn complexe streams voor het lezen van complexe dingen (er zijn bijvoorbeeld streams voor het lezen/schrijven van ZIP-formaat).


Antwoord 3, autoriteit 17%

Van de Java-zelfstudie:

Een stream is een reeks gegevens.

Een programma gebruikt een invoerstroom om gegevens van een bron te lezen, één item tegelijk:

voer hier de afbeeldingsbeschrijving in

Een programma gebruikt een uitvoerstroom om gegevens één voor één naar een bestemming te schrijven:

voer hier de afbeeldingsbeschrijving in

De hierboven afgebeelde gegevensbron en gegevensbestemming kan alles zijn dat gegevens bevat, genereert of verbruikt. Dit omvat uiteraard schijfbestanden, maar een bron of bestemming kan ook een ander programma, een randapparaat, een netwerkaansluiting of een array zijn.

Voorbeeld codevan oracle tutorial:

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

Dit programma gebruikt bytestreams om het bestand xanadu.txtnaar outagain.txtte kopiëren, door één byte per keer te schrijven

Bekijk deze SE-vraag voor meer details over geavanceerde Character-streams, die wrappers zijn bovenop Byte Streams:

bytestream en karakterstream


Antwoord 4, autoriteit 4%

je leest van een InputStream en schrijft naar een OutputStream.

zeg bijvoorbeeld dat u een bestand wilt kopiëren. U zou een FileInputStream maken om uit het bronbestand te lezen en een FileOutputStream om naar het nieuwe bestand te schrijven.

Als uw gegevens een tekenstroom zijn, kunt u desgewenst een FileReader gebruiken in plaats van een InputStream en een FileWriter in plaats van een OutputStream.

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();

Antwoord 5, autoriteit 2%

OutputStream is een abstracte klasse die schrijfuitvoer vertegenwoordigt. Er zijn veel verschillende OutputStream-klassen en ze schrijven naar bepaalde dingen (zoals het scherm, of bestanden, of byte-arrays, of netwerkverbindingen, enz.). InputStream-klassen hebben toegang tot dezelfde dingen, maar ze lezen er gegevens uit.

Hier is een goed basisvoorbeeldvan het gebruik van FileOutputStream en FileInputStream om gegevens naar een bestand en lees het dan weer in.


Antwoord 6, autoriteit 2%

Een stroom is een continue stroom van vloeistof, lucht of gas.

Java-stream is een gegevensstroom van een bron naar een bestemming. De bron of bestemming kan een schijf, geheugen, socket of andere programma’s zijn. De gegevens kunnen bytes, tekens of objecten zijn. Hetzelfde geldt voor C#- of C++-streams. Een goede metafoor voor Java-stromen is water dat uit een kraan in een badkuip stroomt en later in een afvoer.

De gegevens vertegenwoordigen het statische deel van de stream; de lees- en schrijfmethoden het dynamische deel van de stream.

InputStreamvertegenwoordigt een gegevensstroom van de bron, de OutputStreamvertegenwoordigt een gegevensstroom naar de bestemming.
Ten slotte zijn InputStreamen OutputStreamabstracties over toegang op laag niveau tot gegevens, zoals C-bestandsaanwijzers.


Antwoord 7, autoriteit 2%

Stream: In lekentermen is stream data, de meeste generieke stream is binaire representatie van data.

Invoerstroom: als u gegevens uit een bestand of een andere bron leest, is de gebruikte stroom een ​​invoerstroom. In eenvoudiger bewoordingen fungeert de invoerstroom als een kanaal om gegevens te lezen.

Uitvoerstroom: als u gegevens van een bron (bestand enz.) wilt lezen en verwerken, moet u eerst de gegevens opslaan, de gemiddelde om gegevens op te slaan is uitvoerstroom.


Antwoord 8

Een uitvoerstroom is over het algemeen gerelateerd aan een gegevensbestemming zoals een bestand of een netwerk enz. In Java is een uitvoerstroom een ​​bestemming waar gegevens uiteindelijk worden geschreven en eindigen

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

Antwoord 9

Voor een soort InputStream kun je het zien als een “representatie” van een gegevensbron, zoals een bestand.
Bijvoorbeeld:

FileInputStream fileInputStream = new FileInputStream("/path/to/file/abc.txt");

fileInputStream vertegenwoordigt de gegevens in dit pad, dat u de leesmethode kunt gebruiken om bytes uit het bestand te lezen.

Voor de andere soort InputStream nemen ze een andere inputStream op en voeren ze verdere verwerking uit, zoals decompressie.
Bijvoorbeeld:

GZIPInputStream gzipInputStream = new GZIPInputStream(fileInputStream);

gzipInputStream behandelt fileInputStream als een gecomprimeerde gegevensbron. Als je de read(buffer, 0, buffer.length) methode gebruikt, zal het een deel van het gzip-bestand uitpakken in de buffer die je aanlevert.

De reden waarom we InputStream gebruiken, is omdat naarmate de gegevens in de bron groter en groter worden, laten we zeggen dat we 500 GB gegevens in het bronbestand hebben, we niet alles in het geheugen willen bewaren (dure machine; niet vriendelijk voor GC toewijzing), en we willen sneller resultaat krijgen (het lezen van het hele bestand kan lang duren).

Hetzelfde geldt voor OutputStream. We kunnen een resultaat naar de bestemming verplaatsen zonder te wachten tot het hele ding klaar is, plus minder geheugenverbruik.

Als je meer uitleg en voorbeelden wilt, bekijk dan deze samenvattingen: InputStream, OutputStream, InputStream gebruiken, Hoe OutputStream te gebruiken


Antwoord 10

Ga verder met de geweldige andere antwoorden, in mijn eenvoudige woorden:

Streamen– zoals vermeld is @Sher Mohammad data.

Invoerstream – bijvoorbeeld om invoer – data – uit het bestand te halen. Het geval is wanneer ik een bestand heb (de gebruiker uploadt een bestand – invoer) – en ik wil lezen wat we daar hebben.

OutputStream – is het omgekeerde. U genereert bijvoorbeeld een Excel-bestand en voert het ergens uit.

De “hoe te schrijven” naar het bestand wordt gedefinieerd bij de afzender (de Excel-werkmapklasse) en niet bij de uitvoerstroom van het bestand.

Zie hiervoorbeeld in deze context.

try (OutputStream fileOut = new FileOutputStream("xssf-align.xlsx")) {
    wb.write(fileOut);
}
wb.close();

Other episodes