JAVA IO 字节流与字符流

Posted 2020-07-02 听云APM

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA IO 字节流与字符流相关的知识，希望对你有一定的参考价值。

文章出自：听云博客

题主将以三个章节的篇幅来讲解JAVA IO的内容。

第一节JAVA IO包的框架体系和源码分析，第二节，序列化反序列化和IO的设计模块，第三节异步IO。

本文是第一节。

IO框架

从上图我们可以看出IO可以分为两大块字节流和字符流

字节流是 InputStream 和 OutputStream 分别对应输入与输出

字符流是Reader和Writer分别对应输入与输出

ByteArrayInputStream

它字节数组输入流。继承于InputStream。它包含一个数组实现的缓冲区ByteArrayInputStream也是数组实现的，提供read()来读取数据，内部有一个计数器用来确定下一个要读取的字节。

分析源码

//pos是下一个会被读取字节的索引

//count字节流的长度

//pos为0就是从0开始读取

//读取下一个字节， &0xff的意思是将高8位全部置0

// 将“字节流的数据写入到字节数组b中”

// off是“字节数组b的偏移地址”，表示从数组b的off开始写入数据

// len是“写入的字节长度”

ByteArrayOutputStream

它是字节数组输出流。继承于OutputStream。ByteArrayOutputStream 实际也是数组实现的，它维护一个字节数组缓冲。缓冲区会自动扩容。

源码分析

//我们看到不带参的构造方法默认值是32 数组大小必须大于0否则会报 Negative initial size错误 ByteArrayOutputStream本质是一个byte数组

//是将字节数组buffer写入到输出流中，offset是从buffer中读取数据的起始下标，len是写入的长度。

//ensureCapacity方法是判断数组是否需要扩容

//System.arraycopy是写入的实现

//数组如果已经写满则grow

//int Capacity=oldCapacity<<1，简单粗暴容量X2

Piped(管道)

多线程可以通过管道实现线程中的通讯，在使用管道时必须PipedInputStream，PipedOutputStream配套缺一不可

PipedInputStream

//初始化管道

//链接管道

//将“管道输入流”和“管道输出流”绑定。

//调用的是PipedOutputStream的connect方法

PipedOutputStream

//指定配对的PedpedInputStream

示例

