Programación central de Java - flujo IO

Enterprise 2023-08-12 18:31:03 views: null

Tabla de contenido

1. Archivo

1. Crear un objeto de archivo

2. Método de construcción de archivos

3. Métodos comunes

2. Descripción general del flujo de E/S

3. Flujo de bytes

1. FIS y FOS

2. BPI y BOS

1. Archivo

  • java.io.File representa un archivo (directorio) y opera en archivos y directorios locales.
  • El objeto File solo puede manipular la información básica del archivo (nombre, tamaño, etc.). No se puede acceder al contenido del archivo.

1. Crear un objeto de archivo

     1.1 Fuerza Relativa del Camino y Fuerza Absoluta del Camino

                Ruta relativa: relativa a la ubicación del directorio de escritura actual

../demo/a.txt//上级目录的a.txt

                Ruta absoluta: se refiere a la ruta donde realmente existe el archivo en el disco duro

D:\IdeaProjects\javase

2. Método de construcción de archivos

  •  Archivo: ruta de archivo u objeto de archivo, ¡no describe el archivo en sí!
  •  Representación abstracta de nombres de ruta de archivos y directorios
import java.io.File;

public class TestFile {

    public static void main(String[] args) {

        //1.构造方法

        //-- File(String  pathname)
        File file = new File("D:\\program\\A_hqyj\\ideaprojects\\javase-220302\\java-coreprogramming\\src\\com\\hqyj\\qpi\\io\\TestFile.java");
        System.out.println(file);      //  抽象表示
        System.out.println(file.exists());

        //-- File(String parent,String child)
        String parent = "D:\\program\\A_hqyj\\ideaprojects\\javase-220302\\java-coreprogramming\\src\\com\\hqyj\\qpi\\io";
        File file2 = new File(parent, "TestFile.java");
        System.out.println(file2.exists());


        //- File(File parent,String child)
        File parentPath = new File(parent);
        File file3 = new File(parentPath, "TestFile.java");
        System.out.println(file3.exists());

        /*
        2.问题来了路径如果传入绝对路径很复杂
           --绝对路径：从盘符开始的路径
           --相对路径：从Module（子工程）开始的   ！！！类路径
             -".":系统默认路径
         */
        File file4 = new File("java-coreprogramming\\src\\com\\hqyj\\qpi\\io\\TestFile.java");
        System.out.println(file4.exists());   //相对路径

        //测试相对路径
        File file5 = new File("textFile.txt");
        System.out.println(file5.exists());

        //系统的默认路径
        File file6 = new File(".");
        System.out.println(file6.exists());
        System.out.println(file6.getAbsolutePath());

        /*
            路径分隔符
            -- 正斜杠 /（建议使用）
            -- 反斜杠 \\（win独有）
         */

        File file7 = new File("java-coreprogramming/src/com/hqyj/qpi/io/TestFile.java");
        System.out.println(file7.exists());
        


    }

}

3. Métodos comunes

import java.io.File;
import java.util.Arrays;
import java.util.Date;

/**
 *
 * 常用方法
 */
public class TestFile2 {

    public static void main(String[] args) throws  Exception {
        //0.准备工作，在io包下创建文件和目录

        
        File file = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile");
        file.mkdir();
        System.out.println(file.exists());

        //创建一个文件名
        File file2 = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile/demo.properties");
        file2.createNewFile();

        //测试此文件是否可读
        System.out.println(file2.canRead());

        //4.测试是不是一个文件或者目录
        System.out.println(file2.isFile());
        System.out.println(file2.isDirectory());

        //5.返回路径或者文件最后一次被修改的时间
        System.out.println(new Date(file2.lastModified()));

        //6.获取此抽象文件或者目录的名称
        System.out.println(file2.getName());

        //7.判断当前文件是否可写
        System.out.println(file2.canWrite());

        //8.获取文件的长度
        System.out.println(file2.length());

        //9.创建多级目录
        File file3 = new File(file, "a");
        System.out.println(file3.mkdirs());

        //10.删除一个路径
        file3.delete();

        //问题：File对象操作的是文件内容还是文件的基本信息呢？ 操作的是文件的基本信息
           //File 就是该文件路径表示的对象，而不是操作内容本身。

        //11.打印当前目录下的所有内容
        File file4 = new File(".");
        File[] files = file4.listFiles();
        System.out.println(Arrays.toString(files));

        String[] list = file4.list();
        System.out.println(Arrays.toString(list));



    }
}

2. Descripción general del flujo de E/S

  • IO: se refiere a entrada y salida

       Entrada: entrada, desde el mundo exterior al programa, leer datos

       Salida: salida, del programa al mundo exterior, escribir datos

  • Clasificación de corrientes:

        ** flujo de bytes y flujo de caracteres

                Flujo de bytes: la unidad más pequeña de transferencia de datos es byte         

                Flujo de caracteres: la unidad más pequeña de datos transmitidos es un carácter.

        **Flujo de nodo (flujo de bajo nivel) y flujo de procesamiento (flujo de alto nivel o flujo de filtro)

                Flujo de nodo: puede leer y escribir datos en un lugar específico

                Flujo de procesamiento: encapsula el flujo del nodo y realiza la lectura y escritura de datos a través de la llamada de función del flujo encapsulado.

         **Enlace de transmisión: un objeto de transmisión se convierte en un enlace de transmisión después de haber sido empaquetado varias veces por otras transmisiones.

