Estilo JavaSE IO

Others 2020-04-20 10:11:32 views: null

Primero, el uso de la clase File

  • Un objeto de la clase File que representa un archivo o un directorio de archivos
  • Ruta relativa: en comparación con una ruta, la ruta especificada
  • Ruta absoluta: la ruta del archivo o directorio de archivos, incluida la letra de la unidad
  • Separador de ruta
    • ventanas: \\
    • Unix ： /
@Test
public void test1() {
   File file = new File("a.txt");
   System.out.println(file);
}

1.1 Métodos comunes

@Test
public void test2() {
    File file = new File("cn/imut/hello.txt");
    //获取绝对路径
    System.out.println(file.getAbsoluteFile());
    //获取路径
    System.out.println(file.getPath());
    //获取名称
    System.out.println(file.getName());
    //获得上层文件目录路径，无则返回null
    System.out.println(file.getParent());
    //获取文件长度（字节数）
    System.out.println(file.length());
}

@Test
public void test3() {
    File file = new File("hello.txt");
    //判断是否是文件目录
    System.out.println(file.isDirectory());
    //判断是否是文件
    System.out.println(file.isFile());
    //判断是否存在
    System.out.println(file.exists());
    //判断是否可写
    System.out.println(file.canWrite());
}

Segundo, el principio de flujo IO

  • E / S es una abreviatura de Entrada / Salida, y la tecnología de E / S se usa para procesar la transmisión de datos entre dispositivos
  • En los programas Java, las operaciones de entrada / salida de datos se realizan en modo "Stream"

Entrada de entrada: leer datos externos en la memoria

Salida: salida de datos de memoria al disco y CD

Tercero, la clasificación del flujo.

De acuerdo con la unidad de datos

  • Flujo de bytes: 8 bits (InputStream, OutputStream)
  • Secuencia de caracteres: 16 bits (lector, escritor)

Distinguir según la dirección del flujo.

  • Flujo de entrada
  • Flujo de salida

Distinguir según el papel de la corriente.

  • Flujo de nodo
  • Flujo de procesamiento

3.1 sistema de transmisión IO

Clasificación Flujo de entrada de bytes Flujo de salida de bytes Secuencia de entrada de caracteres Secuencia de salida de caracteres
Clase base abstracta Flujo de entrada Flujo de salida Lector Escritor
Archivo de acceso FileInputStream FileOutputStream FileReader FileWriter
Matriz de acceso ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter
Tubería de acceso PipedInputStream PipedOutputStream PipedReader PipedWriter
Cadena de acceso StringReader StringWriter
Flujo de memoria intermedia BufferedInputStream BufferedOutputStream BuffedReader BufferedWriter
Flujo de conversión InputStreamReader OutputStreamWriter
Flujo de objetos ObjectInputStream ObjectOutputStream
FilterInputStream FilterOutputStream FilterReader FilterWriter
Imprimir flujo PrintStream PrintWriter
Flujo de entrada de rebote PushbackInputStream PushbackReader
Flujo especial DataInputStream DataOutputStream

Cuarto, la secuencia del archivo

Importar archivo

