¿Cuáles son los flujos de entrada y salida de JAVA?
Las funciones de entrada y salida del lenguaje Java son muy potentes y flexibles. El único inconveniente es que el código de entrada y salida no parece ser muy conciso, porque a menudo es necesario envolver muchos objetos diferentes. En la biblioteca de clases Java, el contenido de la parte IO es muy grande porque cubre una amplia gama de campos: entrada y salida estándar, operaciones de archivos, flujos de datos en la red, flujos de cadenas, flujos de objetos, flujos de archivos zip. .El propósito de este artículo es brindarle una breve introducción.
La secuencia es un concepto muy vívido. Cuando el programa necesita leer datos, abrirá una secuencia a la fuente de datos. Esta fuente de datos puede ser un archivo, una memoria o una conexión de red. De manera similar, cuando el programa necesite escribir datos, abrirá una secuencia hacia el destino. En este momento, puede imaginar que los datos parecen "fluir" en él, como se muestra a continuación:
Hay dos tipos de flujos en Java, uno es el flujo de bytes y el otro es el flujo de caracteres. stream Están representados por cuatro clases abstractas (cada flujo incluye entrada y salida, por lo que hay de una a cuatro): InputStream, OutputStream, Reader y Writer. Otros flujos en Java se derivan de ellos:
Entre ellos, InputStream y OutputStream ya existían en las primeras versiones de Java. Se basan en flujos de bytes, y más tarde se agregaron Reader y Writer basados en flujos de caracteres. suplemento. El diagrama de jerarquía anterior es un sistema de jerarquía básico en la biblioteca de clases de Java.
Entre estas cuatro clases abstractas, InputStream y Reader definen exactamente la misma interfaz:
int read()
int read(char cbuf[] )
int read(char cbuf[], int offset, int length)
Y lo mismo ocurre con OutputStream y Writer:
int write(int c)
int write (char cbuf[])
int write (char cbuf[], int offset, int length)
Estos seis métodos son los más básicos. read() y write() leen y escriben un byte o una matriz de bytes mediante la sobrecarga de métodos.
Las funciones más flexibles y modificables se amplían mediante sus subclases. Después de conocer la estructura jerárquica básica de la entrada y salida de Java, este artículo quisiera brindarle algunos ejemplos que se pueden aplicar repetidamente en el futuro. Los detalles de todas las subclases y sus funciones no se discutirán en detalle.
importar java.io.*;
clase pública IOStreamDemo {
muestras vacías públicas() lanza IOException {
//1 Esto es para leer una línea de datos del teclado y devolver una cadena
BufferedReader stdin =new BufferedReader (new InputStreamReader (System.in));
System.out.print. ("Ingrese una línea:");
System.out.println (stdin.readLine());
//2. archivo
BufferedReader in = new BufferedReader(new FileReader("IOStreamDemo.java"));
String s, s2 = new String()
while ( (s = in.readLine()) != null)
s2 = s "\n"
in.close()
/ / 3. Esto es leer bytes uno por uno de una cadena
StringReader in1 = new StringReader(s2);
int c;
while(( c = in1.read()) != -1)
System.out.print((char)c);
//4. file
intente {
BufferedReader in2 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter( " IODemo.out")));
int lineCount = 1;
while ((s = in2.readLine()) != null )
out1 .printl
n(lineCount ": " s);
out1.close();
} catch (EOFException e) {
System.err.println(" Fin de la transmisión");
}
}
}
Para el ejemplo anterior, es necesario explicar los siguientes puntos:
1. BufferedReader es una subclase de Reader. Tiene la función de almacenamiento en búfer y evita la lectura frecuente de información de dispositivos físicos. Tiene los dos constructores siguientes:
BufferedReader (Lector de entrada)
BufferedReader (Lector de entrada, int sz)
El sz aquí especifica el tamaño del búfer.
Su método básico:
void close() //Cerrar la transmisión
void mark(int readAheadLimit) //Marcar la posición actual
boolean markSupported() //Si se admite la marca
int read() //Método básico heredado de Reader
int read(char[] cbuf, int off, int len ) //Método básico heredado de Reader
String readLine() //Lee una línea de contenido y la devuelve como una cadena
boolean ready() //Determina si la secuencia se ha completado Buena preparación para la lectura
void reset () //Restablecer a la última marca
long skip (long n) //Omitir el número especificado de caracteres para leer< / p>
2. InputStreamReader es el puente entre InputStream y Reader. Dado que System.in es un flujo de bytes, debe empaquetarse y convertirse en un flujo de caracteres para que lo utilice BufferedReader.
3. PrintWriter out1 = new PrintWriter (new BufferedWriter (new FileWriter ("IODemo.out")));
Esta oración refleja una característica del sistema de entrada y salida de Java. Para lograr un determinado propósito, se necesitan varias capas de embalaje. Primero, el destino de salida es el archivo IODemo.out, por lo que el contenedor más interno es FileWriter para crear un flujo de archivo de salida. Luego, esperamos que este flujo esté almacenado en el búfer, por lo que usamos BufferedWriter para envolverlo y lograr el propósito. Los resultados de salida deben formatearse, por lo que PrintWriter se envuelve en la capa más externa.
Java proporciona una función para redirigir los flujos de entrada y salida estándar. En otras palabras, podemos configurar algún otro flujo como flujo de entrada o salida estándar. Consulte el siguiente ejemplo:
. import java.io.*;
redireccionamiento de clase pública {
public static void main(String[] args) lanza IOException {
PrintStream console = System. salida
BufferedInputStream in = new BufferedInputStream( new FileInputStream( "Redirecting.java"));
PrintStream salida = new PrintStream( new BufferedOutputStream( new FileOutputStream(" test.out" )));
System.setIn(in);
System.setOut(out);
BufferedReader br = new BufferedReader( new InputStreamReader(System. in));
String s;
while ((s = br.readLine()) != null)
System.out .println(s
out.close();
System.setOut(consola
}
}
<); p>Método estático de java.lang.System aquístatic void setIn（InputStream in）
static void setOut（PrintStream out）
Proporciona un método para redefinir el flujo de entrada y salida estándar, esto es muy conveniente. Por ejemplo, un programa tiene muchos resultados y, a veces, es necesario voltearlo para mostrarlo, lo que hace que sea inconveniente ver los resultados. el flujo de salida estándar. Se define como un flujo de archivos. Una vez ejecutado el programa, es mucho más intuitivo abrir el archivo correspondiente y ver los resultados.
Los flujos de Java tienen otro propósito importante, que es utilizar flujos de objetos para serializar objetos. Comenzaremos a introducir este aspecto a continuación.
Cuando se ejecuta un programa, los datos variables se almacenan en la memoria. Una vez que finaliza el programa, los datos no se guardarán. Una solución es escribir los datos en un archivo, y Java proporciona un mecanismo para hacerlo. Puede escribir objetos en un programa en un archivo y luego leer los objetos del archivo para recrearlos. Esta es la llamada serialización de objetos. Se introdujo en Java principalmente para RMI (Invocación de método remoto) y Java Bean, pero también es una tecnología muy útil en las aplicaciones diarias.
Todos los objetos que necesiten implementar la serialización de objetos deben implementar primero la interfaz Serializable.
Veamos un ejemplo:
import java.io.*;
import java.util.*
public class Logon implements Serializable {
fecha privada fecha = nueva fecha();
nombre de usuario de cadena privada
contraseña de cadena transitoria privada
Inicio de sesión (nombre de cadena, contraseña de cadena; ) {
nombre de usuario = nombre
contraseña = pwd
}
cadena pública toString() {
<; p > String pwd = (contraseña == null) ? "(n/a)": contraseña;return "información de inicio de sesión: \n " "nombre de usuario: " nombre de usuario "\n fecha: " fecha " \ n contraseña: " pwd;
}
public static void main(String[] args) lanza IOException, ClassNotFoundException {
Inicio de sesión a = nuevo inicio de sesión( " Morgan", "morgan83");
System.out.println("logon a = " a);
ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out " ));
o.writeObject(a);
o.close();
int segundos = 5;
long t = System.currentTimeMillis() segundos * 1000;
while (System.currentTimeMillis() lt; t);
ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon. out "));
System.out.println( "Recuperando objeto en " new Date());
a = (Inicio de sesión) in.readObject();
System.out.println ("logon a = " a);
}
}
Class Logon es una clase que registra la información de inicio de sesión, incluido el nombre de usuario. y contraseña. Primero, implementa la interfaz Serializable, que indica que se puede serializar. Luego, en el método principal, ObjectOutputStream o = new ObjectOutputStream (new FileOutputStream ("Logon.out") crea una nueva secuencia de salida de objeto para envolver una secuencia de archivo, lo que indica que el destino de la serialización del objeto es el archivo Logon.out. Luego use el método writeObject para comenzar a escribir. Cuando desee restaurar, es muy simple. ObjectInputStream in = new ObjectInputStream (new FileInputStream ("Logon.out") crea una nueva secuencia de entrada de objeto con la secuencia de archivos Logon.out como parámetro y luego llama a readObject. método.
Es necesario explicar que una de las cosas mágicas de la serialización de objetos es que establece una red de objetos, que incluye todos los objetos a los que apuntan las referencias contenidas en el objeto que se van a serializar y escribir juntos. el archivo, lo que es aún más sorprendente es que si serializa varios objetos a la vez, el mismo contenido se escribirá entre sí. De hecho, este es un muy buen mecanismo. Se puede utilizar para implementar copias profundas.
La palabra clave transitoria aquí significa que el contenido actual no se serializará. Por ejemplo, la contraseña en el ejemplo debe mantenerse confidencial, por lo que no se escribe en el archivo.
Esta es una breve introducción a las funciones de entrada y salida de Java. El propósito de este artículo es solo hacer un buen comienzo, con la esperanza de brindarles a todos una comprensión básica de los flujos de entrada y salida de Java.