3. Flujo de bytes

  • El flujo de bytes tiene dos clases abstractas: InputStream y OutputStream
  • Métodos comunes de IS (InputStream)
  • Métodos comunes de OS (OutputStream)

1. FIS y FOS

         Flujo de 1.1 bytes FIS y FOS

  •                FIS: FileInputStream, flujo de entrada de archivos

FileInputStream (archivo de archivo)

        Crea un FileInputStream al abrir una conexión con el archivo real especificado por el archivo del objeto File en el sistema de archivos.

FileInputStream (nombre de la cadena)

        Crea un FileInputStream al abrir una conexión con el archivo real especificado por el nombre de ruta en el sistema de archivos.

  •                FOS: FileOutputStream, flujo de salida de archivos

FileOutputStream (archivo de archivo)

        Crea un flujo de salida de archivo que escribe datos en el archivo representado por el objeto File especificado.

FileOutputStream (Archivo de archivo, anexo booleano)

        Crea un flujo de salida de archivo que escribe datos en el archivo representado por el objeto File especificado.

FileOutputStream (nombre de la cadena)

        Crea una secuencia de archivos de salida que escribe datos en el archivo con el nombre especificado.

FileOutputStream (nombre de cadena, anexo booleano)

        Crea una secuencia de archivos de salida que escribe datos en el archivo con el nombre especificado.

        1.2 Lectura y escritura de FileInputStream

/**
 * fileInputStream FileOutputSream
 *
 *
 * 字节流：凡是以Stream结尾的都是字节流
 */
public class TestFISAndFOS2 {

    public static void main(String[] args) throws  Exception{

        //读入
        InputStream inputStream = null;
        OutputStream outputStream = null;

        File file = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile/fis1.txt");
        try {
            inputStream= new FileInputStream(file);

            for (int j= 1; ; j++) {
                 int io = inputStream.read();
                if (io == -1) {
                    break;
                }
                System.out.print((char ) io);
            }
        }catch (Exception e){
            e.printStackTrace();
        } finally {
            inputStream.close();
        }
        System.out.println();


        //写出
        byte[] bytes = new byte[]{'o','u','t'};
        try {
            outputStream = new FileOutputStream(file,true);
            outputStream.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            outputStream.close();
        }

    }
}

    1.3 Copia del contenido del archivo

      Se necesitan pruebas unitarias en este momento, el siguiente es el contenido de las pruebas unitarias

      1. Prueba de lectura y escritura

                --Unidad (cada método es una unidad) prueba:

                         --@Before : En el mismo java, el contenido que se debe ejecutar antes de ejecutar @Test

                         --@After : En el mismo java, el contenido que se debe ejecutar después de ejecutar @Test

                         --@Test : En el mismo java se debe ejecutar el contenido de @Test 

      2. Ruta de prueba unitaria

                 Ruta absoluta: a partir de la letra de la unidad

                 Ruta relativa: la ubicación de compilación de la prueba unitaria es diferente de la función principal

                         --main comienza con el módulo

                         --Las pruebas unitarias comienzan desde Classpath (ruta de clase)

                         -- Puede marcar un directorio de archivos ordinario como ruta de clase Crear directorio como 

prueba:


import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.*;

/*
        测试读写
          --单元(每一个方法都是一个单元)测试：
             --@Before :同一个java中，执行@Test前必须执行的内容
             --@After :同一个java中，执行完@Test后必须执行的内容
             --@Test :同一个java中，必须执行@Test的内容
         */
public class TestFISAndFOS3  {

    //练习通过上面的案例尝试读取文件中所有的字节，并尝试创建OutputStream,向文件中写入内容

    File file;
    FileInputStream fis;
    FileOutputStream fos;

    //准备资源
    @Before
    public void testBefore(){
        /*
        单元测试：
            绝对路径：从盘符开始
            相对路径：单元测试编译位置和main函数不同
                    --main从module开始
                    --单元测试从Classpath开始（类路径）
                      可以标记一个普通的文件目录为classpath
                      Make Directory As
         */
        String path  = "resource\\fis1.txt";
        file = new File(path);
    }

    //写
    @Test
    public void testWirte() throws  Exception{
        /*
        构造方法中：boolean append参数如果为true表示追加
         */
        fos = new FileOutputStream(file,true);
        fos.write(65);


    }

    //读
    @Test
    public  void  testRead() throws  Exception{

        fis = new FileInputStream(file);
        int i = -1;
        while ((i = fis.read()) != -1) {
            System.out.println((char)i);
        }

    }

    //byte[]写
    @Test
    public void  testWriteByts() throws  Exception{
        fos = new FileOutputStream(file,true);
        byte[] bytes1 = new byte[]{65,66,67,68,69};
        fos.write(bytes1);
    }

