Sistema Java IO
Uno, IO
1, entrada (entrada) y salida (salida) El
lenguaje Java ha logrado un gran éxito en el diseño de IO. Está completamente orientado a objetos y utiliza principalmente el patrón decorador para evitar una gran cantidad de clases, incluida la mayor posibilidad. un mejor mecanismo de extensión.
El IO de Java consta principalmente de tres partes:
la parte de transmisión : la parte principal de IO, la parte que
no es de transmisión, contiene principalmente una parte de transmisión auxiliar del
archivo de clase , la parte de lectura de las clases relacionadas con la seguridad y la clase
2 del sistema de archivos relacionado con el . sistema operativo local operaciones stream en Java se dividen en dos tipos:
flujo de bytes básica (InputStream leer, escribir OutputStream)
flujo de caracteres (lector leer, escribir escritor)
corriente Java IO puede se puede resumir como: dos correspondencias y un puente. Las dos correspondencias se refieren a la correspondencia entre el flujo de bytes (flujo de bytes) y el flujo de caracteres (flujo de caracteres), y la correspondencia entre el flujo de entrada y el flujo de salida. Un puente se refiere al puente entre el flujo de bytes y el flujo de caracteres.
3, Java, el diseño de un flujo de cuatro clases abstractas:
InputStream,
flujo de bytes, los datos de
lectura, OutputStream, un flujo de bytes, el lector de datos de escritura , flujo de caracteres, el
escritor de datos de lectura , un flujo de caracteres, datos de escritura
otros Se heredan una variedad de flujos de ellos, y la versión mejorada deriva de una decoración lujosa.La
siguiente figura es un diagrama de jerarquía de clases que describe el flujo de entrada y el flujo de salida.
En segundo lugar, la clase de archivo
1, el objeto de clase de archivo representa un archivo o directorio en el disco. Proporciona un método independiente de la plataforma para manipular archivos o directorios en el disco.
Visualización de código:
package io;
import java.io.File;
import java.io.IOException;
public class Test01 {
public static void main(String[] args) {
File f1 = new File("bb.txt"); //在创建一个名为bb的txt文件
File f2 = new File("d:/aa/aa.txt"); //在D盘中创建一个名为aa的文件夹，并在文件夹里面创建一个名为aa的txt文件
File f3 = new File("d:/bb"); //在D盘中创建一个名为bb的文件夹
File f4 = new File("d:/cc/dd"); //在D盘中创建一个名为cc的文件夹，并在cc文件夹里面创建一个名为dd的文件夹
try {
boolean b1 =f1.createNewFile();
boolean b2 =f2.mkdir();
boolean b3 = f3.mkdir();
boolean b4 = f4.mkdirs();
if (b1&b2&b3&b4){
System.out.println("创建成功");
}else {
System.out.println("创建失败");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Visualización de resultados:
creado con éxito
2. FileInputStream y FileOutputStream
FileInputStream
FileInputStream proporciona un método disponible () para probar el tamaño del archivo, proporciona un método close () para cerrar la secuencia y utiliza el método read () para leer datos de la fuente de datos. Puede usar la zona de búfer para mejorar la eficiencia especificando el tamaño del byte [] b-si no diseña la zona de búfer, solo puede leer byte por byte, lo cual es demasiado ineficiente.
Se puede considerar que se ha creado una cucharada (tampón), que puede contener 200 ml de agua. Utilice esta cuchara para sacar el agua del tanque a otro tanque y vierta la cantidad que desee (para 200 ml, vierta 200 ml y cucharada de 10 ml). Solo vierta 10 ml), si no saca nada, deje de tomar agua.
Cuando esté en uso, una vez completada la operación, preste atención para cerrar el flujo de archivos.
FileOutputStream La
clase FileOutputStream proporciona tres métodos write () para escribir datos.
Visualización del código:
Copie la imagen:
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test02 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("d:/ab.jpg");//原图片
fos = new FileOutputStream("d:/bb/as.jpg");//复制图片
} catch (FileNotFoundException e) {
e.printStackTrace();
}
byte [] b = new byte[1024];
int result = 0;
try {
while ((result=fis.read(b))!=-1){
fos.write(b,0,result);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fis.close(); //关闭数据流
fos.close(); //关闭数据流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Resultado de la ejecución:
se ejecuta correctamente, la imagen se copia correctamente.
3. BufferedReader y BufferedWriter
BufferedReader y BufferedWriter realizan la lectura y escritura eficiente de flujos de caracteres con su propio búfer. La unidad mínima de operación es un carácter (16 bits). Al mismo tiempo, también podemos especificar el tamaño del búfer nosotros mismos. . El búfer predeterminado es de 8192 caracteres que suelen ser suficientes.
(1)
En comparación con FileInputStream, BufferedReader tiene dos métodos más: readLine () y ready (). El método readLine () se usa para leer una línea a la vez del búfer, ready () se usa para juzgar si el archivo ha sido leído.
Cuando BufferedReader lee un archivo de texto, primero leerá los datos en el búfer, y luego, si se usa el método read (), primero leerá del búfer, si los datos del búfer son insuficientes, entonces los datos se leerán desde el búfer. Leer desde el archivo, con el búfer, puede reducir la acción de E / S en el disco, mejorando así la eficiencia del programa
(2) BufferedWriter
tiene un búfer, por lo que en el proceso de escritura, el carácter se completa primero el búfer (8192 caracteres), y luego entregue el contenido del búfer al sistema operativo para que lo escriba en el archivo en el disco, lo que mejora el rendimiento y evita la operación frecuente de escribir cada carácter en el disco. El
método flush () se utiliza para escribir el búfer. Los datos que contiene se pasan al sistema operativo y se escriben en el disco a través del sistema operativo. Cuando se llama al método close (), el método flush () se llama automáticamente
(3) Visualización de código
package io;
import java.io.*;
public class Test03 {
public static void main(String[] args) {
FileInputStream fis=null;
FileOutputStream fot=null;
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try {
fis = new FileInputStream("d:/bb/as.jpg");
fot = new FileOutputStream("d:/cc/dd/aa.jpg");
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fot);
byte[] b =new byte[1024];
int result=0;
try {
while ((result=bis.read(b))!=-1){
bos.write(b,0,result);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
bis.close();
bos.close();
fis.close();
fot.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Operación exitosa:
Tercero, juego de caracteres Java
En la JVM, la codificación de caracteres basada en el juego de caracteres Unicode se usa de manera uniforme.
Para la versión china del sistema operativo, la codificación predeterminada del sistema es GBK.
Visualización de código:
package io;
public class Text06 {
public static void main(String[] args) {
System.out.println(System.getProperty("file.encoding"));
}
}
Resultado de la operación:
Cuarto, PrinterWriter La
clase PrintWriter, como BufferedWriter, también hereda de la clase Writer, y la mayoría de sus funciones son las mismas. La diferencia es que BufferedWriter proporciona un búfer, que puede proporcionar una escritura de datos eficiente, mientras que PrintWriter proporciona formato de datos, como print (boolean b), print (char c), print (doble d) y soporte para cualquier plataforma. Método de salto de línea println () y así sucesivamente, lo que hace que nuestro programa sea más gratuito
1. Visualización de código:
package io;
import java.io.*;
public class Text04 {
public static void main(String[] args) {
BufferedReader br=null;
BufferedWriter bw=null;
try {
br = new BufferedReader(new FileReader("d:/bb/aa.txt")); //原版
try {
bw = new BufferedWriter(new FileWriter("d:/cc.txt")); //复制版
String temp = null;
while ((temp=br.readLine())!=null){
bw.write(temp);
bw.newLine();
}
bw.flush(); //刷新缓冲区
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Resultados de ejecución:
2, visualización de código
package io;
import java.io.*;
public class Test05 {
public static void main(String[] args) {
BufferedReader br=null;
BufferedWriter bw=null;
br = new BufferedReader(new InputStreamReader(System.in));
try {
bw = new BufferedWriter(new FileWriter("d:/bb/asd.txt"));
String temp=null;
while ((temp=br.readLine())!=null){
if (temp.equals("quit")){
//输入quit退出
break;
}
bw.write(temp);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Resultados de la ejecución:
Resumen: la
clase Archivo se utiliza para crear archivos y carpetas, y para leer y modificar sus atributos.
El flujo de bytes InputStream y OutputStream se pueden utilizar para leer archivos binarios.
El lector y escritor de flujo de caracteres puede leer archivos de texto de manera eficiente.
Java proporciona la conversión de flujo de bytes a flujo de caracteres: InputStreamReader, OutputStreamWriter.
PrintWriter puede formatear los datos en el flujo de salida.