模拟BufferedInputStream，编写一个类
package toto.IO;
import java.io.IOException;
import java.io.InputStream;
class MyBufferedInputStream{
private InputStream in;
privatebyte[] buf = newbyte[1024*4];
privateintpos = 0,count = 0;
MyBufferedInputStream(InputStream in){
this.in = in;
}
//从缓冲区中读取一个字节
/**
*缓冲区的原理：
*其实就是定义了一个临时容器
*然后将获取到的数据都存入到临时容器中，通过临时容器的方法获取数据，当临时容器
*中的数据取完后，再获取一批数据进容器、
发现自定义的缓冲区出现了秒杀效果
为什么秒杀呢？
因为MP3这样的媒体数据，对应的二进制数据，很有可能出现连续多个1的情况。而连续的过程中，出现-1，程序就认为读到了末尾，程序停止读取。
为了避免这种情况，将获取的一个字节数据，进行提升，变成int ,并在保留原有八位的基础上补零。补完后，就变成了正数，就避免了-1的这种情况。
*/
publicint myRead() throws IOException{
if(count == 0){
count = in.read(buf);//通过流对象从硬盘获取一批数据装入缓冲去
pos = 0;//从0开始取
byte b = buf[pos];//将数据存入数组
pos++;//取完之后pos++
count--;//取走一个减少一个
returnb&oxff; //这里与上的是255。这里进行了自动提升效果。
}elseif(count>0){
//第二次取时count>0
byte b = buf[pos];
pos++;
count--;
return b;
}else {
return -1;
}
}
publicvoid myClose()throws IOException{
in.close();
}
}
publicclass Demo1 {
}
/*package toto.IO;
import java.io.IOException;
import java.io.Reader;
*//**
*按照装饰设计模式的思想
*自定义MyBufferedReader类
*一样提供一个和BufferedReader功能相同的readLine方法。
*//*
class MyBufferedReader{//extends Reader{
由于它里面中提供Reader中的所有方法，故它要继承Reader类。这里继承的原因是里面的方法太多这里不写了
private FileReader r;这种方式只能包装FileReader类，
要想包装所有的Reader的子类，我们写成以下方式：
private Reader r;
MyBufferedReader(Reader r) {//这里是被包对象
this.r = r;
}
提供一个一次读一行的方法。
* 1、使用的还是Reader中read()方法，一次读一个。
* 2、将读到一个字符进行临时存储。数组和StringBuilder都可以。
* 这里选用StringBuilder，因为可以省略数组延长部分代码的编写。该Builder中使用就是数组
* 而且可变长度，并且最终变成字符串。
* 3、因为自负有很多需要循环读取。
* 4，读取到的字符进行判断，如果是回车符，那么就将StringBuilder中的存储数据作为字符串返回
public String myReadLine() throws IOException {
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch==r.read())!=-1) {//使用初进来的read方法，并且要判断不等于-1
if(ch=='\r')//遇到这个转义字符时，不能将这个数据读进去，并且将这个数据向下读一个
continue;
if(ch=='\n')
return sb.toString();
sb.append((char)ch);//如果两个都满足，就将数据向里面转了。
}
return null;
}
public void myClose() throws IOException{
r.close();
}
}
public class MyBufferedReader{
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
*/
转换流
/*
* 转换流，涉及的对象都在字符流体系中。
* InputStreamReader字节转到字符的桥梁。把看不懂得转换成为看的懂的。
* OutputStreamWriter：字符转到字节的桥梁。把看得懂的转换成为看不懂的。
* 该类本身是一个字符流，因为它是桥梁，需要把一个指定的字节流传给构造函数。
* 将制定的字节流转成字符流。*/
package toto.IO;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
publicclass Demo2 {
publicstaticvoid main(String[] args)throws IOException {
//readIn();
// System.out.println('-'+0);
// System.out.println('1'+0);
readLineByKey();
}
/*
* 读取键盘录入，并打入的录入的数据
* 当录入了一行数据后，打印录入的一行数据内容。而其可以不断的进行录入
* 一次打印一行。
*
*1，读取键盘通过System.in完成
*2，需要一次打印一行。那么就需要定义一个临时容器，将读取到自己额进行临时存储。
*当读到回车符的时候就降临时容器中存储的数据一次性打印、*/
publicstaticvoid printLineByKey() throws Exception{
InputStream in = System.in;
int by = 0;
StringBuilder sb = new StringBuilder();
while((by==in.read())!=-1){//这里有警告，不知道为什么
if(by=='\r')
continue;
if(by=='\n')
System.out.println(sb.toString());
else
sb.append((char)by);
}
}
publicstaticvoid readIn() throws IOException {
//获取标准的输入流，对应的默认设备就是键盘。
//从键盘获取到的数据都是字节数据。
InputStream in = System.in;
//读取键盘录入的一个字节
//通