    //byte[]读
    @Test
    public void  testReadByts() throws  Exception{
        fis = new FileInputStream(file);
        byte[] bytes2 = new byte[100];
        int i = fis.read(bytes2);
        System.out.println(new String(bytes2));
    }

    //测试使用fis和fos实现文件的复制 将fis1.txt的内容复制到fis1_copy.txt,采用byte实现
    //byte复制
    @Test
    public void  testcopy() throws  Exception {
        //定义文件路径
        fis = new FileInputStream(file);
                            //如果没有文件，会自动生成文件
        fos = new FileOutputStream("resource\\fis1_copy.txt");
        //定义数组
        byte[] bytes = new byte[1024];
        //读
        fis.read(bytes);

        //写
        fos.write(bytes);

             /*
        int i = -1;
        while(i = fis.read(bytes) != -1) {
            fos.write(bytes);
        }
         */
    }

    //关闭资源
    @After
    public void testAfter() throws  Exception{
        if (fos != null){
            fos.close();
        }
        if (fis != null) {
            fis.close();
        }
    }

}

2. BPI y BOS

  • Ventajas del búfer: reduce el número de lecturas y escrituras
  • flush (): borra el búfer y escribe todos los datos en el búfer
  • BIS: Flujo de entrada almacenado en búfer BufferedInputStream

BufferedInputStream (InputStream en)

                Cree un BufferedInputStream y guarde su parámetro, el flujo de entrada, para uso futuro. BufferedInputStream (InputStream en, tamaño int)

                Crea un BufferedInputStream con el tamaño de búfer especificado y guarda su argumento, el flujo de entrada, para uso futuro.

  • BOS: flujo de salida almacenado en búfer BufferedOutputStream

BufferedOutputStream (OutputStream fuera)

                Crea un nuevo flujo de salida almacenado en búfer para escribir datos en el flujo de salida subyacente especificado. BufferedOutputStream (OutputStream fuera, tamaño int)

                Crea un nuevo flujo de salida almacenado en búfer para escribir datos con el tamaño de búfer especificado en el flujo de salida subyacente especificado.

2.1 Flujos de entrada y salida de almacenamiento en búfer

public class TestBISAndBOS {

    File file;
    FileInputStream fis;
    FileOutputStream fos;
    BufferedInputStream bis;
    BufferedOutputStream bos;

    @Before
    public  void  createFile() throws Exception {
        String s = "resource\\bis1.txt";
        file = new File(s);

    }

    //写出
    @Test
    public  void write() throws  Exception {
        //先去创建低级流
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos,10); //以低级流fos作为载体
        //写出内容
        bos.write("I am a boy".getBytes());
        bos.flush();//立即写出
    }

    //读入
    @Test
    public  void read() throws  Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        byte[] bytes = new byte[1024];
        //读入
        bis.read(bytes);
        System.out.println(new String(bytes));
    }
   

    @After
    public  void  close() throws  Exception {
        //先关闭高级流，在关闭低级流
        if (bos != null)
            bos.close();
        if (bis != null)
            bis.close();
        if (fos != null)
            fos.close();
        if (fis != null)
            fis.close();
    }

}

2.2 Copiar el contenido del archivo

public class TestBISAndBOS {

    File file;
    FileInputStream fis;
    FileOutputStream fos;
    BufferedInputStream bis;
    BufferedOutputStream bos;

    @Before
    public  void  createFile() throws Exception {
        String s = "resource\\bis1.txt";
        file = new File(s);

    }

    //写出
    @Test
    public  void write() throws  Exception {
        //先去创建低级流
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos,10); //以低级流fos作为载体
        //写出内容
        bos.write("I am a boy".getBytes());
        bos.flush();//立即写出
    }

    //读入
    @Test
    public  void read() throws  Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        byte[] bytes = new byte[1024];
        //读入
        bis.read(bytes);
        System.out.println(new String(bytes));
    }
    //复制文件内容
    //练习：使用bis和bos实现文件的复制，bis_copy.txt，参考fis和fos的方法
    @Test
    public void testcopy() throws Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        fos = new FileOutputStream("resource\\bis_copy.txt");
        bos = new BufferedOutputStream(fos);
        byte[] b = new byte[1024];
        int i = -1;
        while (( i = bis.read(b)) != -1) {
            bos.write(b);
        }
    }

    @After
    public  void  close() throws  Exception {
        //先关闭高级流，在关闭低级流
        if (bos != null)
            bos.close();
        if (bis != null)
            bis.close();
        if (fos != null)
            fos.close();
        if (fis != null)
            fis.close();
    }

}

Supongo que te gusta

Origin blog.csdn.net/weixin_46048259/article/details/124305087
Recomendado
Clasificación
Diario
Más
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)
2024-04-28(9)
2024-04-27(28)
2024-04-26(22)
2024-04-25(34)
2024-04-24(31)
2024-04-23(29)
2024-04-22(5)

Code World

© 2018 codetd.com