package cn.imut;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class IOTest {
    public static void main(String[] args) {
        FileReader fileReader = null;
        try {
            //1.File类实例化
            File file = new File("D:\\Test\\IO\\hello.txt");
            //2.FileReader流实例化
            fileReader = new FileReader(file);
            //3.读入操作
            char[] c = new char[5]; //表示每次读入5个
            int len;
            while ((len = fileReader.read(c)) != -1) {
                for (char value : c) {
                    System.out.print(value);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader != null) {
                //4.资源关闭
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Archivo

package cn.imut;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IOTest2 {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            //1.提供File类对象，指明写出到的文件
            File file = new File("D:\\Test\\IO\\hello.txt");
            //2.提供FileWriter对象，用于数据的写出
            fileWriter = new FileWriter(file);
            //3.写出操作
            fileWriter.write("hehe,I am you 's me");
            fileWriter.write("you a sb");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源关闭
            try {
                assert fileWriter != null;
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Nota: en la operación de salida, el archivo puede no existir. Si existe, el constructor utilizado por la secuencia es FileWriter (archivo, falso), y el archivo original se sobrescribe. Si es FileWrith (archivo, verdadero), ¡el archivo original no se sobrescribe!

package cn.imut;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IOTest3 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("D:\\Test\\IO\\hello.txt");
            File destFile = new File("D:\\Test\\IO\\hello1.txt");
            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);
            //3.数据的读入和写出操作
            char[] ch = new char[5];
            int len;
            while ((len = fr.read(ch)) != -1) {
                //每次写出 len个字符
                fw.write(ch,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert fw != null;
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileInputStream

package cn.imut;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;

public class IOTest4 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            //1.造文件
            File file = new File("D:\\Test\\IO\\hello2.txt");
            //2.造流
            fileInputStream = new FileInputStream(file);
            //3.读数据
            byte[] buffer = new byte[5];
            int len;    //记录每次读取的字节个数
            while ((len = fileInputStream.read(buffer)) != -1) {
                String str = new String(buffer,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            try {
                assert fileInputStream != null;
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Resumen

  • Para archivos de texto, use secuencias de caracteres (FileReader / Writer)
  • Para archivos que no son de texto, use la secuencia de bytes (FileInputStream / OutputStream)

Cinco, flujo de amortiguación

Para mejorar la velocidad de lectura y escritura de datos, la API de Java proporciona clases de flujo con funciones de almacenamiento en búfer. Cuando se utilizan estas clases de flujo, se crea una matriz de almacenamiento intermedio interno. De manera predeterminada , se usa un almacenamiento intermedio de 8192 bytes (8Kb).

El flujo del búfer debe "engarzarse" en el flujo del nodo correspondiente. Según la unidad de operación de datos, el flujo del búfer se puede dividir en

  • BufferedInputStream 和 BufferedOutputStream
  • BufferedReader 和 BufferedWriter

** Al leer datos, los datos se leen en el búfer en bloques, y las operaciones de lectura posteriores acceden directamente al búfer **

Al usar BufferedInputStream para leer un archivo de bytes, BufferedInputStream leerá 8192 (8Kb) del archivo al mismo tiempo y lo almacenará en el búfer hasta que el búfer esté lleno antes de leer los siguientes 8192 bytes del archivo nuevamente. Matriz

Al escribir bytes en la secuencia, no se escribirá directamente en el archivo. Primero se escribirá en el búfer hasta que el búfer esté lleno. BufferedOutputStream escribirá los datos del búfer en el archivo de inmediato. Use el método flush () para forzar que el contenido del búfer se escriba en la secuencia de salida

El orden de cierre de la secuencia es el reverso del orden de apertura de la secuencia. Mientras el flujo más externo esté cerrado, cerrar el flujo más externo también cerrará el flujo del nodo interno en consecuencia

Uso del método flush (): escriba manualmente el contenido del búfer en un archivo

Copia de la imagen

package cn.imut;

import java.io.*;

public class IOTest5 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File("D:\\Test\\IO\\Test.jpg");
            File destFile = new File("D:\\Test\\IO\\Test1.jpg");

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            BufferedInputStream bis = new BufferedInputStream(fis);
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert fis != null;
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert fos != null;
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Seis, flujo de conversión

La secuencia de conversión proporciona conversión entre la secuencia de bytes y la secuencia de caracteres

  • InputStreamReader: Convertir InputStream a Reader
  • OutputStreamWriter: Convertir Writer a OutputStrea

Cuando los datos en la secuencia de bytes son todos caracteres, la operación de conversión a una secuencia de caracteres es más eficiente

package cn.imut;

import java.io.*;

public class IOTest6 {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            File file1 = new File("D:\\Test\\IO\\hello.txt");
            File file2 = new File("D:\\Test\\IO\\www.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"utf-8");
            osw = new OutputStreamWriter(fos,"utf-8");

            char[] ch = new char[20];
            int len;
            while ((len = isr.read(ch)) != -1) {
                osw.write(ch,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert isr != null;
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert osw != null;
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6.1 Tabla de codificación común

  • ASCII: Código de intercambio de información estándar estadounidense, que se puede expresar con 7 bytes de un byte
  • ISO8859-1: tabla de códigos latinos, tabla de códigos europeos, expresada en 8 bits de un byte
  • GB2312: tabla de codificación china de China, hasta dos bytes codifican todos los caracteres
  • GBK: la tabla de codificación china de China se ha actualizado para incorporar más símbolos de texto en chino. Codificación de hasta dos bytes
  • Unicode: Código estándar internacional, que combina todos los caracteres utilizados actualmente por los humanos. Asigne un código de carácter único a cada personaje. Todo el texto está representado por dos bytes.
  • UTF-8: codificación de longitud variable, se pueden usar 1-4 bytes para representar un carácter

6.2 serialización de objetos

El mecanismo de serialización de objetos permite que los objetos Java en la memoria se conviertan en un flujo binario independiente de la plataforma, lo que permite que el flujo binario se almacene de manera persistente en el disco o se transmita a otro nodo de red a través de la red. Cuando otros programas obtienen esta secuencia binaria, se pueden restaurar al objeto Java original

ventaja serialización es que cualquier objeto que implementa la interfaz Serializable puede convertir en bytes de datos , se puede guardar y restaurado durante la transmisión

La serialización es un mecanismo que debe implementarse para los parámetros y valores de retorno de los procedimientos RMI (invocación de método remoto), y RMI es la base de JavaEE. Por lo tanto, el mecanismo de serialización es la base de la plataforma JavaEE.

Si necesita un objeto para soportar el mecanismo de serialización, debe hacer que la clase a la que pertenece el objeto y sus atributos sean serializables.Para hacer que una clase sea serializable, la clase debe implementar una de las siguientes dos interfaces. De lo contrario, se lanzará una excepción NotSerializableException

  • Serializable
  • Externalizable

Las clases que implementan la interfaz serializable tienen una variable estática que representa el identificador de versión serializada

  • privado estático final largo serialVersionUID
  • serialVersionUID se usa para indicar la compatibilidad entre diferentes versiones de la clase. En resumen, el propósito es serializar objetos para el control de versiones, y si las versiones son compatibles cuando se deserializan
  • Si la clase no define explícitamente esta constante estática, el entorno de tiempo de ejecución de Java genera automáticamente su valor en función de los detalles internos de la clase. Si se modifica la variable de instancia de la clase, serialVersionUID puede cambiar , por lo que se recomienda declararla explícitamente.

En pocas palabras, el mecanismo de serialización de Java verifica la coherencia de la versión determinando el serialVersionUID de la clase en tiempo de ejecución. Durante la deserialización, la JVM comparará el serialVersionUID en el flujo de bytes entrante con el serialVersionUID de la clase de entidad local correspondiente.Si son iguales, se consideran consistentes y se pueden deserializar. Excepción inconsistente. (InvalidCastException)

7. flujos de entrada y salida estándar

System.in y System.out representan los dispositivos de entrada y salida estándar del sistema, respectivamente.

El dispositivo de entrada predeterminado es: teclado, el dispositivo de salida es: display

** El tipo de System.in es InputStream, el tipo de System.out es PrintStream, que es una subclase de OutputStream, una subclase de FilterOutputStream **

Supongo que te gusta

Origin www.cnblogs.com/yfyyy/p/12735975.html
IO:
Recomendado
Clasificación
Diario
Más
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)

Code World

© 2018 codetd.com