Java IO 基础知识总结

IO流是什么

IO流（Input/Output Stream）是用于输入和输出数据的抽象概念。在Java中，IO流用于在程序和外部设备（如文件、网络等）之间进行数据的读写操作。根据数据的流向，IO流可以分为输入流和输出流。

中的IO流分为字节流和字符流，字节流以字节为单位进行读写操作，而字符流以字符为单位进行读写操作。

在字节流中，常用的类有InputStream、OutputStream、FileInputStream、FileOutputStream等。在字符流中，常用的类有Reader、Writer、FileReader、FileWriter等。

此外，还提供了一些高级的IO流，如缓冲流（BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter），用于提高读写操作的效率；对象流（ObjectInputStream、ObjectOutputStream），用于序列化和反序列化对象；打印流（PrintStream、PrintWriter），用于方便地打印数据。

字节流

字节流主要用于处理二进制数据，比如读取和写入文件或网络传输的字节数据。常用的字节流类有InputStream和OutputStream。

以下是常用的字节流方法及示例：

1. read(): 用于从输入流中读取一个字节，并返回读取的字节值。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   int data = inputStream.read();
   System.out.println(data);
   

   输出结果：读取的字节值（0-255之间）

2. write(int b): 用于将一个字节写入输出流。 示例：

   OutputStream outputStream = new FileOutputStream("file.txt");
   outputStream.write(65);
   outputStream.close();
   

   输出结果：将ASCII码为65的字节写入文件中，即写入字母"A"。

3. read(byte[] b): 用于从输入流中将指定长度的字节读入到字节数组b中，并返回实际读取的字节数。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   byte[] buffer = new byte[5];
   int bytesRead = inputStream.read(buffer);
   System.out.println(new String(buffer));
   

   输出结果：读取文件中前5个字节并以String形式输出。

4. write(byte[] b): 用于将字节数组中的字节写入输出流。 示例：

   OutputStream outputStream = new FileOutputStream("file.txt");
   byte[] data = {65, 66, 67};
   outputStream.write(data);
   outputStream.close();
   

   输出结果：将字节数组中的字节写入文件中，即写入字母"ABC"。

5. available(): 用于获取当前可从输入流中获取的字节数。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   int availableBytes = inputStream.available();
   System.out.println(availableBytes);
   

   输出结果：当前可读取的字节数。

6. skip(long n): 用于忽略从输入流中的前n个字节。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   inputStream.skip(3);
   int data = inputStream.read();
   System.out.println(data);
   

   输出结果：跳过前3个字节，输出第4个字节。

7. close(): 用于关闭输入流或输出流。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   inputStream.close();
   

   输出结果：无

8. flush(): 用于刷新输出流，将缓冲区中的数据强制写入目标设备。 示例：

   OutputStream outputStream = new FileOutputStream("file.txt");
   outputStream.write(65);
   outputStream.flush();
   outputStream.close();
   

   输出结果：将数据写入文件并刷新缓冲区。

9. mark(int readLimit) 和 reset(): 用于在输入流中做标记和返回到该标记位置，以便后续读取操作。 示例：

   InputStream inputStream = new FileInputStream("file.txt");
   inputStream.mark(5);
   int data1 = inputStream.read();
   inputStream.reset();
   int data2 = inputStream.read();
   System.out.println(data1);
   System.out.println(data2);
   

   输出结果：先读取一个字节后又返回到标记位置再次读取。

10. FileInputStream(String name) 和 FileOutputStream(String name): 分别用于创建文件输入流和文件输出流，以便读取和写入文件。 示例：

    InputStream inputStream = new FileInputStream("file.txt");
    OutputStream outputStream = new FileOutputStream("file.txt");
    

字符流

1. read()：从字符流中读取下一个字符，并返回它的ASCII值。示例：

