21 Java学习之字节流（InputStream和OutPutStream)

 

一.流的分类

 

1、从功能上：输入流、输出流

2、从结构上：字节流、字符流

3、从来源上：节点流、过滤流

　　其中InputStream/OutputStream是为字节流而设计的，Reader/Writer是为字符流而设计的。处理字节或者二进制对象使用字节流，处理字符或者字符串使用字符流。

        在最底层，所有的输入/输出都是字节形式的，基于字符的流只在处理字符的时候提供方便有效的方法。

　　节点流是从特定的地方读写的流，例如磁盘或者内存空间，也就是这种流是直接对接目标的。

　　过滤流是使用节点流作为输入输出的，就是在节点流的基础上进行包装，新增一些特定的功能。

二. 什么是输入流和输出流？

        输入和输出流的概念其实都是针对内存（note:或者直接理解为我们的程序）说的。比如：我们常用来打印到控制台的命令System.out.println()它就是out，对于内存来说，把字符串打印到屏幕上就是从内存流向了屏幕的控制台；而等待用户输入命令确实System.in就是从键盘将字符输入到内存中。

因此：  从内存出：out (输出流）             进入到内存：in（输入流）

note：因为从内存到屏幕，就是写文件的流向；从硬盘到内存就是读文件的流向。

       如果时网络访问中，我们请求访问网页就是in，因为我们访问页面的时候时需要抓取该页面的一个html文件，因此是从网络到内存的流向；倘若有一个登陆页面，那么就是从内存到服务器了，因为需要从内存写数据到登陆界面，即out.

 三. InputStream

       其中有底色标注的为节点流，无底色标注的为过滤流，其中FilterInputStream在JDK中的定义为：包含其他一些输入流，它将这些流用作其基本数据源，可以直接传输数据或提供一些额外的功能，这个类本身并不经常被我们使用，常用的是它的子类。(note:上面InputStream的实现类没有例完，只是常用的）

定义了字节输入模式的抽象类，该类提供了三个重载的read方法：

我们可以看到，三个read方法中，其中有一个是抽象的。那在这里思考这样一个问题：为什么只有第一个是抽象的， 其他两个是具体的？

因为后面两个方法内部最终会去调用第一个方法，所以在InputStream派生类中只需要重写第一个方法就可以了。在这里可以看到第一个read方法是与具体的I/O设备相关的，需要子类去实现。

 1. 常用的字节输入流

• InputStream  
• FileInputStream
• BufferedInputStream (BufferedInputStream不是InputStream的直接实现子类，是FilterInputStream的子类)

它们的区别与用途：

（1）InputStream:是抽象基类。其中定义了几个特别常用的方法，比如read和close方法。

（2）FileInputStream:主要用来操作文件的输入流。

（3）BufferedInputStream:一般读取是从硬盘里面读取数据；而带有缓冲区之后，BufferedInputStream是提前将数据封装到了内存中，因此内存中操作数据会更快，从而拥有比非缓冲区更高的效率。

2. 读写数据的逻辑顺序

（1）open a stream

（2）while more information

（3）read/wirte information

（4）close the stream

3. FileInputStream用法

例1：

package com.test.a;

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

public class Test {
    public static void main(String args[]) throws IOException {
        InputStream is = new FileInputStream("C:\\Users\\hermioner\\Desktop\\test.txt");
        int length = 0;
        byte[] buffer = new byte[20];
        StringBuffer stringBuffer = new StringBuffer();
        while (-1 != (length = is.read(buffer, 0, 20))) {//一个中文字符占两个字节
            stringBuffer.append(new String(buffer, 0, length, "GBK"));// WINDOWS中用ANSI代表,
            System.out.println(stringBuffer);
        }
        System.out.println(stringBuffer);
        is.close();

    }
}


/**
 * 1.创建一个文件输入流 is
 * 2.创建一个字节数组，用它来存放每次读取到内存中的内容，最多读取20个字节
 * 3.必须要加入GBK，否则会乱码。
 * 4.读完以后就关闭流is
 * 
 * */

输出：


少年强则国强，国强少
少年强则国强，国强少年则更强
少年强则国强，国强少年则更强

test.txt文件中的内容是：

少年强则国强，国强少年则更强     （note:以ANSI格式保存的）

例2：

package com.test.a;

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

public class TestSerialversionUID {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("C:\\Users\\hermioner\\Desktop\\test.txt");
        byte[] buffer = new byte[2];
        int readNums = fileInputStream.read(buffer);//代表一次最多读取多少个字节
        System.out.println(readNums);
        System.out.println(String.valueOf(buffer[1]));// 将buffer数组中的元素转换成字符串输出，字符串输出的值实际上是对应元素的assic码，比如buffer[1]=b，就输出98
        String string = new String(buffer, 0, buffer.length, "GBK");// 如果是中文，只能打印出一个中文，英文的话可以打印两个出来
        System.out.println(string);
        fileInputStream.close();

    }
}


2
98
ab

4.BufferedInputStream用法

BufferedOutputStream(OutputStream out); //使用默认大小、底层字节输出流构造bos。默认缓冲大小是 8192 字节( 8KB )

BufferedOutputStream(OutputStream out, int size); //使用指定大小、底层字节输出流构造bos

package com.test.a;

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

public class Test {
    public static void main(String args[]) throws IOException {
        FileInputStream fileInputStream=new FileInputStream("C:\\Users\\hermioner\\Desktop\\test.txt");
        BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
        byte buffer[]=new byte[20];
        int len=0;
        while((len=bufferedInputStream.read(buffer))!=-1) {
            System.out.println(new String(buffer,0,len,"GBK"));
        }
        
        bufferedInputStream.close();
        fileInputStream.close();

    }
}


少年强则国强，国强少
年则更强

5. 为什么需要BufferedInputStream?

BufferedInputStream和BufferedOutputStream这两个类分别是FilterInputStream和FilterOutputStream的子类，作为装饰器子类，使用它们可以防止每次读取/发送数据时进行实际的写操作，代表着使用缓冲区。

BufferedInputStream是一个带有缓冲区的输入流，通常使用它可以提高我们的读取效率，现在我们看下BufferedInputStream的实现原理： 
BufferedInputStream内部有一个缓冲区，默认大小为8*1024B，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快，所以BufferedInputStream的效率很高！ 

 

不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！这就是inputstream与bufferedinputstream的区别

同时正因为它们实现了缓冲功能，所以要注意在使用BufferedOutputStream写完数据后，要调用flush()方法或close()方法，强行将缓冲区中的数据写出。否则可能无法写出数据。与之相似还BufferedReader和BufferedWriter两个类。

BufferedInputStream和BufferedOutputStream类就是实现了缓冲功能的输入流/输出流。使用带缓冲的输入输出流，效率更高，速度更快。

（1）何时用flush

那么什么时候flush()才有效呢？
答案是：当OutputStream是BufferedOutputStream时。

当写文件需要flush()的效果时，需要
FileOutputStream fos = new FileOutputStream(“c:\a.txt”);
BufferedOutputStream bos = new BufferedOutputStream(fos);
也就是说，需要将FileOutputStream作为BufferedOutputStream构造函数的参数传入，然后对BufferedOutputStream进行写入操作，才能利用缓冲及flush()。

查看BufferedOutputStream的源代码，发现所谓的buffer其实就是一个byte[]。
BufferedOutputStream的每一次write其实是将内容写入byte[]，当buffer容量到达上限时，会触发真正的磁盘写入。
而另一种触发磁盘写入的办法就是调用flush()了。

1.BufferedOutputStream在close()时会自动flush
2.BufferedOutputStream在不调用close()的情况下，缓冲区不满，又需要把缓冲区的内容写入到文件或通过网络发送到别的机器时，才需要调用flush.

我的理解：往磁盘写数据有两种情况：一种是从流中而来的数据已经写满了缓存，这个是时候buffer会自动写入磁盘；另外一种是通过调用flush强行把缓存中的数据写入到磁盘。   并且我们在程序中定义了一个一定容量的byte数组，用它来装载从流而来的数据，这实际上表示每次向stream表示的缓存中放入了多少数据，多次的累加来达到缓存的最大值以后，缓存就会自动像磁盘写入了。我们实际上可以使用默认缓存或者自定义缓存容量大小的。可以用我们自定义的byte数组来记录读取了多少数据，看看缓存是否快要达到了等操作，它相当于是一个像缓存中一次次送数据的。（实际上送数据的是流）

6. 节点流和处理流的关闭顺序

问题：

（1）JAVA的IO流使用了装饰模式,关闭最外面的流的时候会自动调用被包装的流的close()方吗？  是

（2）如果按顺序关闭流，是从内层流到外层流关闭还是从外层到内层关闭？  （从外层到内层：即buffered--->非buffered)

