O que é InputStream e Output Stream? Por que e quando usamos?

Alguém me explica o que é InputStreame o que OutputStreamé?

Estou confuso sobre os casos de uso para ambos InputStreame OutputStream.

Se você também pudesse incluir um trecho de código para acompanhar sua explicação, isso seria ótimo. Obrigado!

O objetivo InputStreame OutputStreamé abstrair maneiras diferentes de entrada e saída: se o fluxo é um arquivo, uma página da Web ou a tela não deve importar. O que importa é que você receba informações do fluxo (ou envie informações para esse fluxo.)

InputStream é usado para muitas coisas que você lê.

OutputStream é usado para muitas coisas nas quais você escreve.

Aqui está um código de exemplo. Ele assume o InputStream instre OutputStream osstrjá foi criado:

int i;

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

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

InputStream é usado para leitura, OutputStream para gravação. Eles são conectados como decoradores um ao outro, para que você possa ler / gravar todos os tipos diferentes de dados de todos os tipos diferentes de fontes.

Por exemplo, você pode gravar dados primitivos em um arquivo:

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

Para ler o conteúdo escrito:

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

Você pode usar outros tipos de fluxos para aprimorar a leitura / gravação. Por exemplo, você pode introduzir um buffer para eficiência:

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

Você pode gravar outros dados, como objetos:

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

Você pode ler de outras fontes de entrada diferentes:

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

Para a maioria dos fluxos de entrada, também existe um fluxo de saída. Você pode definir seus próprios fluxos para ler / escrever coisas especiais e existem fluxos complexos para ler coisas complexas (por exemplo, existem fluxos para leitura / gravação no formato ZIP).

No Tutorial Java :

Um fluxo é uma sequência de dados.

Um programa usa um fluxo de entrada para ler dados de uma fonte, um item de cada vez:

Um programa usa um fluxo de saída para gravar dados em um destino, um item de cada vez:

A fonte de dados e o destino dos dados mostrados acima podem ser qualquer coisa que retém, gera ou consome dados. Obviamente, isso inclui arquivos de disco , mas uma origem ou destino também pode ser outro programa, dispositivo periférico, soquete de rede ou matriz .

Código de exemplo do tutorial da 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();
            }
        }
    }
}

Este byte usos programa de fluxos para copiar xanadu.txt arquivo para outagain.txt , escrevendo um byte de cada vez

Dê uma olhada nesta pergunta SE para saber mais detalhes sobre fluxos de caracteres avançados, que são wrappers sobre os fluxos de bytes:

fluxo de bytes e fluxo de caracteres

você lê de um InputStream e grava em um OutputStream.

por exemplo, suponha que você deseja copiar um arquivo. Você criaria um FileInputStream para ler o arquivo de origem e um FileOutputStream para gravar no novo arquivo.

Se seus dados forem um fluxo de caracteres, você poderá usar um FileReader em vez de um InputStream e um FileWriter em vez de um OutputStream, se preferir.

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 é uma classe abstrata que representa a saída de gravação. Existem muitas classes OutputStream diferentes, e elas gravam em determinadas coisas (como a tela, arquivos, matrizes de bytes ou conexões de rede, etc.). As classes InputStream acessam as mesmas coisas, mas elas lêem dados delas.

Aqui está um bom exemplo básico do uso de FileOutputStream e FileInputStream para gravar dados em um arquivo e, em seguida, lê-los novamente.

Um fluxo é um fluxo contínuo de líquido, ar ou gás.

O fluxo Java é um fluxo de dados de uma origem para um destino. A origem ou destino pode ser um disco, memória, soquete ou outros programas. Os dados podem ser bytes, caracteres ou objetos. O mesmo se aplica aos fluxos de C # ou C ++. Uma boa metáfora para os fluxos Java é a água que escorre de uma torneira para a banheira e depois para a drenagem.

Os dados representam a parte estática do fluxo; os métodos de leitura e gravação são a parte dinâmica do fluxo.

InputStreamrepresenta um fluxo de dados da fonte, OutputStreamrepresenta um fluxo de dados para o destino. Finalmente, InputStreame OutputStreamsão abstrações sobre o acesso de baixo nível aos dados, tais como ponteiros de arquivo C.

Fluxo : em termos leigos, fluxo é dados, o fluxo mais genérico é a representação binária de dados.

Fluxo de entrada : se você estiver lendo dados de um arquivo ou de qualquer outra fonte, o fluxo usado é o fluxo de entrada. Em termos mais simples, o fluxo de entrada atua como um canal para ler dados.

Fluxo de saída : se você deseja ler e processar dados de uma fonte (arquivo etc.), primeiro é necessário salvar os dados, o meio para armazenar dados é o fluxo de saída.

Um fluxo de saída geralmente está relacionado a algum destino de dados, como um arquivo ou uma rede, etc. No fluxo de saída java é um destino em que os dados são eventualmente gravados e terminam

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