Descripción general de io stream:
El flujo de IO se utiliza para procesar la transmisión de datos entre dispositivos, cargar archivos y descargar archivos. Java manipula los datos en un modo de flujo. Los objetos que utiliza Java para manipular los flujos están todos en el paquete IO.
Clasificación de flujo IO
Según el flujo de datos
Flujo de entrada para leer datos
El flujo de salida escribe datos
Según tipo de datos
Flujo de bytes
Flujo de caracteres
¿Qué corriente se debe utilizar en qué circunstancias?
Si el archivo donde se encuentran los datos se abre a través del bloc de notas que viene con Windows y puede leer el contenido en su interior, utilice la secuencia de caracteres y otros utiliza la secuencia de bytes.
Si no sabe nada, utilice flujos de bytes.
IO stream clase base comúnmente utilizada
Clase base abstracta de flujo de bytes:
InputStream ， OutputStream。
Clase base abstracta de flujo de caracteres:
Lector, Escritor,
Nota: Los
nombres de las subclases derivadas de estas cuatro clases tienen el sufijo del nombre de la clase principal.
Como: FileInputStream, una subclase de InputStream.
Como: FileReader, una subclase de Reader.
FileOutputStream, una subclase de OutputStream
Método de construcción:
FileOutputStream (archivo de archivo)
FileOutputStream (nombre de la cadena)
Se recomienda el segundo método de construcción:
FileOutputStream outputStream = nuevo FileOutputStream ("a.txt"); 1
Cree un objeto de flujo de salida de bytes y haga varias cosas:
A: Llame a la función del sistema para crear un archivo B: Cree un objeto outputStream C: Apunte el objeto foutputStream a este archivo 123
Escribir datos en texto a través del flujo de salida de bytes
public void write (int b) public void write (byte [] b) public void write (byte [] b, int off, int len) 123
Como se puede ver en el método, solo se puede escribir por byte
outputStream.write ("hola" .getBytes ()); hola aparece en el texto
outputStream.write (96) // aparece en el texto un
byte [] bys = {97,98,99,100,101};
outputStream.write (bys, 1, 3); bcd12345 aparece en el texto
Escriba de esta manera, los datos en el texto no se ajustarán ni adjuntarán, y cada vez que se escriba, se sobrescribirá el original.
añadir:
FileOutputStream outputStream = new FileOutputStream ("a.txt", true);
// El segundo parámetro true está configurado para que se pueda agregar. 12
Nueva línea \ n \ r:
for (int i = 0; i <5; i ++) {
outputStream.write ("hola" .getBytes ());
outputStream.write ("\ n \ r" .getBytes ());
} 1234
Nota: recuerde cerrar la transmisión cuando haya terminado.
outputStream.close (); 1
Ejemplo completo:
package io2;
import java.io.FileOutputStream;
import java.io.IOException;
/ **
* new FileOutputStream ("a.txt", true); El segundo parámetro es true, configurado para escribir datos empalmados al final
* \ n \ r Line feed
* write (bys, 1,3); write byte array
* /
public class out {
public static void main (String args []) {
FileOutputStream outputStream = null;
try {
// FileOutputStream fos = new FileOutputStream (archivo);
outputStream = new FileOutputStream ("a.txt", true);
/ *
* Crear un objeto de flujo de salida de bytes y hacer varias cosas:
* A: llamar a la función del sistema para crear un archivo
* B: crear un objeto de flujo de salida
* C: apunte el objeto foutputStream a este archivo
* /
// for (int i = 0; i <5; i ++) {
// outputStream.write ("hola" .getBytes ());
// outputStream.write ("\ n \ r" .getBytes ());
//}
byte [] bys = {97,98,99,100,101};
outputStream.write (bys, 1,3);
} captura (IOException e) {
e.printStackTrace ();
}
finalmente {
prueba {
outputStream.close ();
} captura (IOException e) {
e.printStackTrace ();
}
}
}
} 12345678910111213141516171819202122232425262728293031323334353637383940414243
Subclase de InputStream FileInputStream
Método de construcción FileInputStream
FileInputStream (archivo de archivo) FileInputStream (nombre de cadena) 12
Se recomienda el segundo método de construcción:
FileInputStream inputStream = nuevo FileInputStream ("a.txt"); 1
Ahora lea los datos que acaba de escribir en la consola:
public int read () public int read (byte [] b) 12
La primera lectura es leer un byte y la segunda lectura es leer una matriz de bytes.
// 读 一个 字节
int por = 0;
while ((por = inputStream.read ())! = - 1) {
System.out.println ((char) by);
} 12345
Si no hay datos, devolverá -1, lo que se utiliza para juzgar si la lectura ha finalizado.
// Leer una matriz de bytes, generalmente 1024 tamaño
int len = 0;
byte [] bys = new byte [1024];
while ((len = inputStream.read (bys))! = -1) {
System.out. println (nueva cadena (bys, 0, len));
} 123456
Los valores de retorno de las dos lecturas son ligeramente diferentes, read () devuelve el byte leído y -1 al final de la lectura, read (byte [] b) devuelve el número de bytes leídos, el byte leído Ponlo en la matriz de bytes y devuelve -1 si no hay datos al final.
Diagrama de dos métodos de lectura:
[Error en la transferencia de la imagen del enlace externo. El sitio de origen puede tener un mecanismo de enlace anti-sanguijuela. Se recomienda guardar la imagen y subirla directamente (img-Yv0oyKLy-1603813798619) (http://p5kllyq5h.bkt.clouddn.com/ 174401.jpg)]
Cuando la transmisión se agota, debe cerrarse a tiempo para evitar el uso de la memoria.
inputStream.close (); 1
Ejemplo completo:
Se recomienda leer los datos en una matriz de bytes.
paquete io2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/ **
* Crear por stefan
* Fecha en 2018-05-27 23:00
* ¡Conversión sobre configuración!
* /
public class input2 {
public static void main (String args []) {
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream ("a.txt");
// byte [] bys = new byte [4];
// int len = inputStream.read (bys);
// System.out.println (nueva cadena (bys)); // bcd
// System.out.println (len); // 3
// System.out.println (inputStream.read (bys)); // - 1
int len = 0;
byte [] bys = nuevo byte [1024];
while ((len = inputStream.read (bys))! = -1) {
System.out.println (new String (bys, 0, len));
}
/ **
*
Public String (byte bytes []) { this (bytes, 0, bytes.length);
}
* /
} catch (IOException e) {
e.printStackTrace ();
} finalmente {
prueba {
inputStream.close ();
} captura (IOException e) {
e.printStackTrace ();
}
}
}
} 123456789101112131415161718192021222324252627282930313233343536373839404142434445
Archivo de copia de flujo de bytes
Use la secuencia de entrada para leer los bytes en un archivo y luego use la secuencia de salida para escribir los bytes leídos en otro archivo (se creará automáticamente si no existe)
paquete io2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/ **
* Crear por stefan
* Fecha en 2018-05-27 23:19
* Conversión sobre configuración!
* /
public class copy {
public static void main (String args []) lanza IOException {
FileInputStream inputStream = new FileInputStream ("E: \\ huge1.jpg");
FileOutputStream outputStream = nuevo FileOutputStream ("E: \\ 古 月 .jpg");
byte [] bytes = nuevo byte [1024];
int len = 0;
while ((len = inputStream.read (bytes))! = -1) {
outputStream.write (bytes, 0, len);
}
inputStream.close ();
outputStream.close ();
}
} 12345678910111213141516171819202122232425262728
Nota: El método para copiar texto, imágenes, mp3, video, etc. es el mismo.
La velocidad de lectura y escritura del flujo de bytes de una matriz a la vez es obviamente mucho más rápida que la velocidad de lectura y escritura de un byte a la vez Este es el efecto de agregar un búfer como una matriz.
Cuando se diseñó Java, también tuvo en cuenta estas ideas de diseño (explicadas más adelante en el patrón de diseño decorativo), por lo que proporciona un flujo de búfer de bytes.
Flujo de salida en búfer de bytes BufferedOutputStream Flujo de entrada en búfer de bytes BufferedInputStream 1234
BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream (nuevo FileOutputStream ("a.txt", verdadero));
bos.write ("hola mundo" .getBytes ());
bos.close (); 123
BufferedInputStream
BufferedInputStream bis = new BufferedInputStream (nuevo FileInputStream ("a.txt"));
byte [] bytes = nuevo byte [1024];
int len = 0;
while ((len = bis.read (bytes))! = -1) {
System.out.println (new String (bytes, 0, len));
}
bis.close (); 1234567
Nota:
-
El método de miembro es básicamente el mismo que el flujo de bytes, y la función del flujo de búfer de bytes es mejorar la eficiencia de la entrada y la salida.
-
El método de construcción puede especificar el tamaño del búfer, pero generalmente no lo usamos, porque el tamaño predeterminado del búfer es suficiente.
-
¿Por qué no pasar un archivo o ruta de archivo específico, pero pasar un objeto OutputStream? La razón es muy simple, el flujo de búfer de bytes solo proporciona un búfer, diseñado para la eficiencia. Sin embargo, las operaciones reales de lectura y escritura deben basarse en objetos de flujo básicos.
Actualización de archivos copiados:
BufferedOutputStream bos = new BufferedOutputStream (nuevo FileOutputStream ("E: \\ modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream (nuevo FileInputStream ("F: \\ 汤包 \\ 慕 课 大巴 \\ modern-java.pdf"));
int len = 0;
byte [] bytes = nuevo byte [1024];
while ((len = bis.read (bytes))! = -1) {
bos.write (bytes, 0, len);
}
bis.close ();
bos.close (); 123456789
Prueba: la eficacia de los cuatro tipos de archivos de copia
package io2;
import java.io. *;
/ **
*
* Tiempo de copia de prueba
*
Creada por stefan * Fecha en 2018-05-28 10:28
* Conversión sobre configuración!
* /
public class copy2 {
// Un byte Se necesita 22697 milisegundos para copiar un byte
public static void fun () lanza IOException {
FileInputStream fis = new FileInputStream ("F: \\ soupbag \\ modern-java.pdf");
FileOutputStream fos = new FileOutputStream ("E: \\ modern- java.pdf ");
int by = 0;
while ((by = fis.read ())! = -1) {
fos.write (by);
}
fis.close ();
fos.close ();
}
/ / La copia de la matriz de 1024 bytes tarda 63 milisegundos
public static void fun1 () lanza IOException {
FileInputStream fis = new FileInputStream ("F: \\ soupbag \\ MO Class Bus \\ modern-java.pdf");
FileOutputStream fos = new FileOutputStream ("E: \\ modern- java .pdf ");
int len = 0;
byte [] bytes = nuevo byte [1024];
while ((len = fis.read (bytes))! = -1) {
fos.write (bytes, 0, len );
}
fis.close ();
fos.close ();
}
// Copia un byte por un byte, pero se necesitan 64 milisegundos para usar el flujo de búfer
public static void fun2 () throws IOException {
int by = 0;
BufferedOutputStream bos = new BufferedOutputStream (nuevo FileOutputStream ( "E: \\ modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream (new FileInputStream ("F: \\ soupbag \\ bus de clase moo \\ modern-java.pdf"));
while ((by = bis.read ())! = -1) {
bos. write (by);
}
bis.close ();
bos.close ();
}
// Se copia la matriz de 1024 bytes y se usa el flujo almacenado en búfer. Tarda 7 milisegundos
public static void fun3 () throws IOException {
BufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream ("E: \\ modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream (new FileInputStream ("F: \\ soupbag \\ MO Class Bus \\ modern-java.pdf")) ;
int len = 0;
byte [] bytes = nuevo byte [1024];
while ((len = bis.read (bytes))! = -1) {
bos.write (bytes, 0, len);
}
bis.close ();
bos.close ();
}
public static void main (String args []) lanza IOException {
long t1 = System.currentTimeMillis ();
fun3 ();
t2 largo = System.currentTimeMillis ();
System.out.println (t2-t1);
}
} 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768