Java IO流的基本概念和使用，包括文件读写、序列化等

发布于：2024-06-05 ⋅ 阅读:(204) ⋅ 点赞:(0)

Java 输入输出（IO）系统提供了一套丰富的类和接口，用于处理文件读写、网络通信、数据序列化等各种数据操作。

IO 操作在任何编程语言中都扮演着重要角色，而 Java 的 IO 系统以其强大的灵活性和扩展性，成为开发者进行数据操作的得力工具。

1. 基本概念
1.1 流（Stream）

流是一个抽象概念，表示数据的有序集合。流分为输入流和输出流：

  • 输入流：从数据源（如文件、网络连接）读取数据。
  • 输出流：向数据目标（如文件、网络连接）写入数据。

Java 中的流大致分为以下几种类型：

  • 字节流（Byte Streams）：用于处理原始的字节数据，常用于二进制文件。
  • 字符流（Character Streams）：用于处理字符数据，适合处理文本文件。
  • 缓冲流（Buffered Streams）：提供缓冲机制，提高 IO 操作效率。
  • 数据流（Data Streams）：用于读写 Java 原始数据类型。
  • 对象流（Object Streams）：用于对象序列化和反序列化。
1.2 字节流

字节流类主要包括 InputStream 和 OutputStream，它们是所有字节流类的基类。

  • InputStream：所有字节输入流的超类，常用的子类有 FileInputStream、BufferedInputStream 等。
  • OutputStream：所有字节输出流的超类，常用的子类有 FileOutputStream、BufferedOutputStream 等。
1.3 字符流

字符流类主要包括 Reader 和 Writer，它们是所有字符流类的基类。

  • Reader：所有字符输入流的超类，常用的子类有 FileReader、BufferedReader 等。
  • Writer：所有字符输出流的超类，常用的子类有 FileWriter、BufferedWriter 等。
2. 文件读写
2.1 字节流文件读写

文件读写是最基本的 IO 操作，下面是使用字节流进行文件读写的示例：

文件读取：

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamReadExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件写入：

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamWriteExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("example.txt")) {
            String content = "Hello, World!";
            fos.write(content.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
2.2 字符流文件读写

字符流处理的是字符数据，更适合用于文本文件的读写。

文件读取：

import java.io.FileReader;
import java.io.IOException;

public class CharStreamReadExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("example.txt")) {
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件写入：

import java.io.FileWriter;
import java.io.IOException;

public class CharStreamWriteExample {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("example.txt")) {
            String content = "Hello, World!";
            fw.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
3. 缓冲流

缓冲流通过增加缓冲区来提高 IO 操作的效率。缓冲区可以减少对底层操作系统的访问频率，从而提升性能。

缓冲字节流：

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedByteStreamReadExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲字符流：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedCharStreamReadExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
4. 数据流

数据流用于读写 Java 的基本数据类型（如 int、double、boolean）和字符串，适合进行数据的存储和传输。

数据输出流：

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamWriteExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.dat"))) {
            dos.writeInt(123);
            dos.writeDouble(45.67);
            dos.writeBoolean(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据输入流：

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataStreamReadExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.dat"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            boolean booleanValue = dis.readBoolean();

            System.out.println("Integer: " + intValue);
            System.out.println("Double: " + doubleValue);
            System.out.println("Boolean: " + booleanValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
5. 对象流

对象流用于对象的序列化和反序列化。序列化是指将对象的状态转换为字节流，以便保存到文件或通过网络传输；反序列化是将字节流恢复为对象。

对象序列化：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectStreamWriteExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.dat"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象反序列化：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectStreamReadExample {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.dat"))) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
6. 其他 IO 操作
6.1 文件复制

文件复制是常见的 IO 操作，使用缓冲流可以提高效率。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("destination.txt"))) {

            byte[] buffer = new byte[1024];
            int length;
            while ((length = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
6.2 读取文件行数

使用 BufferedReader 可以方便地逐行读取文件内容。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LineCountExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            int lineCount = 0;
            while (br.readLine() != null) {
                lineCount++;
            }
            System.out.println("Total lines: " + lineCount);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
6.3 查找文件中的某个单词

可以结合 BufferedReader 和 String 的 contains 方法实现简单的文本搜索。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class WordSearchExample {
    public static void main(String[] args) {
        String searchWord = "Java";
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            int lineNumber = 0;
            while ((line = br.readLine()) != null) {
                lineNumber++;
                if (line.contains(searchWord)) {
                    System.out.println("Found " + searchWord + " at line " + lineNumber);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java 的 IO 系统通过提供丰富的类和接口，使得开发者可以方便地进行各种数据操作。字节流适用于处理二进制数据，字符流适用于处理文本数据，缓冲流提高了 IO 操作的效率，数据流便于处理基本数据类型，对象流支持对象的序列化和反序列化。此外，Java IO 还提供了许多实用的方法和工具类，简化了文件操作、数据传输等任务。

黑马程序员免费预约咨询

微信公众号

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布