En la API de Java, un objeto que puede leer una secuencia de bytes se llama flujo de entrada y un objeto que puede escribir una secuencia de bytes se llama flujo de salida. Los dos flujos que más involucramos son InputStream y OutputStream. clase abstracta. Este artículo es mi experiencia al leer "Java Core Technology Volume Two". El código está escrito por mí en combinación con escenarios específicos. Creo que los lectores que sean principiantes en el flujo de entrada y el flujo de salida podrán distinguir con precisión los dos flujos después leerlo. Finalmente, no es fácil crear, dar me gusta, recopilar y seguir tres enlaces, cangrejo y cangrejo ~
Uno, flujo de entrada y flujo de entrada de archivo
1. Explore el método de lectura
Primero, la clase InputStream tiene un método abstracto: abstract int read ()
Este método leerá un byte y devolverá el byte que se leyó, o devolverá -1 cuando se alcance el final de la entrada. Nota: Dado que InputStream rara vez se usa directamente en la práctica, usamos principalmente subclases de InputStream, entre las cuales la más comúnmente utilizada es FileInputStream, en la que la clase FileInputStream anula el método de lectura de la clase InputStream.
Aquí está el código fuente de JDK como referencia:
Código fuente read () de InputStream:
@Override
public int read() throws IOException {
ensureOpen();
return -1;
}La parte de comentario en la figura siguiente dice: Lea un byte de datos de este flujo de entrada. Si no hay entrada disponible para lectura, este método se bloqueará. Devuelve el siguiente byte. Si se llega al final del archivo, se devuelve -1.
/**
* Reads a byte of data from this input stream. This method blocks
* if no input is yet available.
*
* @return the next byte of data, or {@code -1} if the end of the
* file is reached.
* @throws IOException if an I/O error occurs.
*/
public int read() throws IOException {
return read0();
}A continuación se dan ejemplos específicos.
Abra IDEA (no use el malvado Eclipse, esto no es bueno en absoluto), cree un archivo de texto Test.txt, el contenido del archivo es: ¡Hola!
Para crear el archivo Test.java, primero debe crear un objeto de archivo: File file = new File ("E: \\ problema de pulverización \\ Test.txt");
public class Test {
public static void main(String[] args) throws IOException {
File file = new File("E:\\喷涂问题\\Test.txt");
FileInputStream in=new FileInputStream(file);
int read = in.read();
System.out.println(read);
}
}Salida: 72.
Quizás alguien tenga curiosidad por saber por qué se emite un número. De hecho, ¡este es el código ASCII correspondiente a la letra H!
Después de buscar en la tabla, los códigos ASCII correspondientes de H, e, l, l, o,! Son 72101108108111 33, por lo que solo necesitamos convertir el tipo entero al tipo de carácter.
public class Test {
public static void main(String[] args) throws IOException {
File file = new File("E:\\喷涂问题\\Test.txt");
FileInputStream in=new FileInputStream(file);
int read = in.read();
char text=(char)read;
System.out.println(text);
}
}Entonces puede generar: H
2, método readAllBytes
Si solo usa el método de lectura, como en el ejemplo anterior, debe leer 'H', 'E', 'L' ..., obviamente, es demasiado lento e inconveniente. Entonces, a partir de Java9, se proporciona un método readAllBytes (), que lee directamente todos los caracteres en el flujo de entrada en una matriz de bytes . ¡Entonces puede generar información de texto de una vez mediante la conversión!
import java.io.*;
public class Test {
public static void main(String[] args) throws IOException {
File file = new File("E:\\喷涂问题\\Test.txt");
FileInputStream in=new FileInputStream(file);
byte[] bytes = in.readAllBytes();
for (byte Byte : bytes) {
char c=(char)Byte;
System.out.print(c);
}
}
}
Salida de consola:
En segundo lugar, el flujo de salida del archivo
Ahora expliquemos los pasos generales del flujo de entrada anterior de forma continua:
1. Cree un archivo de texto e ingrese un párrafo de texto ¡Hola!
2. Lea la información de texto en la matriz de bytes byte [] a través del flujo de entrada.
---------------------------------------------Línea divisoria--- ---------------------------------------------
¿Qué pasa con el flujo de salida?
¡Por supuesto que es al revés! ! Es decir , envíe los datos que ya están en la matriz de bytes a un archivo de texto vacío .
Da un ejemplo basado en el anterior:
1. Primero cree un archivo de texto vacío ReadFromTest.txt.
2. Cree un objeto file2 que represente un archivo vacío y llame al método out.write (). Se puede entender que el flujo de salida se ha vinculado al nuevo archivo, y escribir la matriz de bytes en el flujo de salida es equivalente a escribir en el nuevo archivo.
import java.io.*;
public class Test {
public static void main(String[] args) throws IOException {
File file1 = new File("E:\\喷涂问题\\Test.txt");
FileInputStream in=new FileInputStream(file1);
byte[] bytes = in.readAllBytes();
//以上部分的代码将原来Test.txt中的hello!转移到字符数组bytes中了
File file2 = new File("E:\\喷涂问题\\ReadFromTest.txt");
FileOutputStream out = new FileOutputStream(file2);
out.write(bytes);
}
}3. Ejecute el código anterior y verá que el mensaje de texto ¡Hola! Aparece en el nuevo archivo ReadFromTest.txt.
Si no sabe por qué hay un código ilegible detrás, los amigos que sepan cómo eliminarlo pueden comentar en el área de mensajes.
