Day15——File类与IO流

1.java.io.File类的使用

1.1 File类的理解

File 类及本章下的各种流，都定义在 java.io 包下。
一个 File 对象代表硬盘或网络中可能存在的一个文件或者文件目录（俗称文件夹），与平台无关。（体会万事万物皆对象）。
File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
- File 对象可以作为参数传递给流的构造器。
想要在 Java 程序中表示一个真实存在的文件或目录，那么必须有一个 File 对象，但是Java 程序中的一个 File 对象，可能没有一个真实存在的文件或目录。

1.2 构造器

public File(String pathname) ：以 pathname 为路径创建 File 对象，可以是绝对路径或者相对路径，如果 pathname 是相对路径，则默认的当前路径在系统属性user.dir 中存储。
- 绝对路径：包括盘符在内的文件或文件目录的完整路径。
- 相对路径：相对于某一个文件目录来讲的相对位置。
  - 在IDEA中，如果使用main方法，相对于当前的project来说。
  - 如果使用单元测试方法，相对于当前的module来讲。
public File(String parent, String child) ：以 parent 为父路径，child 为子路径创建 File 对象。
- 参数1：一定是文件目录。
- 参数2：可以是文件或文件目录。
public File(File parent, String child) ：根据一个父 File 对象和子文件路径创建 File 对象。
- 参数1：一定是文件目录。
- 参数2：可以是文件或文件目录。

1.3 常用方法

1.3.1 获取文件和目录基本信息

public String getName() ：获取名称。
public String getPath() ：获取路径。
public String getAbsolutePath()：获取绝对路径。
public File getAbsoluteFile()：获取绝对路径表示的文件。
public String getParent()：获取上层文件目录路径。若无，返回 null。
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值。
- 如果 File 对象代表的文件或目录存在，则 File 对象实例初始化时，就会用硬盘中对应文件或目录的属性信息（例如，时间、类型等）为File 对象的属性赋值，否则除了路径和名称，File 对象的其他属性将会保留默认值。

1.3.2 列出目录的下一级

public String[] list() ：返回一个 String 数组，表示该 File 目录中的所有子文件或目录。
public File[] listFiles() ：返回一个 File 数组，表示该 File 目录中的所有的子文件或目录。

1.3.3 File类的重命名功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径。

1.3.4 判断功能的方法

public boolean exists() ：此 File 表示的文件或目录是否实际存在。
public boolean isDirectory() ：此 File 表示的是否为目录。
public boolean isFile() ：此 File 表示的是否为文件。
public boolean canRead() ：判断是否可读。
public boolean canWrite() ：判断是否可写。
public boolean isHidden() ：判断是否隐藏。

1.3.5 创建、删除功能

public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false。
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建。
public boolean delete() ：删除文件或者文件夹删除注意事项：
- Java 中的删除不经过回收站。
- 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

/**
 * 创建一个与hello.txt在相同文件目录下的另一个名为abc.txt的文件
 */
public class Exer1 {
    public static void main(String[] args) {
        File file1 = new File("hello.txt");
        System.out.println(file1.getAbsolutePath());
        File file2 = new File(file1.getAbsoluteFile().getParent(), "abc.txt");
        System.out.println(file2.getAbsolutePath());
    }
}

2.IO流原理及流的分类

2.1 IO原理

I/O 流中的 I/O 是 Input/Output 的缩写， I/O 技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

输入 input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出 output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

2.2 流的分类

java.io 包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

按数据的流向不同分为：输入流和输出流。
- 输入流：把数据从其他设备上读取到内存中的流。以 InputStream、Reader 结尾。
- 输出流：把数据从内存中写出到其他设备上的流。以 OutputStream、Writer 结尾。
按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）。
- 字节流：以字节为单位，读写数据的流。以InputStream、OutputStream 结尾。
- 字符流：以字符为单位，读写数据的流。以 Reader、Writer 结尾。
根据 IO 流的角色不同分为：节点流和处理流。
- 节点流：直接从数据源或目的地读写数据。
- 处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

3.流的API

Java 的 IO 流共涉及 40 多个类，实际上非常规则，都是从如下 4 个抽象基类派生的。

输入流：
- 字节流：InputStream。
- 字符流：Reader。
输出流：
- 字节流：OutputStream。
- 字符流：Writer。

3.1 常用的节点流

文件流： FileInputStream、FileOutputStrean、FileReader、FileWriter 。
字节/字符数组流： ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter。
- 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。

3.2 常用的处理流

缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。
- 作用：增加缓冲功能，避免频繁读写硬盘，进而提升读写效率。
转换流：InputStreamReader、OutputStreamReader。
- 作用：实现字节流和字符流之间的转换。
对象流：ObjectInputStream、ObjectOutputStream。
- 作用：提供直接读写 Java 对象功能。

4.FileReader\FileWriter的使用

4.1 执行步骤

