java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java常用流类示例

java各种流的常见使用方法及示例

作者：tjh510623!

在java中所有数据都是使用流读写的,流是一组有序的数据序列,将数据从一个地方带到另一个地方,这篇文章主要介绍了java各种流的常见使用方法及示例的相关资料,需要的朋友可以参考下

流在 Java I/O 操作中扮演着核心角色，主要用于处理数据序列（如文件、网络连接、内存缓冲区等）。它们主要分为两大类：字节流和字符流。

核心概念

常用流类及示例

1. 文件字节流 (FileInputStream / FileOutputStream)

import java.io.*;

public class FileCopy {
    public static void main(String[] args) {
        try (InputStream in = new FileInputStream("source.jpg");
             OutputStream out = new FileOutputStream("copy.jpg")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 缓冲字节流 (BufferedInputStream / BufferedOutputStream)

import java.io.*;

public class BufferedRead {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("data.bin");
             BufferedInputStream in = new BufferedInputStream(fis)) {
            int data;
            while ((data = in.read()) != -1) {
                // 处理每个字节 data
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 数据流 (DataInputStream / DataOutputStream)

import java.io.*;

public class DataStreamDemo {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.dat"))) {
            dos.writeInt(100);
            dos.writeDouble(3.14);
            dos.writeBoolean(true);
            dos.writeUTF("你好");
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.dat"))) {
            int i = dis.readInt();
            double d = dis.readDouble();
            boolean b = dis.readBoolean();
            String s = dis.readUTF();
            System.out.println(i + ", " + d + ", " + b + ", " + s);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 对象流 (ObjectInputStream / ObjectOutputStream)

import java.io.*;

class Person implements Serializable {
    private String name;
    private transient int age; // transient 修饰的字段不会被序列化

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // ... Getters, Setters, toString ...
}

public class ObjectStreamDemo {
    public static void main(String[] args) {
        Person person = new Person("张三", 30);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.dat"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.dat"))) {
            Person readPerson = (Person) ois.readObject();
            System.out.println(readPerson); // 注意 age 字段为默认值 0 (未序列化)
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

5. 文件字符流 (FileReader / FileWriter)

import java.io.*;

public class FileReadWrite {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("input.txt");
             Writer writer = new FileWriter("output.txt")) {
            char[] buffer = new char[1024];
            int charsRead;
            while ((charsRead = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, charsRead);
            }
            System.out.println("文本文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. 缓冲字符流 (BufferedReader / BufferedWriter)

import java.io.*;

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

7. 转换流 (InputStreamReader / OutputStreamWriter)

import java.io.*;

public class EncodingDemo {
    public static void main(String[] args) {
        try (InputStream fis = new FileInputStream("input_gbk.txt");
             // 将字节流 fis 转换为字符流，并指定编码为 GBK
             Reader isr = new InputStreamReader(fis, "GBK");
             BufferedReader br = new BufferedReader(isr)) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line); // 正确显示 GBK 编码的中文
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8. 打印流 (PrintStream / PrintWriter)

import java.io.*;

public class PrintWriterDemo {
    public static void main(String[] args) {
        try (PrintWriter pw = new PrintWriter(new FileWriter("log.txt"))) {
            pw.println("日志开始:");
            pw.printf("时间: %tT%n", System.currentTimeMillis());
            pw.println("操作: 用户登录");
            pw.println("日志结束.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

9. 管道流 (PipedInputStream / PipedOutputStream / PipedReader / PipedWriter)

import java.io.*;

public class PipedStreamDemo {
    public static void main(String[] args) throws IOException {
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos); // 连接管道

        Thread writerThread = new Thread(() -> {
            try (DataOutputStream dos = new DataOutputStream(pos)) {
                dos.writeUTF("Hello from writer thread!");
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        Thread readerThread = new Thread(() -> {
            try (DataInputStream dis = new DataInputStream(pis)) {
                String message = dis.readUTF();
                System.out.println("Reader thread received: " + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

总结与选择建议

流类型典型类主要用途特点/注意点
字节流FileInputStream, FileOutputStream原始字节数据读写基础文件操作
BufferedInputStream, BufferedOutputStream提高字节流效率强烈推荐包装使用
DataInputStream, DataOutputStream读写基本数据类型二进制格式
ObjectInputStream, ObjectOutputStream对象序列化/反序列化对象需实现 Serializable
PipedInputStream, PipedOutputStream线程间字节通信必须成对连接
字符流FileReader, FileWriter文本文件读写注意编码(默认平台编码)
BufferedReader, BufferedWriter提高字符流效率，支持readLine()推荐用于文本处理
InputStreamReader, OutputStreamWriter字节流->字符流转换，指定编码解决乱码的关键
PrintStream, PrintWriter格式化打印输出System.out 是 PrintStream
PipedReader, PipedWriter线程间字符通信必须成对连接

选择原则：

  1. 数据类型： 处理二进制数据（图片、音频等）用字节流；处理文本数据优先考虑字符流。
  2. 性能： 使用 BufferedXxx 包装流提高效率。
  3. 功能： 根据需求选择特定功能的流（如读写基本类型用 DataXxx，序列化用 ObjectXxx）。
  4. 编码： 处理文本时，务必关注编码。使用 InputStreamReader/OutputStreamWriter 明确指定编码。
  5. 资源管理： 使用 try-with-resources 语句确保流正确关闭，避免资源泄漏。

总结

到此这篇关于java各种流的常见使用方法及示例的文章就介绍到这了,更多相关java常用流类示例内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文