模拟BufferedInputStream，编写一个类
package toto.IO;
import java.io.IOException;
import java.io.InputStream;
class MyBufferedInputStream{
private InputStream
in;
private
byte[]
buf =
new
byte[1024*4];
private
int
pos = 0,count
= 0;
MyBufferedInputStream(InputStream in){
this.in
= in;
}
//从缓冲区中读取一个字节
/**
*缓冲区的原理：
*其实就是定义了一个临时容器
*然后将获取到的数据都存入到临时容器中，通过临时容器的方法获取数据，当临时容器
*中的数据取完后，再获取一批数据进容器、
发现自定义的缓冲区出现了秒杀效果
为什么秒杀呢？
的情况。而连续的过程中，出现-1，程序就认为读到了末尾，程序停止读取。
为了避免这种情况，将获取的一个字节数据，进行提升，变成int ,并在保留原有八位的基础上补零。补完后，就变成了正数，就避免了-1的这种情况。
*/
public
int myRead()
throws IOException{
if(count
== 0){
count =
in.read(buf);//通过流对象从硬盘获取一批数据装入缓冲去
pos = 0;//开始取
byte b =
buf[pos];//将数据存入数组
pos++;//取完之后pos++
count--;//取走一个减少一个
return
b&oxff;
//。这里进行了自动提升效果。
}else
if(count>0){
//第二次取时count>0
byte b =
buf[pos];
pos++;
count--;
return b;
}else {
return -1;
}
}
public
void myClose()throws
IOException{
in.close();
}
}
public
class 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;
public
class Demo2 {
public
static
void main(String[] args)throws
IOException {
//readIn();
//
System.out.println('-'+0);
//
System.out.println('1'+0);
readLineByKey();
}
/*
* 读取键盘录入，并打入的录入的数据
* 当录入了一行数据后，打印录入的一行数据内容。而其可以不断的进行录入
* 一次打印一行。
*
*1，读取键盘通过System.in完成
*2，需要一次打印一行。那么就需要定义一个临时容器，将读取到自己额进行临时存储。
*当读到回车符的时候就降临时容器中存储的数据一次性打印、*/
public
static
void 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);
}
}
public
static
void readIn()
throws IOException {
//获取标准的输入流，对应的默认设备就是键盘。
//从键盘获取到的数据都是字节数据。
InputStream in = System.in;
//读取键盘录入的一个字节
//通过循环形式，读取一个字节，打印一个字节
int by = 0;
while((by=in.read())!=-1){
System.out.println(by);
}
}
public
static
void readLineByKey()
throws IOException {
//字节读取流
InputStream in =System.in;
//要想使用readLine方法读取一样，就要建立BufferReader对象
//但是该字符流的缓冲区，在对象在初始化时，
//要将一个字符对象作为参数传递给BufferReader的构造函数
//读取键盘是字节流，如何让字符流的缓冲区所使用呢？，这时就需要将字节流转成字节流
//想要进行字节和字符流的转换，就需要IO包中的转换流
//由于早期只有字节流，只有涉及到字符流之后才涉及到转换，故这个转换体系在字符流中。
//InputStreamReader的前面是字节流，后面是字符流。故通过它转换。
InputStreamReader isr = new InputStreamReader(in);
//因为BufferedReader只能包装字符流。故只需将isr传递进去就行了。
BufferedReader bufr = newBufferedReader(isr);
String line = null;
while((line=bufr.readLine())!=null){
if(line.equals("over")){
break;
}
//System.out.println(line.toUpperCase());
}
bufr.close();
}
}
package toto.IO;
/*流操作的基本规律
*
流操作要明确数据源和数据目的（数据汇）
*
*
在现有程序中，
*
源：键盘
*
目的控制台。
* 1、需求：将一个硬盘上的文件打印在控制台上
* 2、需求：将键盘录入的数据存储到一个文件中。
*
* */
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public
class TransStreamDemo2 {
public
static
void main(String[] args)
throws IOException {
/*InputStream in = System.in;
InputStreamReader isr = new InputStreamReader(in);
BufferedReader bufr = new BufferedReader(isr);*/
//上面三行可以转换成一行,读取键盘最方便方式，因为键盘录入的都是文本数据。所以一次读一行最方便,先将字节流包装成字符流，再将字符流写入缓冲区，提高效率。
/*BufferedReader bufr = new
BufferedReader(new InputStreamReader(System.in));*/
//硬盘上的文件是字节流，要将它转换成字符流，读取硬盘上的一个文件的方式：
BufferedReader bufr = new
BufferedReader(new InputStreamReader(new
FileInputStream("文件地址")));
/*向控制台上输出，使用System.out
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);*/
//
BufferedWriter bufw = new BufferedWriter(newOutputStreamWriter(System.out));
//时，上面是System.in，下面是要写到的文件的路径。当上下都是文件名称时，相当于文件的复制。
BufferedWriter bufw = new BufferedWriter(new
OutputStreamWriter(new FileOutputStream("要写到的文件的地址")));
String line = null;
while((line==bufr.readLine())!=null){
if("over".equals(line)){
break;
}
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufw.close();
bufr.close();
}
}
IO包中对象其实都是以围绕读写为主，用于操作数据。
IO技术的难点：因为io包中的对象太多，在实际开发，不太容易明确使用哪个对象
IO操作的基本规律：
1、 作用的数据源和数据目的。
如果是操作数据源：输入流。（InputStream
，Reader）,读入的是字节流用InputStream，读入的是字符流用Reader.
如果是操作数据汇：就是输入流。（OutputStream，Writer），输出成字节流用OutputStream，输出成字符用writer
2、 要操作的数据是不是纯文本数据。
如果是：使用字符流
如果不是：使用字节流。
3，根据源和目的的设备来确定要操作的对象。
无论数据源或者数据汇都有存在设备。
源设备：硬盘（File）。键盘(键盘对应的是System.in)。内存（内存对应的都是数组）。
目的设备：硬盘（File），控制台(控制台对应的是：System.out)，内存（内存对应的是数组）。
这两个明确可以确定到底要使用上面四个体系中的那个体系。
需求一：对文本文件进行复制
1， 这个需求既有源又有目的
源：硬盘上的文件。InputStream Reader
目的：硬盘上的文件。OutputStream or Writer
是不是纯文本数据呢？是。
源：要使用字符读取流Reader
目的：要使用字符输出流Writer
那么体系确定后，要使用该体系中那个对象呢？
源：是一个文件。所以要使用字符读取流中可以操作文件的对象：FileReader
目的：也是一个文件，所以要使用字符写入流中的可以操作文件的对象：FileWriter
FileReader fr = new FileReader(“a.txt”);
FileWriter fw = new FileWriter(“b.txt”);
该操作过程中是否需要提高侠侣呢？是。
如果是：加入缓冲技术。
代码就变成：
BufferedReader bufr = newBufferedReader(new FileReader(“a.txt”));
BufferedWriter bufw = newBufferedWriter(new FileWriter(“b.txt”));
需求二，将一个硬盘上的文件打印在控制台上。
1， 明确源和目的
源：硬盘的文件。读取文件，体系是InputStream or Reader
目的：控制台。OutputStream or Writer
对于控制台较为特殊，其默认的目的是System.out
2， 是不是纯文本数据
是
源：Reader
目的Writer
3，明确体系中的对象
源：因为是一个文件，FileReader
目的：因为是控制台对应的对象是System.out，为了便于字符操作，所以将System.out转换成字符流。
FileReader fr =new FileReader(“a.txt”);
读取字符流
OutputStreamWriterout =new OutputStreamWriter(System.out;); //输出字节流
FileReader fr =new FileReader(“a.txt”);
读取字符流
OutputStreamWriterosw = new OutputStreamWriter(System.out);这里也变成了字符流了。
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1){
osw.writer(buf,o.len);
//将数据写到目的了(buf)，即控制体。
}
为了提高效率，加入缓冲技术。
BufferedReader buf = new BufferReader(newFileReader(“a.txt”));
BufferedWriter bufw = newBufferedWriter(new OutputStreamWriter(“b.txt”));
String line = null;
While((lien=bufr.readLine())!=null){
bufw.write(line);
bufw.newLine();
bufw.flush();
}
需求三，将录入的文件写入硬盘上的文件。
1,明确体系；
源：InputStream。 System.in
目的：硬盘文件
OutputStream，Writer。
2， 明确纯文本。
因为键盘录入的都是字节数据。但是该数据最终得转化成为纯文本。
所以可以使用字符流。
源：Reader
目的：Writer。
3， 明确体系对象
源：因为键盘录入，对应的对象是System.in，是一个字节读取流。
为了可以使用字符读取留来操作这些数据，可以将其转换成字符读取流
目的：因为是一个文本文件，所以可以使用FileWriter。
InputStreamReaderisr = new InputStreamReader(System.in);
FileWriter fw =new FileWriter(“a.txt”);
为了提高效率，加入了缓冲技术
Bufferreader bufr = new BufferedReader(newInputStreamReader(System,in));
BufferedWriter bufw = newBufferedWriter(new FileWriter(“a.txt”));
需求四：读取键盘录入，将录入的信息打印在控制台上，
1体系：
源：InputStream
Reader
目的：OutputStream，Writer
2纯文本：是
源：Reader
目的：Writer
4， 对象：
源：System.in
目的：System.out
因为键盘录入都是纯文本，所以用字符流操作很方便。
那么就将源和目的都转换成字符流
InputStreamReader isr = newInputStreamReader(System.in);
OutputStreamWriter osw = newOutputStreamWriter(System.out);
需要高效
BufferedReader bufr = newBufferedReader(new InputStreamReaderl(System,in));
BufferedWriter bufw = newBufferedWriter(new OutputStreamWriter(System.out));
注意：在使用写入缓冲区时，记得要进行刷新。flush().
需求五：将一个文本文件中的数据存储到另一个文本文件中，要求按照UTF-8的编码形式存储
1， 体系
源InputStream or Reader
目的：OutputStream or Writer
2,纯文本？yes
源：Reader
目的：Writer
3，对象：
因为操作是文本，而且没有指定编码。所以可以按照默认编码形式
。那么就可以使用FileReader
目的：
按照一般思想，会去找FileWriter。但是FileWriter使用的默认编码。
而需求中要求按照指定编码UTF-8形式存储
那么这时就要用到转换流，因为只有转换流可以在初始化是指定编码。
目的也是一个文件。那么就明确要使用的对象是FileOutStream。
FileReader fr =new FileReader(“a.txt”);
OutlputStreamWriterosw = new OutputStream(new FileOutputStream(“b.txt”),”UTF-8”);
需要提高效率
BufferedReaderbufr = new BufferedReader(new FileReader(a.txt));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(newFileOutputStream(“b.txt”),”UTF-8”));
package toto.IO;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class TransStreamDemo {
/**
* @param args
*/
publicstatic void main(String[] args)throws IOException {
//writeText();
readText();
}
publicstatic void readAndWrite()throws IOException{
FileReaderfr = new FileReader("test.txt");//字符流
//FileWriterfw = new FileWriter("test1.txt");//默认的字符集。
OutputStreamWriterosw = new OutputStreamWriter(new
FileOutputStream("text1.txt"),"utf-8");//字符流
char[] buf = new char[1024];
intlen = 0;
while((len=fr.read(buf))!=-1){
osw.write(buf,0,len);
}
osw.close();
fr.close();
}
publicstatic void readText() throws IOException{
FileReaderfr = new FileReader("test.txt");//这种编码默认是gbk
intch = fr.read();
System.out.println((char)ch);
intch1 = fr.read();
System.out.println((char)ch1);
fr.close();
}
publicstatic void writeText() throws IOException{
FileWriterfw = new FileWriter("test.txt");
fw.write("你好");
fw.close();
}
}
读取一个UTF-8编码的文件。
BufferedReader bufr =
New BufferedReader(new
FileInputStream(“text.txt”,”utf-8”)
)
或通过：
InputStreamReaderisr = new InputStreamReader(new FileInputStream(“text.txt”,”utf-8”));
char[] buf = new char[1024];