¿Qué es InputStream y Output Stream? ¿Por qué y cuándo los usamos?

¿Alguien me explica qué InputStreamy qué OutputStreamson?

Estoy confundido acerca de los casos de uso para ambos InputStreamy OutputStream.

Si también pudiera incluir un fragmento de código para acompañar su explicación, sería genial. ¡Gracias!

El objetivo de InputStreamy OutputStreames abstraer diferentes formas de entrada y salida: si la transmisión es un archivo, una página web o la pantalla no debería importar. Lo único que importa es que reciba información de la transmisión (o envíe información a esa transmisión).

InputStream se usa para muchas cosas de las que lees.

OutputStream se usa para muchas cosas en las que escribes.

Aquí hay un código de muestra. Asume InputStream instry OutputStream osstrya ha sido creado:

int i;

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

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

InputStream se usa para leer, OutputStream para escribir. Están conectados como decoradores entre sí, de modo que puede leer / escribir todos los diferentes tipos de datos de todos los diferentes tipos de fuentes.

Por ejemplo, puede escribir datos primitivos en un archivo:

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 leer los contenidos escritos:

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

Puede usar otros tipos de transmisiones para mejorar la lectura / escritura. Por ejemplo, puede introducir un búfer para la eficiencia:

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

Puede escribir otros datos 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();

Puede leer desde otras fuentes 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 la mayoría de las secuencias de entrada también hay una secuencia de salida. Puede definir sus propias secuencias para leer / escribir cosas especiales y existen secuencias complejas para leer cosas complejas (por ejemplo, hay secuencias para leer / escribir en formato ZIP).

Del tutorial de Java :

Una secuencia es una secuencia de datos.

Un programa usa un flujo de entrada para leer datos de una fuente, un elemento a la vez:

Un programa usa una secuencia de salida para escribir datos en un destino, un elemento a la vez:

El origen de datos y el destino de datos que se muestran arriba pueden ser cualquier cosa que contenga, genere o consuma datos. Obviamente, esto incluye archivos de disco , pero un origen o destino también puede ser otro programa, un dispositivo periférico, un socket de red o una matriz .

Código de muestra del tutorial de 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 trenes de programa para copiar xanadu.txt archivo a outagain.txt , escribiendo un byte a la vez

Eche un vistazo a esta pregunta SE para conocer más detalles sobre las secuencias de caracteres avanzadas, que son envoltorios sobre las secuencias de bytes:

flujo de bytes y flujo de caracteres

lees desde un InputStream y escribes en un OutputStream.

por ejemplo, digamos que desea copiar un archivo. Crearía un FileInputStream para leer del archivo fuente y un FileOutputStream para escribir en el nuevo archivo.

Si sus datos son una secuencia de caracteres, puede usar un FileReader en lugar de un InputStream y un FileWriter en lugar de un OutputStream si lo prefiere.

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 es una clase abstracta que representa la salida de escritura. Hay muchas clases diferentes de OutputStream, y escriben en ciertas cosas (como la pantalla, o Archivos, o conjuntos de bytes, o conexiones de red, etc.). Las clases InputStream acceden a las mismas cosas, pero leen datos de ellas.

Aquí hay un buen ejemplo básico del uso de FileOutputStream y FileInputStream para escribir datos en un archivo y luego volver a leerlo.

Una corriente es un flujo continuo de líquido, aire o gas.

La secuencia de Java es un flujo de datos desde una fuente a un destino. El origen o el destino puede ser un disco, memoria, socket u otros programas. Los datos pueden ser bytes, caracteres u objetos. Lo mismo se aplica a las secuencias de C # o C ++. Una buena metáfora para las corrientes de Java es el agua que fluye de un grifo a una bañera y luego a un drenaje.

Los datos representan la parte estática de la secuencia; Los métodos de lectura y escritura son la parte dinámica de la secuencia.

InputStreamrepresenta un flujo de datos desde el origen, OutputStreamrepresenta un flujo de datos hacia el destino. Finalmente, InputStreamy OutputStreamson abstracciones sobre el acceso de bajo nivel a los datos, como los punteros de archivos C.

Flujo : en términos simples, el flujo es datos, el flujo más genérico es la representación binaria de datos.

Secuencia de entrada : si está leyendo datos de un archivo o de cualquier otra fuente, la secuencia utilizada es la secuencia de entrada. En términos más simples, el flujo de entrada actúa como un canal para leer datos.

Flujo de salida : si desea leer y procesar datos de una fuente (archivo, etc.) primero necesita guardar los datos, el medio para almacenar datos es el flujo de salida.

Una secuencia de salida generalmente está relacionada con algún destino de datos, como un archivo o una red, etc.

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