Aprendizaje de funciones avanzadas de Java (súper detallado) tres (flujo de E/S de archivos)

Language 2023-08-26 18:37:19 views: null

Tabla de contenido

1. Introducción al archivo

1.1 Documentos en la vida

1.2 Archivos en la computadora

1.3 Adición y eliminación de archivos de archivos

1.4 Fluir en la vida

1.5 Transmisión por computadora

1.6 Dirección de la corriente

1.7 Clasificación de corrientes

2. Flujo de bytes

2.1 Flujo de entrada de bytes FileInputStream para lograr la lectura

2.2 Flujo de salida de bytes de FileInputStream para lograr la escritura

3. Flujo de personajes

3.1 Flujo de entrada de caracteres de FileReader para realizar la lectura

 3.2 Flujo de salida de caracteres FileWriter para lograr la escritura

4. Flujos almacenados en búfer

4.1 Flujo de caracteres FileReader más BufferedReader para realizar la lectura

4.2 Flujo de caracteres FileWriter más BufferedWriter para lograr la escritura 

5. Copiar

5.1 Flujo de caracteres para realizar la copia.

5.2 Copiar archivos binarios (imágenes, videos)

1. Introducción al archivo

1.1 Documentos en la vida

  1. El papel de los archivos, persistencia (opuesto al estado transitorio)
  2. Definición de un archivo: una colección de datos
  3. Ubicación de almacenamiento de archivos: disco, disco duro, disquete, disco U, etc.

1.2 Archivos en la computadora

  1. Definición de archivo: clase de archivo en java.io
  2. Usar Archivo: new File(); //Crear una instancia de archivo
  3. Propiedades del archivo: la ubicación del archivo, el nombre del archivo, el contenido del archivo

1.3 Adición y eliminación de archivos de archivos

(1) Cree un nuevo archivo: createNewFile()

        //实例化File文件对象，对象中参数存放有文件的路径和文件的名称
        //文件的路径D：\\或D：/
        File file = new File("/Users/yihongda/Downloads/jojo.txt");
        Demo001 demo001 = new Demo001();
        demo001.addFile(file);
public void addFile(File file) throws IOException {
        //新增文件
        //调用file对象的createNewFile()方法，获得返回值
        //如果某个磁盘路径没有对应文件，则可以创建文件，返回值为true
        //如果已经存在，则不能创建文件，返回值为false

        //exists() 判断某路径下文件是否存在
        if (file.exists()){
            System.out.println("该文件名已存在！");
        }else {
            boolean flag = file.createNewFile();
            if (flag){
                System.out.println("创建文件成功");
            }else{
                System.out.println("创建文件失败");
            }
        }
    }

 (2) Archivo de consulta——existe ()

public void findFile(File file){
        //查询文件名称
        if (!file.exists()){
            System.out.println("该文件不存在！！！");
        }else {
            System.out.println(file.getName());    //获取文件名称
            System.out.println(file.getAbsoluteFile());   //获取文件绝对路径
        }
    }