第1步：创建读取或写出File类的对象。
第2步：创建输入流或输出流。
第3步：具体的读入或写出的过程。
- 读入：read(char[] cbuffer)
- 写出：write(String str)/write(char[] cbuffer,0,len)
第4步：关闭流，避免内存泄漏。

    @Test
    public void test2() {
        FileReader reader = null;
        try {
            //1.创建File对象，对应hello.txt文件
            File file = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p177\\hello.txt");
            //2.创建输入的字符流，用于读取数据
            reader = new FileReader(file);
            //3.读取数据并显示到控制台上
            char[] cbuffer = new char[5];
            int len;
            while ((len = reader.read(cbuffer)) != -1) {
                for (int i = 0; i < len; i++) {
                    System.out.print(cbuffer[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test3(){
        FileWriter fileWriter = null;
        try {
            //1.创建File对象，指明要写出的文件名称
            File file = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p177\\info.txt");
            //2.创建输出流
            //覆盖文件使用的构造器
            fileWriter = new FileWriter(file);
            //在现有的文件基础上追加内容使用的构造器
            fileWriter = new FileWriter(file, false);
            //3.写出的具体过程
            fileWriter.write("hellowoeld123");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null)
                    //4.流的关闭
                    fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4.2 注意点

涉及到流资源的关闭操作，所以出现异常时，需要使用try-catch-finally方式来处理异常。
对于输入流来说，要求File类的对象对应的物理磁盘上的文件必须存在，否则会报FileNotFoundException。
对于输出流来说，File类的对象对应物理磁盘上的文件可以不存在。
- 如果此文件不存在，则在输出的过程中自动创建此文件，并写出数据到此文件中。
- 如果此文件存在：
  - 使用FileWriter(File file)或FileWriter(File file,false)：在输出数据过程中，会新建同名的文件对现有的文件进行覆盖。
  - 使用FileWriter(File file,true)：在输出数据过程中，会在现有的文件的末尾追加写出的内容。

5.FileInputStream\FileOutputStream的使用

5.1 执行步骤

第1步：创建读取或写出File类的对象。
第2步：创建输入流或输出流。
第3步：具体的读入或写出的过程。
- 读入：read(byte[] buffer)
- 写出：write(byte[] buffer,0,len)
第4步：关闭流，避免内存泄漏。

    /**
     * 需求：复制图片
     */
    @Test
    public void test1() {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            //1.创建相关的File类的对象
            File srcFile = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p178\\2391e3248003e6ec91f355117ac020c.jpg");
            File destFile = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p178\\1.jpg");
            //2.创建相关的字节流
            inputStream = new FileInputStream(srcFile);
            outputStream = new FileOutputStream(destFile);
            //3.数据的读入和写出
            byte[] buffer = new byte[1024];
            int len;    //记录每次读入到buffer中字节的个数
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4.关闭流资源
                if (outputStream != null)
                    outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                //4.关闭流资源
                if (inputStream != null)
                    inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

5.2 注意点

涉及到流资源的关闭操作，所以出现异常时，需要使用try-catch-finally方式来处理异常。
对于输入流来说，要求File类的对象对应的物理磁盘上的文件必须存在，否则会报FileNotFoundException。
对于输出流来说，File类的对象对应物理磁盘上的文件可以不存在。
- 如果此文件不存在，则在输出的过程中自动创建此文件，并写出数据到此文件中。
- 如果此文件存在：
  - 使用FileWriter(File file)或FileWriter(File file,false)：在输出数据过程中，会新建同名的文件对现有的文件进行覆盖。
  - 使用FileWriter(File file,true)：在输出数据过程中，会在现有的文件的末尾追加写出的内容。
字符流只能用来操作文本文件，不能用来处理非文本文件。
字节流通常用来处理非文本文件。但涉及到文本文件的复制操作也可以使用字节流。

5.3 说明

文本文件：txt、.java、.c 、.cpp、.py等
非文本文件：.doc、.xls、.jpg、.pdf、.mp3等

6.缓冲流

6.1 介绍

BufferedInputStream
BufferedOuputStream
BufferedReader
BufferedWriter

6.2 缓冲流的作用

提升文件读写的效率。

6.3 使用方法

6.3.1 处理非文本文件的字节流

BufferedInputStream：read(byte[] buffer)
BufferedOuputStream：write(byte[] buffer,0,len)

6.3.2 处理文本文件的字符流

BufferedReader：read(char[] cBuffer)/readLine()
BufferedWriter：write(char[] cBuffer,0,len)

6.4 执行步骤

创建File对象、流的对象（包括文件流、缓冲流）。
使用缓冲流实现读取数据或写出数据的过程：
- 读取：int read(char[] cbuf/byte[] buffer)：每次将数据读入到cbuf/buffer数组中，并返回读入到数组中。
- 写出：
  - void write(String str)/write(char[] cbuf)：将str或cbuf写出到文件中。
  - void write(byte[] buffer)：将byte[]写出到文件中。
关闭资源。

    /**
     * 使用BufferedInputStream\BufferedOutputStream复制文件
     */
    @Test
    public void test1() {
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //1.创建相关的File类的对象
            File srcFile = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p178\\2391e3248003e6ec91f355117ac020c.jpg");
            File destFile = new File("C:\\Users\\22923\\Desktop\\Java\\Java SE\\src\\p178\\1.jpg");
            //2.创建相关的字节流、缓冲流
            FileInputStream inputStream = new FileInputStream(srcFile);
            FileOutputStream outputStream = new FileOutputStream(destFile);
            bufferedInputStream = new BufferedInputStream(inputStream);
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            //3.数据的读入和写出
            byte[] buffer = new byte[1024];
            int len;    //记录每次读入到buffer中字节的个数
            while ((len = bufferedInputStream.read(buffer)) != -1) {
                bufferedOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭外层缓冲流资源。
            //由于关闭外层流时会自动对内层流执行关闭操作，所以可以省略关闭内层流的操作
            try {
                if (bufferedOutputStream != null)
                    bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bufferedInputStream != null)
                    bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 使用BufferedReader和BufferedWriter完成文本文件的复制
     */
    @Test
    public void test2() {
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            File file1 = new File("hello.txt");
            File file2 = new File("hello——copy.txt");
            bufferedReader = new BufferedReader(new FileReader(file1));
            bufferedWriter = new BufferedWriter(new FileWriter(file2));
            String data;
            while ((data = bufferedReader.readLine()) != null){
                bufferedWriter.write(data);
                bufferedWriter.newLine();   //换行操作
                bufferedWriter.flush(); //刷新方法，每当调用此方法时，会主动将内存中数据写出到磁盘文件中
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null)
                    bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }try {
                if (bufferedWriter != null)
                    bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

7.转换流

其作用是实现字节与字符之间的转换。
在这里插入图片描述

7.1 InputStreamReader与OutputStreamWriter

InputStreamReader：将一个输入型的字节流转换为输入型的字符流。
OutputStreamWriter：将一个输出型的字符流转换为输出型的字节流。

    @Test
    public void test2() {
        FileOutputStream fos = null;
        OutputStreamWriter oos = null;
        try {
            File file1 = new File("hello.txt");
            File file2 = new File("hello_utf8.txt");
            FileInputStream fis = new FileInputStream(file1);
            InputStreamReader isr = new InputStreamReader(fis, "GBK");
            fos = new FileOutputStream(file2);
            oos = new OutputStreamWriter(fos, "utf8");
            char[] cBuffer = new char[1024];
            int len;
            while ((len = isr.read()) != -1) {
                oos.write(cBuffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

7.2 字符集

7.2.1 在存储文件中的字符

ASCII：主要用来存储a、b、c等英文字符和1、2、3、常用的标点符号。
iso-8859-1：了解，每个字符占用1个字节。向下兼容ascii。
GBK：用来存储中文简体繁体、a、b、c等英文字符和1、2、3、常用的标点符号等字符。
UTF-8：可以用来存储世界范围内主要的语言的所有的字符。使用1-4个不等的字节表示一个字符。中文字符使用3个字节存储的。向下兼容ascii，意味着英文字符、1、2、3、标点符号仍使用1个字节。

7.2.2 在内存中的字符

一个字符（char）占用2个字节。在内存中使用的字符集称为Unicode字符集。

8.数据流和对象流

8.1 数据流

DataOutputstream:可以将内存中的基本数据类型的变量、String类型的变量写出到具体的文行中。
DataInputStream:将文件中保存的数据还原为内存中的基本数据类型的变量、String类型的变量。

8.2 对象流

8.2.1 API

ObjectInputStream
ObjectOutputStream

8.2.2 作用

可以读写基本数据类型的变量和引用数据类型的变量。

8.3 对象的序列化机制

对象序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。

8.3.1 序列化的意义

8.3.2 序列化过程

使用ObjectOutputStream实现，将内存中的Java对象保存在文件中或通过网络传输出去。

    /**
     * 序列化过程
     *
     * @throws IOException
     */
    @Test
    public void test1() throws IOException {
        File file = new File("hello.txt");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeUTF("hello");
        oos.close();
    }

8.3.3 反序列化过程

使用ObjectInputStream实现，将文件中的数据或网络传输过来的数据还原为内存的Java对象。

    /**
     * 反序列化过程
     *
     * @throws IOException
     */
    @Test
    public void test2() throws IOException {
        File file = new File("hello.txt");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        String str1 = ois.readUTF();
        System.out.println(str1);
        ois.close();
    }

8.3.4 自定义类实现序列化机制的要求

自定义类需要实现接口：Serializable。
要求自定义类声明一个全局常量：static final long serialVersionUID=42234234L；用来唯一标识当前类。
如果不声明全局常量serialVersionUID，系统会自动声明一个针对于当前类的serialVersionUID。但是修改此类时，会导致serialVersionUID变化，进而导致反序列化时，出现InvaliedClassException异常。
要求自定义类的各个属性也必须可序列化：
- 对于基本数据类型的属性，默认可以序列化。
- 对于引用数据类型的属性，要求实现Serializable接口。
类中的属性如果声明为transient或static，则不会实现序列化。