阅读 800

java I/O流详解

为什么需要I/0流

  1. 当我们的程序需要从硬盘,网络,或其他应用程序中读取或写入数据时候,数据传输量可能很大,而我们的内存或带宽有限,无法一次性读取获取写入大量数据。
  2. 而流(Stream)可以实现一点一点的逐步传输数据。
  3. 想想我们是怎样下载一个大文件的, 下载软件(例如x雷)并不会占用你内存很大的空间, 而只是在内存划分一个缓冲区, 一点一点地下载到自己的内存(缓冲区满了再写到硬盘),。

Stream

  1. Stream是一个java类,这个类用于java程序和外部设备之前的输入输出操作。
  2. 所谓外部设备可以是硬盘上的文件,也可以是网络设备,或其他java程序。
  3. 在java中把不同的输入/输出源(键盘,文件,网络连接等)抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stream是从起源(source)到接收的(sink)的有序数据。
  4. 如下图,输入输出流就像连接程序和水缸的管道,让水流一点点通行。

I/O流的分类

  1. I/O流具体的分类
    • 从流的方向划分:分为 输入流输出流
    • 从流的传输单位划分: 分为 字节流(8位字节),字符流(16位的字符)
    • 从流的角色划分: 分为 节点流处理流
      • 节点流是直接连接数据源的流,可以直接向数据源(特定的IO设备,如硬盘,网络,其他程序)读写数据
      • 处理流通过构造方法接收一个节点流,对节点流使用装饰者模式增加更多的功能,处理流必须依赖于一个节点流,因为只有节点流最终可以将数据流输入输出到IO设备中。
  2. Java将所有传统的流类型都放在Java.io包下,用于实现输入和输出功能。
  3. 该包下的流的类非常多,初学者非常容易混淆,但我们始终记住,java的I/0存在4大基类,而所有的IO流实现类,都是其子类。

I/O流架构体系

这个缺少一个继承自Writer基类的PrinterWriter

节点流--直接连接数据源的流

常见的节点流

  1. File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream。
  2. 从/向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
  3. 从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream。
  4. Pipe管道流。 实现管道的输入和输出(进程间通信): PipedReader与PipedWriter、PipedInputStream与PipedOutputStream。

处理流--连接已存在的流

常见的处理流

  1. Buffering缓冲流:在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
  2. Filtering 滤流:在数据进行读或写时进行过滤:FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
  3. Converting between Bytes and Characters 转换流:按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader):InputStreamReader、OutputStreamWriter。
  4. Object Serialization 对象流 :ObjectInputStream、ObjectOutputStream。
  5. DataConversion数据流: 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream 。
  6. Counting计数流: 在读入数据时对行记数 :LineNumberReader、LineNumberInputStream。
  7. Peeking Ahead预读流: 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream。  8 .Printing打印流: 包含方便的打印方法 :PrintWriter、PrintStream。

FileInputStream & FileOutputStream

  1. FileInputStream & FileOutputStream 可以从文件系统中 读取/写入 诸如图像数据之类的原始字节流。
  2. 以下是 使用 FileInputStream & FileOutputStream 实现文件拷贝的案例
// 使用文件字节流 一次拷贝一个字节
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 使用文件字节流 一次拷贝一个字节数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
   }
复制代码

DataInputStream & DataOutputStream

  1. DataInputStream & DataOutputStream,是处理流,改构造方法接收一个已存在的输入输出流, 允许程序从读取方便快捷 操作java的基本数据类型。
// 向文件中写入 java基本数据类型
    private static void write(String dest) throws IOException {
        //1. 创建流对象
        DataOutputStream os = new DataOutputStream(new FileOutputStream(dest));
        //2. 写入数据
        os.writeInt(10);
        os.writeChar('a');
        os.writeChar('b');
        os.writeDouble(12.83);
        //3. 关闭流
        os.close();
}

    // 从文件中读取 java基本数据类型,要和写入的顺序保持一致
    private static void read(String src) throws IOException {
        //1. 创建数据流对象
        DataInputStream in = new DataInputStream(new FileInputStream(src));
        //2. 读取数据
        int a = in.readInt();
        char b = in.readChar();
        char c = in.readChar();
        double d = in.readDouble();
        //3. 关闭流
        in.close();
    }
复制代码

BufferedInputStream & BufferedOutputStream

  1. BufferedInputStream & BufferedOutputStream 为另一个输入输出流流添加一些功能,即缓冲区的作用。在创建 BufferedInputStream & BufferedOutputStream 时,会创建一个内部缓冲区数组。
// 为文件字节流 添加缓冲区功能, 一次读写一个字节数据,但内部缓冲区数组已经填满
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 为文件字节流 添加缓冲区功能, 一次读写一个字节数组数据,但内部缓冲区数组已经填满
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
    }
复制代码

PrintStream

  1. PrintStream 为其他输出流添加了功能,使它们能够方便地打印各种数据值表示形式。
public static void main(String[] args) throws FileNotFoundException {

        PrintStream ps = new PrintStream("test.txt");
        ps.println(5);
        ps.print("Aaaa");
        ps.print(false);
        ps.println("hahah");

        ps.flush();
        ps.close();
    }
复制代码

ByteArrayInputStream & ByteArrayInputStream

  1. ByteArrayInputStream & ByteArrayInputStream 包含一个内部缓冲区(实际上就是把数据写入内存,然后再读取),该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节,.
public static void main(String[] args) throws IOException {

        //1. 写入数据
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        os.write("hello".getBytes());
        os.close(); // 没有写任何实现

        //2. 读取输出
        byte[] bytes = os.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);

        byte[] data = new byte[1014];
        int len = in.read(data);
        System.out.println(new String(data, 0 ,len));

    }
复制代码

InputStreamReader & OutputStreamWriter

  1. java 在jdk1.1种提供了,针对字符处理的 方便类,字符流,将原来的字节流,增加了 字符编码表 编码处理功能
  2. 字节流到字符流的转换流,read()和writer()方法会一次输入输出多个字节,以包装字符转换有效,
  3. 字节流 + 编码表 = InputStreamReader & OutputStreamWriter
// 使用 字符转换流, 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

FileReader & FileWriter

  1. 在只针对将字符写入文件的时候,因为 每次使用 转换流,对字节流进行包装,写法太麻烦,所以jdk 提供了 字节转换流子类FileReader & FileWriter,方便的进行字符文件的IO操作
// 使用 字符转换流, 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

BufferedReader & BufferedWriter

// 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个一整行的 字符串
    private static void copyFile3(String src, String dest) throws IOException {
        //1. 创建转换流
        BufferedReader reader = new BufferedReader(new FileReader(src));
        BufferedWriter writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        String data = reader.readLine();
        while (data != null) {
            writer.write(data);
            writer.newLine();
            data = reader.readLine();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

StringReader & StringWriter

  1. 方便快捷的将字符串写入内存,或从内存读取
public static void main(String[] args) throws IOException, NoSuchFieldException {
        //1. 向内存写入数据,其内部提供了一个缓冲区
        StringWriter writer = new StringWriter();
        writer.write("hello world");

        //2. 读取数据
        StringReader reader = new StringReader(writer.toString());

        char[] data = new char[1024];
        int len =  reader.read(data);

        System.out.println(new String(data,0,len));
    }
复制代码
关注下面的标签,发现更多相似文章
评论