(3) Eliminar archivos——eliminar ()

    public void delFile(File file){
        //删除文件
        if(file.exists()){
            boolean flag = file.delete();
            if (flag){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }else {
            System.out.println("该文件不存在！！！");
        }
    }

1.4 Fluir en la vida

Flujo de personas, tráfico Similar a Colección de personas o automóviles.

1.5 Transmisión por computadora

  1. Definir la recopilación de datos [mecanismo: primero en entrar, primero en salir]
  2. La dirección de entrega del flujo: desde la fuente de datos de origen a la fuente de datos de destino

1.6 Dirección de la corriente

  1. Leer en [archivo  leído en el programa]
  2. Escribir 【El programa  escribe en un archivo】

1.7 Clasificación de corrientes

  1. Según la dirección del flujo: flujo de salida: OutputStream y Writer

               Flujo de entrada: InputStream y Reader

  1. Por unidad de procesamiento:

                Flujo de bytes: InputStream y OutputStream

                Flujo de personajes: lector y escritor

2. Flujo de bytes

2.1 Flujo de entrada de bytes FileInputStream para lograr la lectura

(1) Leer el primer bit de datos

/*
* 利用FileInputStream实现读入
* */
public class Demo002 {
    public static void main(String[] args) throws IOException {
        //步骤1：实例化FileInputStream对象
        FileInputStream fileInputStream = new FileInputStream("/Users/yihongda/Downloads/jojo.txt");

        //步骤2：fileInputStream对象的read（）方法获取文件中数据的第一个字节的内容对应的ascii码十进制的值【int类型的数值】
        int read = fileInputStream.read();

        //步骤3：对int类型read强制转换为char类型，则可原样输出
        System.out.println((char) read);

        fileInputStream.close();
    }
}

(2) Leer todos los datos (leer byte a byte)

/*
* 利用FileInputStream实现读入
* */
public class Demo002 {
    public static void main(String[] args) throws IOException {
        //步骤1：实例化FileInputStream对象
        FileInputStream fileInputStream = new FileInputStream("/Users/yihongda/Downloads/jojo.txt");

        //步骤2：定义临时变量data
        int data = 0;

        //步骤3：循环遍历文件中的read()，判断如果返回值为-1 则读取结束
        while((data = fileInputStream.read()) != -1){
            System.out.print((char)data);
        }

        fileInputStream.close();
    }
}

(3) Leer todos los datos (leer en unidades de matrices de bytes)

El tamaño de la matriz general es múltiplo de 1024.

public class Demo003 {
    public static void main(String[] args) throws IOException {
        //步骤1：实例化FileInputStream对象
        FileInputStream fileInputStream = new FileInputStream("/Users/yihongda/Downloads/jojo.txt");

        //步骤2：定义临时变量
        int data = 0;

        //步骤3：定义数组
        byte[] b = new byte[1024];

        //步骤4：循环读取到数组中
        while ((data = fileInputStream.read(b)) != -1){
            for (int i = 0 ; i < data ; i++){
                System.out.print((char)b[i]);
            }
        }
        fileInputStream.close();
    }
}

2.2 Flujo de salida de bytes de FileInputStream para lograr la escritura

(1) Leer datos y escribir en un nuevo archivo (copiar)

public class Demo004 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("/Users/yihongda/Downloads/jojo.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("/Users/yihongda/Downloads/jojo_copy.txt");

        //1.定义临时变量
        int data = 0;
        //2.定义字节数组
        byte[]b = new byte[1024];
        //3.循环读取输入流fileInputStream并写到输出流fileOutputStream对象中
        while ((data = fileInputStream.read(b)) != -1){
            fileOutputStream.write(b,0,data);
        }

        fileOutputStream.close();
        fileInputStream.close();
    }
}

(2) Expansión: el código de este capítulo arroja una excepción en todo el método principal, que en realidad es irregular y no propicia el mantenimiento.

Normalmente, try-catch se usa para generar excepciones.

public class Demo005 {
    public static void main(String[] args){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream("/Users/yihongda/Downloads/jojo.txt");
            fileOutputStream = new FileOutputStream("/Users/yihongda/Downloads/jojo_copy.txt");
            //1.定义临时变量
            int data = 0;
            //2.定义字节数组
            byte[]b = new byte[1024];
            //3.循环读取输入流fileInputStream并写到输出流fileOutputStream对象中
            while ((data = fileInputStream.read(b)) != -1){
                fileOutputStream.write(b,0,data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            }catch (IOException e1){
                e1.printStackTrace();
            }
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
            }catch (IOException e1){
                e1.printStackTrace();
            }
        }
    }
}

3. Flujo de personajes

3.1 Flujo de entrada de caracteres de FileReader para realizar la lectura

