Interfaces estándar: InputStream, OutputStream

"¡Hola, amigo! Ahora te contaré sobre dos interfaces: InputStream y OutputStream . Se declaran como clases abstractas, pero si profundizas más, puedes ver que son esencialmente interfaces . Casi todos sus métodos son abstractos, excepto por algunos métodos insignificantes. Son muy parecidos al " guardaespaldas " que consideramos antes".

Estas son interfaces muy interesantes. Por ahora, los llamaré deliberadamente interfaces , para que comprenda por qué los necesitamos. Y luego hablaremos de por qué en realidad son clases abstractas.

"Está bien. Entonces, ¿qué son estas interfaces?"

"Te lo diré sin más preámbulos".

Java tiene esta cosa interesante llamada « flujo ». Una corriente es una entidad muy simple. Y su simplicidad es la clave para una forma muy poderosa de intercambiar datos. Hay dos tipos de flujos: flujos de lectura y flujos de escritura .

Como probablemente ya haya adivinado, puede escribir datos en una secuencia para escribir archivos . Tiene un método de escritura para esto. Puede leer datos de una secuencia para leer . Tiene un método de lectura () para esto.

InputStream  es la interfaz para un flujo que admite la lectura. Define la siguiente capacidad: «los bytes se pueden leer de mí».

De manera similar, OutputStream , un OutputStream es una interfaz para un flujo que admite escritura. Define la siguiente habilidad: «se me pueden escribir bytes».

"¿Eso es todo?"

"Más o menos. Pero el punto es que Java tiene muchas clases que pueden funcionar con InputStream y OutputStream . Por ejemplo, desea leer un archivo del disco y mostrar su contenido en la pantalla. Nada podría ser más fácil".

Para leer datos de un archivo en el disco, tenemos la clase especial FileInputStream , que implementa la interfaz InputStream . ¿Quiere escribir estos datos en otro archivo? Para ello contamos con la clase FileOutputStream , que implementa la interfaz OutputStream . El siguiente código muestra lo que debe hacer para copiar datos de un archivo a otro.

public static void main(String[] args) throws IOException
{
 InputStream inStream = new FileInputStream("c:/source.txt");
 OutputStream outStream = new FileOutputStream("c:/result.txt");

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one byte from the input stream
  outStream.write(data); //write that byte to the other stream.
 }

 inStream.close(); //close the streams
 outStream.close();
}

Imagine que hemos escrito una clase y  le hemos agregado las capacidades InputStream  y  OutputStream .

Si implementamos correctamente estas interfaces, las instancias de nuestra clase ahora se pueden guardar o leer desde un archivo. Simplemente leyendo su contenido usando el método de lectura . O se pueden cargar desde un archivo creando un objeto y usando el método de escritura para escribir el contenido del archivo.

"¿Tal vez un ejemplo?"

"Seguro."

class MyClass
{
private ArrayList<Integer> list;
}

Ahora le agregaremos métodos de lectura y escritura.

class MyClass
{
private ArrayList<Integer> list;
public void write(int data)
{
list.add(data);
}
public int read()
{
int first = list.get(0);
list.remove(0);
return first;
}

public int available()
{
return list.size();
}
}

Por supuesto, esto no es una implementación de las interfaces InputStream y OutputStream, pero es muy similar.

"Sí, entiendo. Entonces, ¿cómo se guarda el contenido de dicho objeto en un archivo?"

"Dejame darte un ejemplo:"

public static void main(String[] args)
{
 MyClass myObject = new MyClass();
 OutputStream outStream = new FileOutputStream ("c:/my-object-data.txt");

 while (myObject.available() > 0)
 {
  int data = myObject.read(); //read one int from the input stream
  outStream.write(data); //write that int to the other stream.
 }

 outStream.close();
}

public static void main(String[] args)
{
 InputStream inStream = new FileInputStream("c:/my-object-data.txt");
 MyClass myObject = new MyClass();

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one int from the input stream
  myObject.write(data); //write that int to the other stream.
 }

 inStream.close(); //close the streams
}

"¡Santo Dios! Realmente es muy similar a trabajar con InputStream/OutputStream. ¡Las transmisiones son geniales!"

"¡Y algo más!"

3

Tarea

Núcleo de Java, nivel 3, lección 8

Bloqueada

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

Abrir