IO流：用于处理设备上的数据。
设备：硬盘，内存，键盘录入。
IO有具体的分类：
1：根据处理的数据类型不同，字节流和字符流。
2：根据流向不同，输入流和输出流。
字符流的由来：
因为文件编码的不同，而有了对字符进行高效操作的字符流对象。
原理：其实就是基于字节流读取字节时，去查了指定的码表。
字节流和字符流的区别：
1：字节流读取的时候，读到一个字节就返回一个字节。
字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。
2：字节流可以处理所有类型的数据，如图片，mp3，avi。
而字符流只能处理字符数据。
结论：只要是处理纯文本数据，就要优先考虑使用字符流。除此之外都用字节流。
IO的体系。所具备的基本功能就是两个：读和写。
1：字节流
InputStream（读），OutputStream（写）。
2：字符流
Reader（读），Writer（写）。
基本的读写操作方式：
因为数据通常都以文件形式存在。
所以就要找到IO体系中可以用于操作文件的流对象。
通过名称可以更容易获取该对象。
因为IO体系中的子类名后缀绝大部分是父类名称。而前缀都是体现子类功能的名称。
Reader
InputStreamReader
FileReader：专门用于处理文件的字符读取流对象。
Writer
OutputStreamWriter
FileWriter：专门用于处理文件的字符写入流对象。
Reader中的常见的方法：
1：int read():
读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1.
2：int read(char[]):
将读到的字符存入指定的数组中，返回的是读到的字符个数，也就是往数组里装的元素的个数。如果读到流的末尾，返回-1.
3：close():
读取字符其实用的是window系统的功能，就希望使用完毕后，进行资源的释放。
Writer 中的常见的方法：
1：write(ch)：将一个字符写入到流中。
2：write(char[])：将一个字符数组写入到流中。
3：write(String)：将一个字符串写入到流中。
4：flush()：刷新流，将流中的数据刷新到目的地中，流还存在。
5：close()：关闭资源：在关闭前会先调用flush()，刷新流中的数据去目的地。然后流关闭。
FileWriter：
该类没有特有的方法。只有自己的构造函数。
该类特点在于，
1：用于处理文本文件。
2：该类中有默认的编码表，
3：该类中有临时缓冲。
构造函数：在写入流对象初始化时，必须要有一个存储数据的目的地。
FileWriter(String filename):
该构造函数做了什么事情呢？
1：调用系统资源。
2：在指定位置，创建一个文件。
注意：如果该文件已存在，将会被覆盖。
FileWriter(String filename,boolean append):
该构造函数：当传入的boolean类型值为true时，会在指定文件末尾处进行数据的续写。
FileReader：
1：用于读取文本文件的流对象。
2：用于关联文本文件。
构造函数：在读取流对象初始化的时候，必须要指定一个读取的文件。
如果该文件不存在会发生FileNotFoundException.
FileReader(String filename);
清单 1：
1：将文本数据存储到一个文件中。
对于读取或者写入流对象的构造函数，以及读写方法，还有刷新关闭功能都会抛出IOException或其子类。
所以都要进行处理。或者throws抛出，或者 try catch 处理。
清单 2：
完整的异常处理方法。
清单 3：
读取一个已有的文本文件，将文本数据打印出来。
一次读一个字符就打印出来，效率不高。
读一个字符就存入字符数组里，读完1kb 再打印。
字符流的缓冲区：
缓冲区的出现提高了对流的操作效率。
原理：其实就是将数组进行封装。
对应的对象：
BufferedWriter:
特有方法:
newLine():跨平台的换行符。
BufferedReader:
特有方法：
readLine():一次读一行，到行标记时，将行标记之前的字符数据作为字符串返回。当读到末尾时，返回 null.
在使用缓冲区对象时，要明确，缓冲的存在是为了增强流的功能二存在，
所以在建立缓冲区对象时，要先有流对象存在。
其实缓冲内部就是在使用流对象的方法，只不过加入了数组对数据进行了临时存储。为了提高操作数据的效率。
代码上的体现：
写入缓冲区对象。
//建立缓冲区对象必须把流对象作为参数传递给缓冲区的构造函数。
BufferedWriter bufw = new BufferedWriter(new FileWriter("buf.txt"));
bufw.write("abce");//将数据写入到了缓冲区。
bufw.flush();//对缓冲区的数据进行刷新。将数据刷到目的地中。
bufw.close();//关闭缓冲区，其实关闭的是被包装在内部的流对象。
读取缓冲区对象。
BufferedReader bufr = new BufferedReader(new FileReader("buf.txt"));
String line = null;
//按照行的形式取出数据。取出的每一个行数据不包含回车符。
while((line=bufr.readLine())!=null)
{
System.out.println(line);
}
bufr.close();
练习：通过缓冲区的形式，对文本文件进行拷贝。
public static void main(String[] args) {
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
String line = null;
while((line = bufr.readLine())!= null) {
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufw.close();
bufr.close();
}
readLine():方法的原理：
其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read 方法。
只不过，每一次读到一个字符，先不进行具体操作，先进行临时存储。
当读取到回车标识时，将临时容器中存储的数据一次性返回。
既然明确了原理，我们也可以实现一个类似功能的方法。
class MyBufferedReader {
private Reader r;
MyBufferedReader(Reader r) {
this.r = r;
}
public String myReadLine() throws IOException {
//1：创建临时容器。
StringBuilder sb = new StringBuilder();
//2：循环的使用read方法不断读取字符。
int ch = 0 ;
while((ch = r.read())!=-1) {
if(ch == '\r')
continue;
if(ch == '\n')
return sb.toString
else
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void myClose() throws IOException {
r.close();
}
}
main() {
MyBufferedReader myBufr = new MyBufferedReader(new FileReader("a.txt"));
String line = null;
while((line = myBufr.myReadLine())!=null) {
System.out.println(line);
}
}
它的出现基于流并增强了流的功能。
这也是一种设计模式的体现：装饰设计模式。
对一组对象进行功能的增强。
该模式和继承有什么区别呢？
它比继承有更好的灵活性。
通常装饰类和被装饰类都同属于一个父类或者接口。
Writer
--->MediaWriter
--->TextWriter
(注：MediaWriter 与 TextWtiter 两个类在 JDK中并不存在，为了更形象的举例说明而“创建”的 ，不要误解哈。）
需求：想要对数据的操作提高效率，就用到了缓冲技术。
通过所学习的继承特性。可以建立子类复写父类的write方法。即可
Writer：（注：不要误解，以下两个对象不存在，只为举例。）
--->MediaWriter
--->BufferedMediaWriter
--->TextWriter
--->BufferedTextWriter
当 Writer 中子类对象过多，那么为了提高每一个对象效率，每一个对象都有一个自己的子类Buffered。
虽然可以实现，但是继承体系变的很臃肿。
那么是否可以对其进行一下优化呢？
其实子类都是在使用缓冲技术。
可不可以对缓冲技术进行描述，将需要增强的对象传递给缓冲区即可。
class BufferedWriter {
BufferedWriter(MediaWriter mw) {}
BufferedWriter(TextWriter mw) {}
}
该类虽然完成了对已有两个对象的增强。
但是当有新的对象出现时，还是继续在该类中添加构造函数。这样不利于扩展和维护。
将对这些对象父类型进行操作即可。这就是多态，提高了程序的扩展性。
同时BufferedWriter 中一样具有write方法，只不过是增强后的write。
所以BufferedWriter也应该是Writer中的一个子类。
class BufferedWriter extends Writer {
private Write w;
BufferedWriter(Writer w) {
this.w = w;
}
}
Writer
--->MediaWriter
--->TextWriter
--->BufferedWriter
这样就会发现装饰设计模式，优化增强功能的部分。比继承要灵活很多。
可以在读一行的基础上添加一个行号。
class MyLineNumberReader extends MyBufferedReader {
private int number;
MyLineNumberReader(Reader r) {
super(r);
}
public String myReadLine(){
number++;
return super.myReadLine();
}
public void setNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
}