主要内容包括OutputStream及其部分子类,以分析源代码的方式学习。关心的问题包括:每个字节输出流的作用,各个流之间的主要区别,何时使用某个流,区分节点流和处理流,流的输出目标等问题。 OutputStream的类树如下所示,其中,ObjectOutputStream和PipedOutputStream本文将不做讨论。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
java.io.OutputStream (implements java.io.Closeable, java.io.Flushable) java.io.ByteArrayOutputStream java.io.FileOutputStream java.io.FilterOutputStream java.io.BufferedOutputStream java.io.DataOutputStream (implements java.io.DataOutput) java.io.PrintStream (implements java.lang.Appendable, java.io.Closeable) java.io.ObjectOutputStream (implements java.io.ObjectOutput, java.io.ObjectStreamConstants) java.io.PipedOutputStream
OutputStream源码分析
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; //它是抽象类,并且实现了两个接口Closeable和Flushable。 public abstract class OutputStream implements Closeable, Flushable { //作为抽象类中唯一的抽象方法,(非抽象)子类必须实现这个方法。 //我们可以看到,这个类还提供了另外两个write方法,但是它们最终都是要调用这个方法来完成具体的实现 //对于一个输出流,我们需要关心输出的内容到哪里去了,从这个write方法中我们根本看不到输出的目的地,所以实现这个方法的子类必须告诉这一点 //而实现这个方法的子类,就是节点流。 //注意:作为字节输出流,为何这里参数传递为int型,而非byte型,这个在后面子类实现中再分析 public abstract void write(int b) throws IOException; //此方法直接输出一个字节数组中的全部内容,调用了下面的write方法 public void write(byte b[]) throws IOException { write(b, 0, b.length); } //功能:要输出的内容已存储在了字节数组b[]中,但并非全部输出,只输出从数组off位置开始的len个字节。因此,需要对传入的三个参数作合理性判断 public void write(byte b[], int off, int len) throws IOException { //数组不能为空,否则抛出NullPointerException if (b == null) { throw new NullPointerException(); } else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) { //此处判断off+len<0是多余的 throw new IndexOutOfBoundsException(); } else if (len == 0) { return; } //最终会调用第一个write方法。注意:1.子类可能会复写当前的write方法;2.在输出的过程中,还是一个一个字节输出的。 for (int i = 0 ; i < len ; i++) { write(b[off + i]); } } //这两个方法就是实现两个接口时分别需要实现的方法,但这里方法中内容是空的,子类可以override这两个方法,如果子类不复写,则此方法为空。 public void flush() throws IOException { } public void close() throws IOException { } }
关于override父类或接口的方法时,原以为要和父类或接口中声明的一样,包括权限,现在看来不然。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; import java.io.IOException; public interface Flushable { //此处的方法权限为包权限,而在OutputStream中则成为了public权限 void flush() throws IOException; } package java.lang; public interface AutoCloseable { //此处的方法权限为包权限,而子接口Closeable中也变成了public权限 void close() throws Exception; } package java.io; import java.io.IOException; public interface Closeable extends AutoCloseable { public void close() throws IOException; }
ByteArrayOutputStream
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; import java.util.Arrays; public class ByteArrayOutputStream extends OutputStream { //这里可以回答输出流写到哪里的问题:当我们调用write方法时,把内容都存储到了这个byte数组buf中,且是按照追加的方式添加 //而count则指向下一个可以写入的位置,它的初始值默认为0 protected byte buf[]; protected int count; public ByteArrayOutputStream() { this(32); } //类的构造方法只有两个,实际的工作只是在堆中为数组buf申请一块内存,大小可以指定,默认大小为32 public ByteArrayOutputStream(int size) { if (size < 0) { throw new IllegalArgumentException("Negative initial size: " + size); } buf = new byte[size]; } //此方法是确保buf的大小不少于minCapacity,如果buf的空间不够,则调用grow()方法来扩展空间。 private void ensureCapacity(int minCapacity) { if (minCapacity - buf.length > 0) grow(minCapacity); } //这个方法的实现值得我们思考一些问题:数组空间不够了,需要扩展,该如何扩展呢? //我们可能会这样做:既然你需要minCapacity这么多,那就扩展这么多吧。这里没有这么做,如果这样做,那当用户说我还需要一个字节的空间,那我们就又要在扩展一次,而每一次扩展,都会很耗时。 //耗时的原因是扩展的方式,本人猜测应该是这么扩展(不确定):重新申请更大的一块内存,然后把原数组的内容拷贝过去。若真如此,那确实会很耗时。 //这里的策略是:先把原数组的大小通过左移运算扩展为2倍,若这样还不够,那再把大小改为你需要的大小minCapacity。 //注意:左移运算可能会溢出,使得数组大小变为负数,如果存在溢出,则将其改为Integer.MAX_VALUE。这样的大小是肯定够的,如果这样还不够,那么你传入的minCapacity参数一定有问题 private void grow(int minCapacity) { int oldCapacity = buf.length; int newCapacity = oldCapacity << 1; if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity < 0) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); newCapacity = Integer.MAX_VALUE; } //确定扩展后的数组大小后,通过调用Arrays.copyOf来复制数组,大家可以去研究看是否是先申请更大的一块内存,然后在拷贝。 buf = Arrays.copyOf(buf, newCapacity); } //这里实现了父类的抽象方法,从它可以看出,输出流的内容都到了这个类在堆中申请的内存中了,己buf数组。 //现在也可以回答另外一个问题:对于字节流为何传入int型参数。 //首先,无论用户传入何种类型参数,我们都强制转换为byte类型。这样可以方便用户,因为它不需要自己实现强制类型转换 //举例:int a = 10; write((byte)a); //要求用户传入byte类型时,用户需要自己做强制类型转换,但现在我们帮用户做了,岂不方便? //这样一来,用户在使用时必须注意这一点:这是字节输出流,如果传入short、char或int等,只把它当作byte处理。 public synchronized void write(int b) { ensureCapacity(count + 1); buf[count] = (byte) b; count += 1; } //override了父类的方法,把byte b[]中从off开始的len个字节复制到了buf的后面,同时count增加了len public synchronized void write(byte b[], int off, int len) { if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) - b.length > 0)) { throw new IndexOutOfBoundsException(); } ensureCapacity(count + len); System.arraycopy(b, off, buf, count, len); count += len; } //调用此方法,则用户可以把buf中的全部内容输出到用户传入的输出流中 public synchronized void writeTo(OutputStream out) throws IOException { out.write(buf, 0, count); } public synchronized void reset() { count = 0; } //调用此方法,则用户可以得到一个byte数组,其内容为buf中的全部内容 public synchronized byte toByteArray()[] { return Arrays.copyOf(buf, count); } public synchronized int size() { return count; } public synchronized String toString() { return new String(buf, 0, count); } public synchronized String toString(String charsetName) throws UnsupportedEncodingException { return new String(buf, 0, count, charsetName); } @Deprecated public synchronized String toString(int hibyte) { return new String(buf, hibyte, 0, count); } //个人认为,此方法既然与父类一样为空,但又写一遍是否多余?为何不像flush方法一样,在这里省去不写 public void close() throws IOException { } }
FileOutputStream
这个类比较复杂,其中还包含nio包中的内容,因此我只看明白了其中一小部分:它是节点流;我们用它来写文件很方便。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; import java.nio.channels.FileChannel; import sun.nio.ch.FileChannelImpl; import sun.misc.IoTrace; public class FileOutputStream extends OutputStream{ public FileOutputStream(String name) throws FileNotFoundException { this(name != null ? new File(name) : null, false); } public FileOutputStream(String name, boolean append) throws FileNotFoundException { this(name != null ? new File(name) : null, append); } public FileOutputStream(File file) throws FileNotFoundException { this(file, false); } //构造方法一共5个,但实质上只有两个,这是其中一个,另一个是public FileOutputStream(FileDescriptor fdObj),但我都看不懂 //只说我理解的比较简单的东西:当我们写文件时,我们会选择这个类,原因就是它提供了方法使我们方便地写文件 //它的构造方法--我们可以直接传入一个File对象,或者代表文件pathName的String,我们就可以指明输出流的目标是哪个文件了 //其中,append表示是否以追加方式写文件,默认为false,则会覆盖之前文件中的内容 public FileOutputStream(File file, boolean append) throws FileNotFoundException { ... ... } //这是必须实现父类的那个方法,我们看不到具体实现,因为它是native方法 //我们选择这个类操作文件的另一个原因是:这个方法的实现细节一定包含相关的文件操作命令,而其它类不具备这个方法,则不能把流写到文件中 private native void write(int b, boolean append) throws IOException; }
FilterOutputStream
它不是节点流,与父类主要差别就是它多了个成员变量。我们一般不会使用这个类,它是另外三个节点输出流的父类。理解它很简单:它什么活也不干,都交给传入的out去做。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; public class FilterOutputStream extends OutputStream { //此成员变量非常重要,基本上这个类和其父类OutputStream的最主要差别就是它有这个成员变量 //注意到权限为protected,因此在子类中可以直接使用 protected OutputStream out; //构造方法,传入OutputStream子类对象后,基本上该FilterOutputStream做的事情,它全交给这个传入的对象去做 public FilterOutputStream(OutputStream out) { this.out = out; } //我们一般从这个方法中就能看到节点输出流的目的地,这里它并没有真正实现,只是调用了传入的out去做,所以FilterOutputStream不是节点流 public void write(int b) throws IOException { out.write(b); } //表面上调用了下面的write方法,最终还是调用了out的write方法 public void write(byte b[]) throws IOException { write(b, 0, b.length); } //间接调用out的write方法,以字节为单位地输出 //这里对传入的参数的判断比较有意思,虽然对参数的要求与OutputStream对应方法对参数的要求一致,但形式确不一样了 //我的理解:四个量是或的关系,若有一个为负,则最高位必定为1,则最终结果一定为负,因此要求都不能为负 public void write(byte b[], int off, int len) throws IOException { if ((off | len | (b.length - (len + off)) | (off + len)) < 0) throw new IndexOutOfBoundsException(); for (int i = 0 ; i < len ; i++) { write(b[off + i]); } } //自己不做,交给out去flush public void flush() throws IOException { out.flush(); } //自己不做,交给out去close,但是关闭前先调用了flush方法 public void close() throws IOException { try { flush(); } catch (IOException ignored) { } out.close(); } }
BufferedOutputStream
它是处理流,有个缓冲数组,能起到缓冲作用,似乎缓冲很有用,详细就不懂了
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; public class BufferedOutputStream extends FilterOutputStream { //这个类的核心就是这个buf,会将要输出的内容先存在这个数组里,当这个数组满之后再一次全部输出,当然未满是也可以主动输出 //这个buf似乎与ByteArrayOutputStream有些像,但还是有差别:这个buf大小固定后不会再扩展空间 protected byte buf[]; protected int count; public BufferedOutputStream(OutputStream out) { this(out, 8192); } //此构造方法需要传入OutputStream实例,可以设置buf大小,默认为8192字节 public BufferedOutputStream(OutputStream out, int size) { super(out); if (size <= 0) { throw new IllegalArgumentException("Buffer size <= 0"); } buf = new byte[size]; } //private方法,将buf中缓存的内容全部输出 private void flushBuffer() throws IOException { if (count > 0) { out.write(buf, 0, count); count = 0; } } //这个写方法根本没有写,只是把要写的内容先存到了buf中。如果buf已经满了,那才会先把buf内容输出,然后再向buf里写 public synchronized void write(int b) throws IOException { if (count >= buf.length) { flushBuffer(); } buf[count++] = (byte)b; } public synchronized void write(byte b[], int off, int len) throws IOException { //如果要写入的字节数len比buf的长度还大,那就不需要缓冲了,直接调用out的write方法写就可以 if (len >= buf.length) { flushBuffer(); out.write(b, off, len); return; } //如果buf剩余的空间比len小,那就先输出buf内容,腾出空间后再写 if (len > buf.length - count) { flushBuffer(); } System.arraycopy(b, off, buf, count, len); count += len; } //用户需要调用此方法才能实现真正的输出,但是不要每次调用write都紧接着调用flush,那就失去了缓冲的意义了 //另:在close时,父类FilterOutputStream会调用flush方法的,不用担心,所以你如果调用close的话,该输出的都会输出 public synchronized void flush() throws IOException { flushBuffer(); out.flush(); } }
DataOutputStream
处理流,提供了多个很常用的方法。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package java.io; public class DataOutputStream extends FilterOutputStream implements DataOutput { //这个written参数会不断地累加,但有什么意义没弄明白 protected int written; private byte[] bytearr = null; public DataOutputStream(OutputStream out) { super(out); } private void incCount(int value) { int temp = written + value; if (temp < 0) { temp = Integer.MAX_VALUE; } written = temp; } public synchronized void write(int b) throws IOException { out.write(b); incCount(1); } public synchronized void write(byte b[], int off, int len) throws IOException { out.write(b, off, len); incCount(len); } public void flush() throws IOException { out.flush(); } //这个类的核心就是为我们提供了类似writeBoolean这样的方法,我们可以方便地把这些常见类型转为字节并输出,因为这是字节流 public final void writeBoolean(boolean v) throws IOException { out.write(v ? 1 : 0); incCount(1); } //直接输出 public final void writeByte(int v) throws IOException { out.write(v); incCount(1); } //short占两个字节,那么就先把高字节输出,再把低字节输出 //>>>表示无符号右移,右移8位后在与0xFF做与运算,则可保证此int值的更高位为零,也就是只保留了原int的8-15位 public final void writeShort(int v) throws IOException { out.write((v >>> 8) & 0xFF); out.write((v >>> 0) & 0xFF); incCount(2); } //与writeShort完全一致,我的理解是这样在使用时名称很形象 public final void writeChar(int v) throws IOException { out.write((v >>> 8) & 0xFF); out.write((v >>> 0) & 0xFF); incCount(2); } //先高字节内容,后低字节 public final void writeInt(int v) throws IOException { out.write((v >>> 24) & 0xFF); out.write((v >>> 16) & 0xFF); out.write((v >>> 8) & 0xFF); out.write((v >>> 0) & 0xFF); incCount(4); } private byte writeBuffer[] = new byte[8]; //这里没有像之前一个字节一个字节地写,而是先存到writeBuffer中,可能是觉得这样更好,怎么个好法,不懂 public final void writeLong(long v) throws IOException { writeBuffer[0] = (byte)(v >>> 56); writeBuffer[1] = (byte)(v >>> 48); writeBuffer[2] = (byte)(v >>> 40); writeBuffer[3] = (byte)(v >>> 32); writeBuffer[4] = (byte)(v >>> 24); writeBuffer[5] = (byte)(v >>> 16); writeBuffer[6] = (byte)(v >>> 8); writeBuffer[7] = (byte)(v >>> 0); out.write(writeBuffer, 0, 8); incCount(8); } //float和int型都占用4个字节,因此对float转为对应的int字节流,再调用writeInt //Float.floatToIntBits(v)这个方法的实现可能与IEEE规范中关于浮点数规范有关 public final void writeFloat(float v) throws IOException { writeInt(Float.floatToIntBits(v)); } //double和long型都占用8个字节,因此对double转为对应的long字节流,再调用writeLong //Double.doubleToLongBits(v)这个方法的实现可能与IEEE规范中关于浮点数规范有关 public final void writeDouble(double v) throws IOException { writeLong(Double.doubleToLongBits(v)); } //还可以byte处理字符串 public final void writeBytes(String s) throws IOException { int len = s.length(); for (int i = 0 ; i < len ; i++) { out.write((byte)s.charAt(i)); } incCount(len); } //还可以char处理字符串 public final void writeChars(String s) throws IOException { int len = s.length(); for (int i = 0 ; i < len ; i++) { int v = s.charAt(i); out.write((v >>> 8) & 0xFF); out.write((v >>> 0) & 0xFF); } incCount(len * 2); } public final void writeUTF(String str) throws IOException { writeUTF(str, this); } //可以处理utf-8,这个方法很常用,但其实现还需仔细学习 static int writeUTF(String str, DataOutput out) throws IOException { int strlen = str.length(); int utflen = 0; int c, count = 0; /* use charAt instead of copying String to char array */ for (int i = 0; i < strlen; i++) { c = str.charAt(i); if ((c >= 0x0001) && (c <= 0x007F)) { utflen++; } else if (c > 0x07FF) { utflen += 3; } else { utflen += 2; } } if (utflen > 65535) throw new UTFDataFormatException( "encoded string too long: " + utflen + " bytes"); byte[] bytearr = null; if (out instanceof DataOutputStream) { DataOutputStream dos = (DataOutputStream)out; if(dos.bytearr == null || (dos.bytearr.length < (utflen+2))) dos.bytearr = new byte[(utflen*2) + 2]; bytearr = dos.bytearr; } else { bytearr = new byte[utflen+2]; } bytearr[count++] = (byte) ((utflen >>> 8) & 0xFF); bytearr[count++] = (byte) ((utflen >>> 0) & 0xFF); int i=0; for (i=0; i<strlen; i++) { c = str.charAt(i); if (!((c >= 0x0001) && (c <= 0x007F))) break; bytearr[count++] = (byte) c; } for (;i < strlen; i++){ c = str.charAt(i); if ((c >= 0x0001) && (c <= 0x007F)) { bytearr[count++] = (byte) c; } else if (c > 0x07FF) { bytearr[count++] = (byte) (0xE0 | ((c >> 12) & 0x0F)); bytearr[count++] = (byte) (0x80 | ((c >> 6) & 0x3F)); bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F)); } else { bytearr[count++] = (byte) (0xC0 | ((c >> 6) & 0x1F)); bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F)); } } out.write(bytearr, 0, utflen+2); return utflen + 2; } //不知道这个方法有什么用 public final int size() { return written; } }