Resumen de aprendizaje de Java IO stream: flujo de entrada y salida
Indique la fuente para la reimpresión: http://blog.csdn.net/zhaoyanjun6/article/details/54292148
Este artículo es del [blog de Zhao Yanjun]
Gracias blogger, gracias por compartir
Estructura del diagrama de clase de flujo de Java:
El concepto y el papel del flujo:
Una secuencia es un conjunto de bytes secuenciales con un punto de inicio y un punto final. Es un término general o abstracción para la transmisión de datos. Es decir, la transmisión de datos entre los dos dispositivos se denomina transmisión. La esencia de la transmisión es la transmisión de datos. La transmisión se resume en varias categorías según las características de la transmisión de datos, lo que facilita operaciones de datos más intuitivas.
clasificación corriente IO:
Los tipos de datos se dividen en un tratamiento diferente: un flujo de caracteres y flujo de bytes
de acuerdo con el flujo de datos se divide en: la entrada y salida corrientes de
flujo de caracteres y flujo de bytes
origen de carácter corrientes: codificado como datos diferentes, y Hay objetos de flujo que operan eficientemente en los personajes. La esencia es verificar la tabla de códigos especificada en función de la lectura del flujo de bytes. La diferencia entre la secuencia de bytes y la secuencia de caracteres:
La unidad de lectura y escritura es diferente: la secuencia de bytes está en unidades de bytes (8 bits), la secuencia de caracteres está en unidades de caracteres y los caracteres se asignan de acuerdo con la tabla de códigos.
Los objetos de procesamiento son diferentes: la secuencia de bytes puede procesar todo tipo de datos (como imágenes, avi, etc.), mientras que la secuencia de caracteres solo puede procesar datos de tipo de caracteres.
Flujo de bytes: el binario de 8 bits se lee o se lee a la vez.
Secuencia de caracteres: leer o leer es un binario de 16 bits.
Si los datos en el dispositivo son imágenes o video, texto, se almacenan en binario. Al final, los datos binarios se expresan como una unidad de datos de 8 bits, por lo que la unidad de datos más pequeña en una computadora es un byte. Significa que el flujo de bytes puede manejar todos los datos en el dispositivo, por lo que el flujo de bytes también puede manejar datos de caracteres.
Conclusión
Mientras el procesamiento de datos de texto plano, se da prioridad al uso de secuencias de caracteres. De lo contrario, se utilizan secuencias de bytes.
Flujo de entrada y flujo de salida El flujo de
entrada solo se puede leer, y el flujo de salida solo se puede escribir. El programa necesita usar diferentes flujos de acuerdo con las diferentes características de los datos a transmitir.
InputStream InputStream
InputStream es la clase principal de todos los flujos de bytes de entrada, es una clase abstracta.
ByteArrayInputStream, StringBufferInputStream, FileInputStream son tres flujos de medios básicos, leen datos de la matriz de bytes, StringBuffer y archivos locales.
PipedInputStream es leer datos de la tubería compartida con otros subprocesos, y el conocimiento relacionado con Piped se introducirá por separado más adelante.
ObjectInputStream y todas las subclases FilterInputStream son secuencias decorativas (el personaje principal del patrón decorador).
OutputStream OutputStream
OutputStream es la clase principal de todos los flujos de bytes de salida, es una clase abstracta.
ByteArrayOutputStream y FileOutputStream son dos flujos de medios básicos, que escriben datos en la matriz de bytes y en el archivo local, respectivamente.
PipedOutputStream es escribir datos en la tubería compartida con otros subprocesos.
ObjectOutputStream y todas las subclases FilterOutputStream son secuencias decorativas.
Resumen:
Secuencia de entrada: InputStream o Reader: lectura del archivo al programa;
secuencia de salida: OutputStream o Writer: salida del programa al archivo;
secuencia del
nodo secuencia del nodo: conectado directamente a la fuente de datos, lectura o lectura.
Usar el flujo de nodo directamente es inconveniente para leer y escribir. Para leer y escribir archivos más rápido, hay un flujo de procesamiento.
Secuencias de nodo de uso común
Clases principales: InputStream, OutputStream, Reader,
Archivos de escritura : FileInputStream, FileOutputStrean, FileReader, FileWriter Matriz de procesamiento de nodo de archivo
: ByteArrayInputStream, ByteArrayOutputStream, CharArrayReader, CharArrayWriter matriz de procesamiento Es un archivo, pero una matriz en la memoria)
String: StringReader, StringWriter Node stream que procesa strings
: PipedInputStream, PipedOutputStream, PipedReader, PipedWriter Node stream
stream de
procesamiento y el nodo se usan juntos Sobre la base del flujo del nodo, se anida otra capa y el flujo de procesamiento se anida en el flujo del nodo. Como BufferedReader. El método de construcción para procesar la secuencia siempre toma otro objeto de secuencia como parámetro. Un objeto de flujo se empaqueta varias veces por otros flujos, llamado enlace de flujo.
Secuencia de procesamiento de uso común
Secuencia de búfer: BufferedInputStrean, BufferedOutputStream, BufferedReader, BufferedWriter aumentan la función de búfer para evitar la lectura y escritura frecuente del disco duro.
Secuencia de conversión: InputStreamReader y OutputStreamReader realizan la conversión entre la secuencia de bytes y la secuencia de caracteres.
Flujo de datos: DataInputStream, DataOutputStream, etc.-Proporciona los tipos de datos básicos para escribir en el archivo o leer.
El flujo de conversión
InputStreamReader, OutputStreamWriter requiere InputStream o OutputStream como parámetros para lograr la conversión de flujo de bytes a flujo de caracteres.
Constructor
InputStreamReader (InputStream); // Inicializado por el constructor, utilizando la tabla de codificación predeterminada del sistema GBK. InputStreamReader (InputStream, String charSet); // A través de esta inicialización del constructor, puede especificar la tabla de codificación. OutputStreamWriter (OutputStream); // Inicializado por este constructor, utilizando la tabla de codificación predeterminada del sistema GBK. OutputStreamwriter (OutputStream, String charSet); // A través de esta inicialización del constructor, puede especificar la tabla de codificación.
El uso de la clase FileInputStream en ejercicios de combate reales : lectura del contenido del archivo
paquete com.app; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class A1 { public static void main (String [] args) { A1 a1 = nuevo A1 (); // disco de computadora d abc.txt documento Cadena rutaArchivo = "D: /abc.txt" ; Cadena reslut = a1.readFile (filePath); System.out.println (reslut); } / ** * Leer el contenido del archivo especificado * @param filePath: la ruta del archivo * El resultado devuelto por @ return * / public String readFile (String filePath) { FileInputStream fis = null ; String result = "" ; try { // Instanciar un objeto de flujo de entrada fis = new FileInputStream (filePath); // 2. Devuelve el valor estimado de los bytes restantes que se pueden leer en esta secuencia de entrada; int size = fis.available (); // 3. Crea una matriz de bytes basada en el número de bytes en la secuencia de entrada; byte [ ] matriz = nuevo byte [tamaño]; // 4. Lea los datos en la matriz; fis.read (matriz); // 5. Cree una nueva cadena basada en la matriz de bytes obtenida, y luego produzca; result = new String (array); } catch (FileNotFoundException e) { e.printStackTrace (); } catch (IOException e) { e.printStackTrace (); } finalmente { if (fis! = null ) { try { fis.close (); } catch (IOException e) { e.printStackTrace (); } } } resultado de retorno ; } }
}
Uso de la clase FileOutputStream:
Escribir contenido para archivar
paquete com.app; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; clase pública A2 { public static void main (String [] args) { A2 a2 = nuevo A2 (); // disco de computadora d abc.txt documento Cadena rutaArchivo = "D: /abc.txt" ; // Contenido a escribir String content = "Hoy es 2017/1/9, hace buen tiempo" ; a2.writeFile (filePath, contenido);
} / ** * Crear una secuencia de salida basada en la ruta del archivo * @param filePath: la ruta del archivo * @param content: contenido a escribir * / public void writeFile (String filePath, String content) { FileOutputStream fos = null ; intente { // 1. Cree una secuencia de salida fos = new FileOutputStream (filePath) de acuerdo con la ruta del archivo ; // 2. Convierta la cadena en una matriz de bytes ; byte [] array = content.getBytes (); // 3 , Conjunto de bytes de salida; fos.write (array); } catch (FileNotFoundException e) { e.printStackTrace (); } catch (IOException e) { e.printStackTrace (); } finalmente { if (fos! = null ) { try { fos.close (); } catch (IOException e) { e.printStackTrace (); } } } }
}
Nota:
En el proyecto real, todas las operaciones de E / S deben colocarse en subprocesos para evitar bloquear el subproceso principal.
Cuando FileInputStream lee el contenido del archivo, pasamos la ruta del archivo ("D: /abc.txt"). Si el archivo en esta ruta no existe, se notificará FileNotFoundException cuando se ejecute el método readFile ().
Cuando FileOutputStream escribe un archivo, pasamos la ruta del archivo ("D: /abc.txt"). Si el archivo en esta ruta no existe, cuando se ejecute el método writeFile (), se creará uno nuevo por defecto. Archivos. También es importante no informar una excepción.
Imagen del efecto:
Ejercicios completos para copiar archivos de la unidad D a la unidad E
paquete com.app; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; clase pública A3 { public static void main (String [] args) { A3 a2 = nuevo A3 (); // La ruta de la imagen cat.png en la computadora d unidad String filePath1 = "D: /cat.png" ; // La ruta de la imagen cat.png en la unidad e de la computadora String filePath2 = "E: /cat.png" ; // Copie el archivo a2.copyFile (filePath1, filePath2); } / ** * Copia de archivo * @param filePath_old: la ruta del archivo a copiar * @param filePath_new: la ruta donde se almacena el archivo copiado * / public void copyFile (String filePath_old, String filePath_new) { FileInputStream fis = null ; FileOutputStream fout = null ; intente { // Crear una instancia de un objeto de flujo de entrada fis = new FileInputStream (filePath_old) de acuerdo con la ruta de la ruta ; // 2. Devuelve el valor estimado de los bytes restantes que se pueden leer en esta secuencia de entrada; int size = fis.available (); // 3. Crea una matriz de bytes basada en el número de bytes en la secuencia de entrada; byte [ ] matriz = nuevo byte [tamaño]; // 4. Lea los datos en la matriz; fis.read (matriz); // 5. Crear una secuencia de salida basada en la ruta del archivo fout = new FileOutputStream (filePath_new); // 5. Byte de salida array; fout.write (array); } catch (FileNotFoundException e) { e.printStackTrace (); } catch (IOException e) { e.printStackTrace (); } finalmente { if (fis! = null ) { try { fis.close (); } catch (IOException e) { e.printStackTrace (); } } if (fout! = null ) { intente { fout.close (); } catch (IOException e) { e.printStackTrace (); } } } } }