什么是JavaIO？

Java IO 是 Java 编程语言提供的一个用于操作输入输出（I/O）的应用程序接口。它提供了许多类和接口来处理不同类型的 I/O 操作和方式。Java I/O 主要分为两个部分：流和文件。流提供了一种通用的机制来处理不同类型的 I/O，而文件提供了一种标准的方式来操作文件系统中的文件。

流(Stream)

在 Java 中，流是一组抽象类和接口，用于读取和写入数据。流可以根据数据的方向分为输入流和输出流，根据传输方式分为字节流和字符流。

字节流(Byte Streams)

字节流是操作二进制数据的输入输出流 ，可以处理任何类型的数据，但它们不能处理 Unicode 字符。它们的类都在 java.io 包中定义。Java 提供了两个基本的抽象类用于定义字节流：

• InputStream：所有字节输入流的父类，用于读取字节。
• OutputStream：所有字节输出流的父类，用于写入字节。

FileInputStream 和 FileOutputStream

FileInputStream 和 FileOutputStream 是用于读写文件的字节流。下面是一个从文件中读取字节的示例：

import java.io.*;

public class ReadFileDemo {
    public static void main(String[] args) {
        try {
            FileInputStream in = new FileInputStream("input.txt");
            int c;
            while ((c = in.read()) != -1) {
                System.out.print((char)c);
            }
            in.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将读取 input.txt 文件中的所有字节并打印到控制台。下面是一个将数据写入文件的示例：

import java.io.*;

public class WriteFileDemo {
    public static void main(String[] args) {
        try {
            String str = "Hello, World!";
            FileOutputStream out = new FileOutputStream("output.txt");
            byte[] bytes = str.getBytes();
            out.write(bytes);
            out.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将字符串 "Hello, World!" 写入 output.txt 文件。

字符流(Character Streams)

字符流是用于读写文本数据的输入输出流，可以处理 Unicode 字符。它们的类都在 java.io 包中定义。Java 提供了两个基本的抽象类用于定义字符流：

• Reader：所有字符输入流的父类，用于读取字符。
• Writer：所有字符输出流的父类，用于写入字符。

FileReader 和 FileWriter

FileReader 和 FileWriter 是用于读写文件的字符流。下面是一个从文件中读取字符的示例：

import java.io.*;

public class ReadFileDemo {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("input.txt");
            int c;
            while ((c = reader.read()) != -1) {
                System.out.print((char)c);
            }
            reader.close();
        }

catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将读取 input.txt 文件中的所有字符并打印到控制台。下面是一个将数据写入文件的示例：

import java.io.*;

public class WriteFileDemo {
    public static void main(String[] args) {
        try {
            String str = "Hello, World!";
            FileWriter writer = new FileWriter("output.txt");
            writer.write(str);
            writer.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将字符串 "Hello, World!" 写入 output.txt 文件。

缓冲流(Buffered Stream)

Java I/O 还提供了缓冲流类来提高 I/O 操作的性能。缓冲流类是在字节流或字符流基础上封装的，它提供了缓冲区的功能，可以减少频繁访问磁盘或网络的次数，从而提高读写数据的效率。

缓冲字节流(Buffered Byte Stream)

Java I/O 提供了 BufferedInputStream 和 BufferedOutputStream 类来实现缓冲字节流。

BufferedInputStream 类

BufferedInputStream 类继承自 FilterInputStream 类，它提供了带有缓冲区的读取方法。下面是一个使用 BufferedInputStream 类读取文件的示例：

import java.io.*;

public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        try {
            FileInputStream inputStream = new FileInputStream("input.txt");
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            int c;
            while ((c = bufferedInputStream.read()) != -1) {
                System.out.print((char) c);
            }
            bufferedInputStream.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将使用 BufferedInputStream 类读取 input.txt 文件中的所有字节并打印到控制台。

BufferedOutputStream 类

BufferedOutputStream 类继承自 FilterOutputStream 类，它提供了带有缓冲区的写入方法。下面是一个将数据写入文件的示例：

import java.io.*;

public class BufferedOutputStreamDemo {
    public static void main(String[] args) {
        try {
            String str = "Hello, World!";
            FileOutputStream outputStream = new FileOutputStream("output.txt");
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
            byte[] bytes = str.getBytes();
            bufferedOutputStream.write(bytes);
            bufferedOutputStream.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将使用 BufferedOutputStream 类将字符串 "Hello, World!" 写入 output.txt 文件。

缓冲字符流(Buffered Character Stream)

Java I/O 提供了 BufferedReader 和 BufferedWriter 类来实现缓冲字符流。

BufferedReader 类

BufferedReader 类继承自 Reader 类，它提供了带有缓冲区的读取方法。下面是一个使用 BufferedReader 类读取文件的示例：

import java.io.*;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("input.txt");
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            bufferedReader.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将使用 BufferedReader 类读取 input.txt 文件中的所有行并打印到控制台。

BufferedWriter 类

BufferedWriter 类继承自 Writer 类，它提供了带有缓冲区的写入方法。下面是一个将数据写入文件的示例：

import java.io.*;

public class BufferedWriterDemo {
    public static void main(String[] args) {
        try {
            String str = "Hello, World!";
            FileWriter fileWriter = new FileWriter("output.txt");
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write(str);
            bufferedWriter.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

上面的代码将使用 BufferedWriter 类将字符串 "Hello, World!" 写入 output.txt 文件。

文件(File)

文件是计算机中存储信息的一种方式，Java I/O 提供了许多类和接口来操作文件系统中的文件。

File 类

File 类代表文件系统中的文件或目录。它提供了许多方法来操作文件系统中的文件或目录，如创建文件或目录、删除文件或目录、获取文件或目录的信息等。下面是一个使用 File 类操作文件系统中的文件的示例：

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        if (file.exists()) {
            System.out.println("文件存在");
            System.out.println("文件名：" + file.getName());
            System.out.println("路径：" + file.getAbsolutePath());
            System.out.println("大小：" + file.length() + " 字节");
        } else {
            System.out.println("文件不存在");
        }
    }
}

上面的代码将检查当前目录下是否存在名为 test.txt 的文件，并打印文件的名称、路径和大小。

目录操作

Java I/O 还提供了一些类和接口来操作目录，如创建目录、删除目录、列出目录中的文件等。

创建目录

使用 File 类的 mkdir() 或 mkdirs() 方法可以创建目录。mkdir() 方法只能创建单级目录，mkdirs() 方法可以创建多级目录。下面是一个使用 mkdirs() 方法创建目录的示例：

import java.io.File;

public class CreateDirDemo {
    public static void main(String[] args) {
        String dirname = "testdir/subdir";
        File dir = new File(dirname);
        if (dir.mkdirs()) {
            System.out.println("目录创建成功");
        } else {
            System.out.println("目录创建失败");
        }
    }
}

上面的代码将在当前目录下创建名为 testdir/subdir 的目录。

删除目录

使用 File 类的 delete() 方法可以删除目录。该方法只能删除空目录。如果要删除非空目录，需要使用递归算法删除目录中的所有文件和子目录。下面是一个使用 delete() 方法删除目录的示例：

import java.io.File;

public class DeleteDirDemo {
    public static void main(String[] args) {
        String dirname = "testdir";
        File dir = new File(dirname);
        if (dir.delete()) {
            System.out.println("目录删除成功");
        } else {
            System.out.println("目录删除失败");
        }
    }
}

列出目录中的文件

使用 File 类的 list() 或 listFiles() 方法可以列出目录中的文件或子目录。list() 方法返回一个字符串数组，包含目录中的所有文件和子目录的名称。listFiles() 方法返回一个 File 对象数组，包含目录中的所有文件和子目录的 File 对象。下面是一个使用 listFiles() 方法列出目录中的所有文件和子目录的示例：

import java.io.File;

public class ListDirDemo {
    public static void main(String[] args) {
        String dirname = ".";
        File dir = new File(dirname);
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                System.out.println("目录：" + file.getName());
            } else {
                System.out.println("文件：" + file.getName());
            }
        }
    }
}

上面的代码将列出当前目录中的所有文件和子目录的名称。

总结

Java I/O 提供了丰富的类来处理文件和网络数据的输入输出操作。开发者可以根据自己的需求选择不同的流类来实现不同类型的 I/O 操作。缓冲流类可以提高 I/O 操作的性能，特别是对于频繁访问磁盘或网络的操作。在使用 Java I/O 时，需要注意异常处理，确保程序在出现异常时能够正确地处理异常情况。

课后总结(新学到的)

1.全限定名就是类名全称，带包路径的用点隔开，即全限定名=包名+类名

2.转换流是字符流与字节流之间的桥梁

3.缓冲流会使程序运行速度加快（可以使用n记录一下读入的字符数）