public class Demo006 {
    public static void main(String[] args) {
        FileReader fileReader = null;

        try {
            //步骤1：实例化FileReader对象
            fileReader = new FileReader("/Users/yihongda/Downloads/jojo.txt");

            //步骤2：定义临时变量data
            int data = 0;

            //步骤3：定义char数组
            char []c = new char[1024];

            //步骤4：循环读取数组中的数据
            while ((data = fileReader.read(c)) != -1){
                //步骤5：输出数组中的数据
                for (int i = 0 ; i < data ; i++)
                System.out.print(c[i]);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //步骤6：判断fileReader对象不为空【如果流存在的话】
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

 3.2 Flujo de salida de caracteres FileWriter para lograr la escritura

public class Demo007 {
    public static void main(String[] args) {
        FileWriter fileWriter = null;

        //拓展1：fileWriter = new FileWriter("/Users/yihongda/Downloads/jojo.txt",true);代表每次拼接字符串到文件中
        try {
            fileWriter = new FileWriter("/Users/yihongda/Downloads/jojo.txt",true);
            fileWriter.write("杰洛齐贝林");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //拓展2：字符输出流写出时必须close（），否则方法失效
            try {
                fileWriter.close();
                //拓展3：如果不加close（），则可以添加Flush()强制刷新，也可以实现效果
                fileWriter.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

4. Flujos almacenados en búfer

4.1 Flujo de caracteres FileReader más BufferedReader para realizar la lectura

Puntos principales: BufferReader es similar a colocar una capa de canalización en el exterior de FileReader

public class Demo008 {
    public static void main(String[] args) {
        Reader fr = null;
        BufferedReader br = null;

        try {
            //步骤1：实例化FileReader对象
            fr = new FileReader("/Users/yihongda/Downloads/jojo.txt");
            //步骤2：实例化BufferReader对象，参数是FileReader对象
            br = new BufferedReader(fr);

            String data = null;
            while ((data = br.readLine()) != null){
                System.out.println(data);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.2 Flujo de caracteres FileWriter más BufferedWriter para lograr la escritura 

public class Demo009 {
    public static void main(String[] args) {
        Writer fw = null;
        BufferedWriter bw = null;

        try {
            fw = new FileWriter("/Users/yihongda/Downloads/jojo.txt",true);
            bw = new BufferedWriter(fw);
            bw.write("jojo");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

5. Copiar

5.1 Flujo de caracteres para realizar la copia.

El flujo de caracteres + el flujo de búfer realizan la copia de un archivo, aquí la copia de videos e imágenes pierde mucho

public class Demo010 {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;

        FileWriter fw = null;
        BufferedWriter bw = null;

        try {
            //步骤1：实例化FileReader对象
            fr = new FileReader("/Users/yihongda/图/薇尔莉特.jpeg");
            //步骤2：实例化BufferedReader对象，参数是FileReader对象
            br = new BufferedReader(fr);

            //步骤3：实例化FileWriter对象
            fw = new FileWriter("/Users/yihongda/图/薇尔莉特new.jpeg");
            //步骤4：实例化BufferedWriter对象，参数是FileWriter对象
            bw = new BufferedWriter(fw);

            //步骤5：定义临时变量
            String data = null;

            //步骤6：定义可编辑字符串
            StringBuffer sb = new StringBuffer();
            //步骤7：循环读取流中的数据
            while ((data = br.readLine()) != null){
                sb.append(data);
            }
            //步骤8：读出数据到文件中
            bw.write(sb.toString());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                fw.close();
                br.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

5.2 Copiar archivos binarios (imágenes, videos)

Al usar DataInputStream para transferir, la pérdida de archivos es muy pequeña. Aunque rara vez se usa directamente, la mayoría de las tecnologías para copiar y transferir archivos binarios se implementan usándolo como tecnología subyacente.

public class Demo011 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        DataInputStream dis = null;

        FileOutputStream fos = null;
        DataOutputStream dos = null;

        try {
            fis = new FileInputStream("/Users/yihongda/图/薇尔莉特.jpeg");
            dis = new DataInputStream(fis);

            fos = new FileOutputStream("/Users/yihongda/图/薇尔莉特new.jpeg");
            dos = new DataOutputStream(fos);

            byte[]b = new byte[1024];
            int len = 0;
            while ((len = dis.read(b)) != -1){
                dos.write(b,0 , len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                dos.close();
                fos.close();
                dis.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

Supongo que te gusta

Origin blog.csdn.net/jojo_oulaoula/article/details/131474307
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