神刀安全网

JAVA IO 字节流与字符流

版权声明:此文章如需转载请联系听云College团队成员阮小乙,邮箱:ruanqy#tingyun.com

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

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

本文是第一节。

IO框架

JAVA IO 字节流与字符流

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

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

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

ByteArrayInputStream

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

分析源码

JAVA IO 字节流与字符流

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

//count字节流的长度

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

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

JAVA IO 字节流与字符流

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

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

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

JAVA IO 字节流与字符流

ByteArrayOutputStream

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

源码分析

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

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

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

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

//System.arraycopy是写入的实现

JAVA IO 字节流与字符流

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

JAVA IO 字节流与字符流

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

JAVA IO 字节流与字符流

Piped(管道) 

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

PipedInputStream 

JAVA IO 字节流与字符流

//初始化管道

JAVA IO 字节流与字符流

//链接管道

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

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

//调用的是PipedOutputStream的connect方法

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

PipedOutputStream 

//指定配对的PedpedInputStream

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

示例

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()重置方法”。它本质上是通过一个内部缓冲区数组实现的

源码分析

JAVA IO 字节流与字符流

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

JAVA IO 字节流与字符流

JAVA IO 字节流与字符流

根据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方法

JAVA IO 字节流与字符流

字符流和字符流的区别和使用

字符流的实现与字节流基本相同,最大的区别是字节流是通过byte[]实现的,字符流是通过char[]实现的,这里就不在一一介绍了

按照以下分类我们就可以很清楚的了解在何时使用字节流或字符流

一、按数据源分类:

1 、是文件: FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )

2 、是 byte[] : ByteArrayInputStream, ByteArrayOutputStream( 字节流 )

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )

5 、网络数据流: InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )

二、按是否格式化输出分:要格式化输出: PrintStream, PrintWriter

三、按是否要缓冲分:要缓冲: BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )

四、按数据格式分:

1 、二进制格式(只要不能确定是纯文本的) : InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式(含纯英文与汉字或其他编码方式); Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分:

1 、输入: Reader, InputStream 类型的子类

2 、输出: Writer, OutputStream 类型的子类

六、特殊需要:

1 、从 Stream 到 Reader,Writer 的转换类: InputStreamReader, OutputStreamWriter

2 、对象输入输出: ObjectInputStream, ObjectOutputStream

3 、进程间通信: PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入: SequenceInputStream

5 、更特殊的需要: PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

想阅读更多技术文章,请访问听云技术博客,访问听云官方网站感受更多应用性能优化魔力。

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » JAVA IO 字节流与字符流

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