问题一解释：

如下例子代码：
  FileInputStream is = new FileInputStream(".");   
  BufferedInputStream bis = new BufferedInputStream(is);  
  bis.close();

 
从设计模式上看：
java.io.BufferedInputStream是java.io.InputStream的装饰类。
BufferedInputStream装饰一个 InputStream 使之具有缓冲功能，is要关闭只需要调用最终被装饰出的对象的 close()方法即可，因为它最终会调用真正数据源对象的 close()方法。
 
BufferedInputStream的close方法中对InputStream进行了关闭，下面是jdk中附带的源代码：
 java.io.BufferedInputStream的api:
close
public void close()throws IOException 关闭此输入流并释放与该流关联的所有系统资源。

 public void close() throws IOException {
        byte[] buffer;
        while ( (buffer = buf) != null) {
            if (bufUpdater.compareAndSet(this, buffer, null)) {
                InputStream input = in;
                in = null;
                if (input != null)
                    input.close();
                return;
            }
            // Else retry in case a new buf was CASed in fill()
        }
    }

因此，可以只调用外层流的close方法关闭其装饰的内层流，验证例子：

public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("java IO close test");
         
        bw.close();
      
     }

验证ok

问题二解释：

如下例子： 
public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("java IO close test");
       
        //从内带外顺序顺序会报异常
        fos.close();
        osw.close();
        bw.close();

     }
