主要内容包括OutputStream及其部分子类，以分析源代码的方式学习。关心的问题包括：每个字节输出流的作用，各个流之间的主要区别，何时使用某个流，区分节点流和处理流，流的输出目标等问题。 OutputStream的类树如下所示，其中，ObjectOutputStream和PipedOutputStream本文将不做讨论。
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源码分析
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父类或接口的方法时，原以为要和父类或接口中声明的一样，包括权限，现在看来不然。
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
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包中的内容，因此我只看明白了其中一小部分：它是节点流；我们用它来写文件很方便。
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去做。
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
它是处理流，有个缓冲数组，能起到缓冲作用，似乎缓冲很有用，详细就不懂了
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
处理流，提供了多个很常用的方法。
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;
}
}