关于IO包装流中的两个read方法

刚开始学IO流，会经常感到奇怪，为什么read方法返回的都是int类型，而且，在包装流中经常会弄混淆，看了传智播客老师的视频，加上API文档的了解，总算是完全弄懂了。

下面贴出四个包装流的代码，分别包装了inputstream、outputstream、reader、writer：

public class MyBufferedInputStream extends InputStream {

	private InputStream in;
	private byte[] buf = new byte[1024];	//自定义字节数组作为缓冲区
	private int len = 0; 	//定义一个变量，用于记住缓冲区可用字节数量
	private int pos = 0; 	//定义一个变量，用于记住缓冲区当前可用字节的角标
	//通过构造函数组合被包装的流
	public MyBufferedInputStream(InputStream in) {
		this.in = in;
	}
	
	@Override
	public int read() throws IOException {
		//判断缓冲区是否还有可用字节
		if(len==0) {
			//一次性填充缓冲区
			len = in.read(buf);
			//pos要置零
			pos = 0;
		}
		//判断是否到了流的末尾
		if(len==-1) {
			return -1;
		}
		//返回一个字节，可用字节就少一个，所以len到减1
		len--;
		//返回当前可用字节,升级为int，前面加24个0
		//11111111 & 00000000 00000000 00000000 11111111 0xff
		return buf[pos++]&0xff;
	}
	
	public void close() throws IOException {
		//关闭底层被包装的流
		in.close();
	}

}

public class MyBufferedOutputStream extends OutputStream {

	private OutputStream out;
	private byte[] buf = new byte[1024];	//自定义缓冲区
	private int pos = 0; 	//定义一个变量，记住当前缓冲区可存储的位置
	//组合被包装的流
	public MyBufferedOutputStream(OutputStream out) {
		this.out = out;
	}
	@Override
	public void write(int b) throws IOException {
		//判断缓冲区是否已满
		if(pos==1024) {
			//刷新缓冲区
			flush();
			//pos置零
			pos = 0;
		}
		//将当前字节存入缓冲区对应的空位
		buf[pos++] = (byte) b;
	}
	
	public void flush() throws IOException {
		//将缓冲区有用的字节写入底层流
		out.write(buf, 0, pos);
	}

	public void close() throws IOException {
		//刷心缓冲区
		flush();
		//关闭底层的流
		out.close();
	}
}

public class MyBufferedReader extends Reader {
	private Reader r;
	private char[] buf = new char[1024];
	private int pos;
	private int len;
	public MyBufferedReader(Reader r) {
		this.r = r;
	}
	
	/* 实现read方法，实现缓冲的功能
	 * 分析:
	 * 1.当别人第一次调用次方法时，一次性填充缓冲区
	 * 2.定义一个变量len记住缓冲区的可用字符数量
	 * 3.定义一个变量pos用于记住当前可用字符的角标
	 * 3.将数组的第一个元素返回，
	 * 4.当别人第二次调用时，将数组的第二个元素返回，
	 * 5.每次返回一个元素，len--
	 * 6.当len为0时，说明数组没有可用字符了，再次填充缓冲区，直到读到-1,
	 * 
	 * 思路:
	 * 1.定义两个成员变量，len记住可用字符数量，pos记住当前可用字符的位置
	 * 2.判断len，如果len为0,填充缓冲区，pos要置零
	 * 3.判断len，如果为-1，我们也返回-1
	 * 4.将pos位置的元素返回，pos要++
	 */
	public int read() throws IOException {
		if(len==0) {
			len = r.read(buf);
			pos = 0;
		}
		if(len==-1)
			return -1;
		len--;
		return buf[pos++];
	}
	
	/* 实现readLine方法，实现读一行的功能
	 * 1.循环调用自己的read方法，读取字符
	 * 2.直到遇上回车换行，方法结束
	 */
	public String readLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		int ch;
		while((ch=read())!=-1) {
			if(ch=='\r')
				continue;
			if(ch=='\n')
				break;
			sb.append((char)ch);
		}
		if(ch==-1&&sb.length()==0)
			return null;
		return sb.toString();
	}
	
	public void close() throws IOException {
		r.close();
	}

	@Override
	public int read(char[] buf, int offset, int len) throws IOException {
		int count = 0;
		for(int i=offset; i<offset+len; i++) {
			int ch = read();
			if(ch==-1)
				break;
			count++;
			buf[i] = (char) ch;
		}
		return count;
	}
}

public class MyBufferedWriter extends Writer {
	
	private Writer w;
	private char[] buf = new char[1024];
	private int pos = 0;
	public MyBufferedWriter(Writer w) {
		this.w = w;
	}

	/*
	 * 定义write方法，实现写入一个字符,实现缓冲的功能
	 * 1.定义一个变量pos记住当前的写入位置，
	 * 2.每次调用者调用此方法都会传入一个字符，将字符存入缓冲数组的pos位置，
	 * 3.pos++;
	 * 4.每次一上来都要判断，如果pos==1024，刷新缓冲区，pos=0；
	 */
	public void write(int ch) throws IOException {
		if(pos==1024) {
			flush();
			pos = 0;
		}
		buf[pos++] = (char) ch;
	}
	
	@Override
	public void close() throws IOException {
		flush();
		w.close();
	}

	@Override
	public void flush() throws IOException {
		// 刷新缓冲区，将当前缓冲区有用字符一次性写入底层被包装的流
		w.write(buf, 0, pos);
	}

	public void write(String data) throws IOException {
		char[] chars = data.toCharArray();
		for(char c : chars)
			write(c);
	}
	
	public void newLine() throws IOException {
		write("\r\n");
	}
	@Override
	public void write(char[] buf, int offset, int len) throws IOException {
		for(int i=offset; i<offset+len; i++)
			write(buf[i]);
	}

}

所有这些包装流中，无参的read()方法，返回的int都是字符或字节的ASCII码，参数为数组的read(buf)返回的int是数组中的字符或字节个数，用来确定读取到的字符或字节在数组中的位置，两个read方法返回-1时都代表到了流的末尾。