报出异常：

Exception in thread "main" java.io.IOException: Stream closed
    at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:26)
    at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:99)
    at java.io.OutputStreamWriter.write(OutputStreamWriter.java:190)
    at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:111)
    at java.io.BufferedWriter.close(BufferedWriter.java:246)
    at com.my.test.QQ.main(QQ.java:22)

如下例子：

 public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("java IO close test");

        // 从外到内顺序关闭ok
        bw.close();
        osw.close();
        fos.close();
    }

验证ok

一般情况下是：先打开的后关闭，后打开的先关闭

另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b

例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b

当然完全可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法

如果将节点流关闭以后再关闭处理流，会抛出IO异常；

 

 四. OutPutStream

1. 常用的字节输出流

• OutputStream
• FileoutputStream
• BufferedOutputStream (BufferedOutputStream 不是OutputStream的直接实现子类，是FilterOutputStream的子类)

它们的区别与用途：

（1）OutputStream: 字节输出流的基类。在这个类中常用的方法有wirte、close和flush(即刷新输出流，把数据马上写到输出流中）

（2）FileOutputStream:用于写文件的输出流

（3）BufferedOutputStream:同BufferedInputStream，可以提高效率。

2. FileOutputStream的用法

package com.test.a;

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

public class Test {
    public static void main(String args[]) throws IOException {
        FileOutputStream fileOutputStream=new FileOutputStream("C:\\Users\\hermioner\\Desktop\\test.txt",true);
        String string="为了中国梦，为了民族的伟大复兴，为了老百姓的幸福";
        byte b[]=string.getBytes();
        fileOutputStream.write(b);
        fileOutputStream.close();
    }
}



//note:上面的true代表在原来路径下文本末尾追加字段，如果不写或者false则表示在文件的开头写，即完成了覆盖。如果上面给定的路径不存在，则会新创建。

3.BufferedOutputStream的用法

public class Test {
    public static void main(String args[]) throws IOException {
        FileOutputStream fileOutputStream=new FileOutputStream("C:\\Users\\hermioer\\Desktop\\test.txt");
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(fileOutputStream);
        String string="为了中国梦，为了民族的伟大复兴，为了老百姓的幸福";
        byte b[]=string.getBytes();
        bufferedOutputStream.write(b);
        bufferedOutputStream.close();//BufferedOoutputStream中实际上没有close，调用的是父类的close。并且close方法中还调用了flush方法
    }
}

4. 补充DataInputStream和DataOutputStream

package com.test.a;

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

public class TestSerialversionUID {
    public static void main(String[] args) throws IOException {
        FileOutputStream out = new FileOutputStream("C:\\Users\\hermioner\\Desktop\\test.txt");
           //DataOutputStream可以将各种各样的数据转换为二进制
           DataOutputStream dout = new DataOutputStream(out);
           String name = "Tom";
           int num = 100;
           float f = 100.8f;
           double d = 10088.00d;
           char c='a';
           //为了让解析工具知道这个字符串有多长，还会在字符串前面加前缀。
           //表示这个字符串有多长，8个字节的字符串，还有两个字节的前缀，会写入10个字节
           dout.writeUTF(name);
           //4个字节
           dout.writeInt(num);
           //4个字节
           dout.writeFloat(f);
           //8个字节
           dout.writeDouble(d);
           dout.writeChar(c);
           FileInputStream in = new FileInputStream("C:\\Users\\hermioner\\Desktop\\test.txt");
           DataInputStream din = new DataInputStream(in);
           String readUTF = din.readUTF();
           System.out.println(readUTF);
           int readInt = din.readInt();
           System.out.println(readInt);
           float readFloat = din.readFloat();
           System.out.println(readFloat);
           double readDouble = din.readDouble();
           System.out.println(readDouble);
           char readChar=din.readChar();
           System.out.println(readChar);

    }
}


Tom
100
100.8
10088.0
a

• DataInputStream是数据输入流，读取的是java的基本数据类型。

• FileInputStream是从文件系统中，读取的单位是字节。

 

参考文献：

https://www.cnblogs.com/dongguacai/p/5658388.html

https://www.cnblogs.com/progor/p/9357676.html

https://blog.csdn.net/zhaoyanjun6/article/details/54894451

https://www.cnblogs.com/qqzy168/p/3670915.html

https://blog.csdn.net/android_zyf/article/details/68343953