2. try {
       FileReader reader = new FileReader("file.txt");
       int asciiCode = reader.read();
       System.out.println(asciiCode);
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：98（ASCII码中字母'b'的值为98）

3. read(char[] cbuf)：从字符流中读取字符到字符数组中，并返回读取的字符数。示例：

4. try {
       FileReader reader = new FileReader("file.txt");
       char[] buffer = new char[5];
       int numChars = reader.read(buffer);
       System.out.println(numChars);
       System.out.println(Arrays.toString(buffer));
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：

   5
   [h, e, l, l, o]
   
   3. `read(char[] cbuf, int offset, int length)`：从字符流中读取字符到字符数组的指定位置，并返回读取的字符数。示例：
   ```java
   try {
       FileReader reader = new FileReader("file.txt");
       char[] buffer = new char[5];
       int numChars = reader.read(buffer, 1, 3);
       System.out.println(numChars);
       System.out.println(Arrays.toString(buffer));
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：

   3
   [ , h, e, , o]
   
   4. `readLine()`：从字符流中读取一行字符，并返回该行，如果到达文件末尾则返回null。示例：
   ```java
   try {
       BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
       String line;
       while ((line = reader.readLine()) != null) {
           System.out.println(line);
       }
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：

   Hello
   World
   
   5. `skip(long n)`：跳过指定数量的字符。示例：
   ```java
   try {
       FileReader reader = new FileReader("file.txt");
       reader.skip(3);
       int asciiCode = reader.read();
       System.out.println((char)asciiCode);
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：l

5. mark(int readAheadLimit)：在当前位置设置标记，以便后续调用reset()方法可以返回到该位置。示例：

6. try {
       BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
       reader.mark(10);
       System.out.println(reader.readLine());
       reader.reset();
       System.out.println(reader.readLine());
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：

   Hello
   Hello
   
   7. `ready()`：检查字符流是否准备好进行读取。示例：
   ```java
   try {
       BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
       System.out.println(reader.ready());
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：true

7. close()：关闭字符流。示例：

8. try {
       FileReader reader = new FileReader("file.txt");
       int asciiCode = reader.read();
       System.out.println(asciiCode);
       reader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

   输出结果：98

9. write(char[] cbuf)：将字符数组的内容写入字符流。示例：

   try {
       FileWriter writer = new FileWriter("file.txt");
       char[] chars = {'H', 'e', 'l', 'l', 'o'};
       writer.write(chars);
       writer.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
   

字节缓冲流

1. 字节缓冲流（BufferedInputStream和BufferedOutputStream）是用于提高字节流读写效率的一种流。它们通过在内存中创建一个缓冲区来减少对磁盘的访问次数，从而提高读写的速度。

以下是10个常用的方法以及对应的功能、示例和输出结果：

1. public BufferedInputStream(InputStream in)：创建一个新的缓冲输入流对象。 示例：

2. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"));
   

3. public BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流对象。 示例：

4. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("file.txt"));
   

5. public int read() throws IOException：从输入流中读取下一个字节的数据。 示例：

6. int data = bis.read();
   System.out.println(data);
   

   输出结果：读取的下一个字节的数据。

7. public int read(byte[] b) throws IOException：从输入流中读取一定数量的字节数据到数组中。 示例：

8. byte[] buffer = new byte[1024];
   int bytesRead = bis.read(buffer);
   System.out.println(new String(buffer, 0, bytesRead));
   

   输出结果：读取的一定数量的字节数据。

9. public void write(int b) throws IOException：将指定的字节写入输出流。 示例：

10. bos.write(65);
    bos.flush();
    

    输出结果：将字节'A'写入输出流。

11. public void write(byte[] b) throws IOException：将字节数组中的数据写入输出流。 示例：

12. byte[] buffer = "Hello".getBytes();
    bos.write(buffer);
    bos.flush();
    

    输出结果：将字节数组中的数据写入输出流。

13. public void flush() throws IOException：刷新输出流，将缓冲区中的数据写入磁盘。 示例：

14. bos.write("Hello".getBytes());
    bos.flush();
    

    输出结果：将缓冲区中的数据写入磁盘。

15. public void close() throws IOException：关闭输入流。 示例：

16. bis.close();
    

    输出结果：关闭输入流。

17. public void reset()：重置流的标记位置。 示例：

18. bis.reset();
    

19. public long skip(long n) throws IOException：跳过输入流中的n个字节。 示例：

20. long bytesSkipped = bis.skip(5);
    System.out.println(bytesSkipped);
    

    输出结果：跳过5个字节。

    以上是字节缓冲流的一些常用方法及其功能、示例和输出结果。请注意，实际的输出结果可能因为具体的文件内容和操作而有所不同。

21. write(String str)：将字符串写入字符流。示例：

22. try {
        FileWriter writer = new FileWriter("file.txt");
        String str = "Hello";
        writer.write(str);
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    

?

字符缓冲流

在Java中，字符缓冲流主要用于对字符数据进行高效的读取和写入操作。它是基于字符流的一种高级流，可以提高读取和写入字符数据的效率。

以下是字符缓冲流的常用方法，以及每个方法的作用和输出示例：

1. read() - 从输入流中读取一个字符。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
int c = br.read();
System.out.println((char) c);

输出：第一个字符。

1. read(char[] cbuf) - 将字符读入数组。

char[] cbuf = new char[5];
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
br.read(cbuf);
System.out.println(cbuf);

输出：读取到的字符数组。

1. readLine() - 读取一行字符。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
String line = br.readLine();
System.out.println(line);

输出：读取到的一行字符。

1. skip(long n) - 跳过字符。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
br.skip(5);
int c = br.read();
System.out.println((char) c);

输出：跳过5个字符后的第一个字符。

1. ready() - 判断流是否准备好被读取。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
System.out.println(br.ready());

输出：true 或 false。

1. mark(int readAheadLimit) - 在当前位置做一个标记，以便后续可以回到此处。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
br.mark(5);
int c1 = br.read();
br.reset();
int c2 = br.read();
System.out.println((char) c1 + " " + (char) c2);

输出：第一个字符 第二个字符。

1. reset() - 将流的读取位置重置为最近的标记位置。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
br.mark(5);
br.read();
br.reset();
int c = br.read();
System.out.println((char) c);

输出：第一个字符。

1. close() - 关闭字符缓冲流。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
br.close();

1. lines() - 返回流中的所有行。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
Stream<String> lines = br.lines();
lines.forEach(System.out::println);

1. lines().count() - 返回流中行的数量。

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
long count = br.lines().count();
System.out.println(count);

打印流

在Java中，打印流（PrintStream和PrintWriter）用于将数据输出到控制台或文件。它提供了一系列的打印方法，可以方便地输出不同类型的数据（如字符串、整数等）。

以下是常用的打印流方法及其用途的示例：

1. print(String str): 打印字符串。

PrintStream ps = System.out;
ps.print("Hello World");

输出结果：Hello World

1. println(String str): 打印字符串并换行。

PrintStream ps = System.out;
ps.println("Hello");
ps.println("World");

输出结果： Hello World

1. print(int num): 打印整数。

PrintStream ps = System.out;
int num = 100;
ps.print(num);

输出结果：100

1. println(double num): 打印浮点数并换行。

PrintStream ps = System.out;
double num = 3.14;
ps.println(num);

输出结果：3.14

1. printf(String format, Object... args): 根据指定的格式字符串打印输出。

PrintStream ps = System.out;
String name = "John";
int age = 25;
ps.printf("My name is %s and I am %d years old.", name, age);

输出结果：My name is John and I am 25 years old.

随机访问流

随机访问流（RandomAccessFile）用于以读写方式处理文件。与其他流不同的是，随机访问流可以直接跳转到文件的任意位置读写数据。

以下是常用的方法及其作用，以及相应的示例和输出结果：

1. seek(long pos)：将文件指针定位到指定位置。 示例：

   RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
   file.seek(10);
   System.out.println(file.getFilePointer());
   

   输出结果：10

2. read()：读取一个字节的数据。 示例：

   RandomAccessFile file = new RandomAccessFile("example.txt", "r");
   int data = file.read();
   System.out.println((char)data);
   

   输出结果：读取的单个字符

3. write(byte[] buffer)：将字节数组写入文件。 示例：

   RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
   byte[] data = "Hello".getBytes();
   file.write(data);
   

   输出结果：文件中写入"Hello"

4. length()：返回文件的长度（以字节为单位）。 示例：

   RandomAccessFile file = new RandomAccessFile("example.txt", "r");
   long length = file.length();
   System.out.println(length);
   

   输出结果：文件的字节长度

5. read(byte[] buffer, int offset, int length)：从文件中读取一定数量的字节并存储到字节数组中。 示例：

   RandomAccessFile file = new RandomAccessFile("example.txt", "r");
   byte[] buffer = new byte[5];
   file.read(buffer, 0, 5);
   System.out.println(new String(buffer));
   

   输出结果：读取的前5个字节的内容（如果文件内容不足5个字节，则输出实际读取的内容）

?