package ioEx;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;
public class PipedStreamEx {
    public static void main(String[] args) {
        Writer t1 = new Writer();   
        Reader t2 = new Reader();  
        //获取输入输出流
        PipedOutputStream out = t1.getOutputStream();   
        PipedInputStream in = t2.getInputStream();   
        try {   
            //将管道连接 也可以这样写 out.connect(in);   
            in.connect(out);   
            t1.start();
            t2.start();
        } catch (IOException e) {
            e.printStackTrace();
                    }
    }
}
class Reader extends Thread {
    private PipedInputStream in = new PipedInputStream();  
    // 获得“管道输入流”对象
    public PipedInputStream getInputStream(){   
        return in;   
    }   
    @Override
    public void run(){   
        readOne() ;
        //readWhile() ;
    }
    public void readOne(){
        // 虽然buf的大小是2048个字节，但最多只会从输入流中读取1024个字节。
        // 输入流的buffer的默认大小是1024个字节。
        byte[] buf = new byte[2048];
        try {
            System.out.println(new String(buf,0,in.read(buf)));
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 从输入流中读取1024个字节
    public void readWhile() {
        int total=0;
        while(true) {
            byte[] buf = new byte[1024];
            try {
                int len = in.read(buf);
                total += len;
                System.out.println(new String(buf,0,len));
                // 若读取的字节总数>1024，则退出循环。
                if (total > 1024)
                 break;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class Writer extends Thread {    
    private PipedOutputStream out = new PipedOutputStream();
    public PipedOutputStream getOutputStream(){
        return out;
    }   
     @Override
    public void run(){   
        writeSmall1024();
        //writeBigger1024();
    }   
    // 向输出流中写入1024字节以内的数据 
    private void writeSmall1024() {
        String strInfo = "I < 1024" ;
        try {
            out.write(strInfo.getBytes());
            out.close();   
        } catch (IOException e) {   
            e.printStackTrace();   
        }   
    }
    // 向“管道输出流”中写入一则较长的消息
    private void writeBigger1024() {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<103; i++)
            sb.append("0123456789");
        try {
            // sb的长度是1030 将1030个字节写入到输出流中， 测试一次只能读取1024个字节
            out.write( sb.toString().getBytes());
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    }

ObjectInputStream 和 ObjectOutputStream

Object流可以将对象进行序列化操作。ObjectOutputStream可以持久化存储对象, ObjectInputStream，可以读出这些这些对象。

源码很简单直接上例子，关于序列化的内容题主将于下一节叙述

package ioEx;

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
import java.util.Map;
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Iterator;
  
public class ObjectStreamTest { 
    private static final String FILE_NAME= "test.txt";
  
    public static void main(String[] args) {   
        testWrite();
        testRead();
    }
    private static void testWrite() {   
        try {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
             out.writeByte((byte)1);
            out.writeChar(‘a‘);
            out.writeInt(20160329);
            out.writeFloat(3.14F);
            out.writeDouble(Math.PI);
            out.writeBoolean(true);
            // 写入HashMap对象
            Map<String,String> map = new HashMap<String,String>();
            map.put("one", "one");
            map.put("two", "two");
            map.put("three", "three");
            out.writeObject(map);
            // 写入自定义的Box对象，Box实现了Serializable接口
            Test test = new Test("a", 1, "a");
            out.writeObject(test);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    } 
    private static void testRead() {
        try {
                    ObjectInputStream in = new ObjectInputStream(new FileInputStream(FILE_NAME));
            System.out.println(in.readBoolean());
            System.out.println(in.readByte()&0xff);
            System.out.println(in.readChar());
            System.out.println(in.readInt());
            System.out.println(in.readFloat());
            System.out.println(in.readDouble());
            Map<String,String> map = (HashMap) in.readObject();
            Iterator<Entry<String, String>> iter = map.entrySet().iterator();
            while (iter.hasNext()) {
                Map.Entry<String, String> entry = (Map.Entry<String, String>)iter.next();
                System.out.println(entry.getKey()+":"+ entry.getValue());
            }
            Test test = (Test) in.readObject();
            System.out.println("test: " + test);

            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Test implements Serializable {
    private String a;   
    private int b; 
      private String c;   

    public Test(String a, int b, String c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public String toString() {
        return "a, "+b+", c";
    }
}

FileInputStream 和 FileOutputStream

FileInputStream 是文件输入流，它继承于InputStream。我们使用FileInputStream从某个文件中获得输入字节。

FileOutputStream 是文件输出流，它继承于OutputStream。我们使用FileOutputStream 将数据写入 File 或 FileDescriptor 的输出流。

File操作十分简单，这里就不再展示示例了。

FilterInputStream

它的作用是用来封装其它的输入流，并为它们提供额外的功能。它的常用的子类有BufferedInputStream和DataInputStream和PrintStream。。

BufferedInputStream的作用就是为“输入流提供缓冲功能，以及mark()和reset()功能”。

DataInputStream 是用来装饰其它输入流，它允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用 DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据

(01) BufferedOutputStream的作用就是为“输出流提供缓冲功能”。

(02) DataOutputStream 是用来装饰其它输出流，将DataOutputStream和DataInputStream输入流配合使用，“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。

(03) PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

主要了解一下Buffered流

BufferedInputStream

它是缓冲输入流。它继承于FilterInputStream。它的作用是为另一个输入流添加一些功能，例如，提供“缓冲功能”以及支持“mark()标记”和“reset()重置方法”。它本质上是通过一个内部缓冲区数组实现的

源码分析

方法不再一一解读，重点讲两个方法 read1 和 fill

根据fill()中的判断条件可以分为五种情况

情况1：读取完buffer中的数据，并且buffer没有被标记

(01) if (markpos < 0) 它的作用是判断“输入流是否被标记”。若被标记，则markpos大于/等于0；否则markpos等于-1。

(02) 在这种情况下：通过getInIfOpen()获取输入流，然后接着从输入流中读取buffer.length个字节到buffer中。

(03) count = n + pos; 这是根据从输入流中读取的实际数据的多少，来更新buffer中数据的实际大小。

情况2：读取完buffer中的数据，buffer的标记位置>0，并且buffer中没有多余的空间

这种情况发生的情况是 — — 输入流中有很长的数据，我们每次从中读取一部分数据到buffer中进行操作。当我们读取完buffer中的数据之后，并且此时输入流存在标记时；那么，就发生情况2。此时，我们要保留“被标记位置”到“buffer末尾”的数据，然后再从输入流中读取下一部分的数据到buffer中。

其中，判断是否读完buffer中的数据，是通过 if (pos >= count) 来判断的；

判断输入流有没有被标记，是通过 if (markpos < 0) 来判断的。

判断buffer中没有多余的空间，是通过 if (pos >= buffer.length) 来判断的。

理解这个思想之后，我们再对这种情况下的fill()代码进行分析，就特别容易理解了。

(01) int sz = pos - markpos; 作用是“获取‘被标记位置’到‘buffer末尾’”的数据长度。

(02) System.arraycopy(buffer, markpos, buffer, 0, sz); 作用是“将buffer中从markpos开始的数据”拷贝到buffer中(从位置0开始填充，填充长度是sz)。接着，将sz赋值给pos，即pos就是“被标记位置”到“buffer末尾”的数据长度。

(03) int n = getInIfOpen().read(buffer, pos, buffer.length - pos); 从输入流中读取出“buffer.length - pos”的数据，然后填充到buffer中。

(04) 通过第(02)和(03)步组合起来的buffer，就是包含了“原始buffer被标记位置到buffer末尾”的数据，也包含了“从输入流中新读取的数据”。

情况3：读取完buffer中的数据，buffer被标记位置=0，buffer中没有多余的空间，并且buffer.length>=marklimit

执行流程如下，

(01) read() 函数中调用 fill()

(02) fill() 中的 else if (pos >= buffer.length) ...

(03) fill() 中的 else if (buffer.length >= marklimit) ...

说明：这种情况的处理非常简单。首先，就是“取消标记”，即 markpos = -1；然后，设置初始化位置为0，即pos=0；最后，再从输入流中读取下一部分数据到buffer中。

情况4：读取完buffer中的数据，buffer被标记位置=0，buffer中没有多余的空间，并且buffer.length<marklimit

执行流程如下，

(01) read() 函数中调用 fill()

(02) fill() 中的 else if (pos >= buffer.length) ...

(03) fill() 中的 else { int nsz = pos * 2; ... }

这种情况的处理非常简单。

(01) 新建一个字节数组nbuf。nbuf的大小是“pos*2”和“marklimit”中较小的那个数。

(02) 接着，将buffer中的数据拷贝到新数组nbuf中。通过System.arraycopy(buffer, 0, nbuf, 0, pos)

(03) 最后，从输入流读取部分新数据到buffer中。通过getInIfOpen().read(buffer, pos, buffer.length - pos);

注意：在这里，我们思考一个问题，“为什么需要marklimit，它的存在到底有什么意义？”我们结合“情况2”、“情况3”、“情况4”的情况来分析。

假设，marklimit是无限大的，而且我们设置了markpos。当我们从输入流中每读完一部分数据并读取下一部分数据时，都需要保存markpos所标记的数据；这就意味着，我们需要不断执行情况4中的操作，要将buffer的容量扩大……随着读取次数的增多，buffer会越来越大；这会导致我们占据的内存越来越大。所以，我们需要给出一个marklimit；当buffer>=marklimit时，就不再保存markpos的值了。

情况5：除了上面4种情况之外的情况

执行流程如下，

(01) read() 函数中调用 fill()

(02) fill() 中的 count = pos...

这种情况的处理非常简单。直接从输入流读取部分新数据到buffer中。

BufferedOutputStream

BufferedOutputStream 是缓冲输出流。它继承于FilterOutputStream。

BufferedOutputStream 的作用是为另一个输出流提供“缓冲功能”。

代码很简单，就不一一分析了这里只分析一下write方法