复制：
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：a.txt 输入流 字节输入流 InputStream FileInputStream
1、一次读取一个字节
2、一次读取一个字节数组
目的地：b.txt 输出流 字节输出流 OutputStream FileOutputStream
1、一次写一个int类型的数据
2、一次一个字节数组
3、一次写字节数组的一部分
字节缓冲输出流：
字节缓冲输出流：BufferedOutputStream
构造方法：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
字节缓冲输入流：
字节缓冲输入流：BufferedInputStream
构造方法：
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream并保存其参数，输入流in，供以后使用。
编码、解码：
编码
把看得懂的变成看不懂的 (加密)
String -- byte[]
解码
把看不懂的变成看得懂的 (解密)
byte[] -- String
只要保证将来写入和读取的编码一致就可以了,与存储媒介的编码无关，
如果要想打开存储媒介能看懂的话，就得使媒介的编码与存储时的编码一致就可以了。
字符流：
字符流 = 字节流 + 编码表
字符输出流：Writer -- OutputStreamWriter
字符输入流：Reader -- InputStreamReader
OutputStreamWriter的构造方法：
public OutputStreamWriter(OutputStream out)
创建一个使用默认字符集的OutputStreamReader。
public OutputStreamWriter(OutputStream out,String charsetName)
创建一个使用命名字符集的OutputStreamReader。
OutputStream的写方法：
public void write(int c) //写入字符
public void write(char[] cbuf) //向文件中写入字符数组
public void write(char[] cbuf,int off,int len) //写入字符数组的一部分
public void write(String str) //写入字符串
public void write(String str,int off,int len) //写入字符串一部分
//创建字符输出流对象
//调用方法向文件中写入数据
//刷新缓冲区，调用flush方法后，可以将缓冲区中的数据刷到文件中，并且字符流输出对象不会关闭
//释放资源，包含了刷新操作，但是刷新完后，流对象关闭，后续无法再进行操作了。
InputStreamReader的构造方法：
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
InputStreamReader读取数据的两种方式：
1、public int read()
//方式1：一次读取一个字符
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}
2、public int read(char[] cbuf)
//方式2：一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while ((length = isr.read(chars)) != -1) {
String s = new String(chars, 0, length);
System.out.println(s);
}
复制操作：
1、把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：a.txt 字符流 输入流 Reader -- InputStreamReader
1、一次读取一个字符
2、一次读取一个字符数组
目的地：b.txt -- 字符输出流 -- Writer -- OutputStreamWriter
2、将D盘下的MainDemo.java复制到E盘下MainDemo2.java
数据源：D:\\MainDemo.java -- 字符输入流 -- Reader -- InputStreamReader
目的地：E:\\MainDemo2.java -- 字符输出流 -- Writer -- OutputStreamWriter
字符流的简化写法：
我们知道字符转换流是基于字节流诞生的，
字符流 = 字节流 + 编码表
但是呢，我们在正常写程序的过程中并没有刻意地传入编码，而是使用java默认地编码去操作
OutputStreamWriter = FileOutputStream + 编码表（Unicode编码）
InputStreamReader = FileIntputStream + 编码表（Unicode编码）
上面的过程中，在创建对象时，名字有点长，所以java提供了一个字符流的简化写法
字符输出流：FileWriter
字符输入流：FilerReader
字符转换输出流：
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));
简化字符输出流：
FileWriter fw = new FileWriter("a.txt");
字符转换输入流：
InputStreamReader isr = new InputStreamReader(new FileInputStream("b.txt"));
简化字符输入流：
FileReader fr = new FileReader("b.txt");
FileWriter和FileReader实现文本文件的复制：
数据源：out.txt -- 字符输入流 -- Reader -- InputStreamReader -- FileReader
目的地：ccc.txt -- 字符输出流 -- Writer -- OutputStreamWriter -- FileWriter
自负缓冲流：
类比之前学习字节流的时候有缓冲流存在，字符流也有相对应的缓冲流
字符缓冲输出流：BufferedWriter
字符缓冲输入流：BufferedReader
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)
创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
字符缓冲流特有的方法：
BufferedWriter:
public void newLine() throws IOException//写一行行分隔符。
行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符（'\ n'）字符。
BufferedReader:
public String readLine() throws IOException//读一行文字。
一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。
IO流总结：
IO流
按照流向：
输入流
输出流
按照数据类型：
字节流
字节输入流
InputStream(抽象父类)
FileInputStream:
FileInputStream fis = new FileInputStream("...");
读取数据两种方式：
1）一次读取一个字节
int b = 0;
while((b=fis.read())!=-1){
System.out.print((char)b);
}
2）一次读取一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while((length = fis.read(bytes))!=-1){
String s = new String(bytes,0,length);
System.out.print(s);
}
字节缓冲输入流：BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..."));
1）一次读取一个字节
int b = 0;
while((b=bis.read())!=-1){
System.out.print((char)b);
}
2）一次读取一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while((length = bis.read(bytes))!=-1){
String s = new String(bytes,0,length);
System.out.print(s);
字节输出流:
OutputStream(抽象父类)
FileOutputStream:
//如果目标文件不存在，会自动创建
FileOutputStream fos = new FileOutputStream("...");
写入数据的三种方式：
1）一次写一个int类型的数据
fos.write(97);
2）一次写一个字节数组
fos.write(bytes);
3）一次写一个字节数组的一部分
fos.write(bytes,1,3);
字节缓冲输出流：BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(".."));
1）一次写一个int类型的数据
bos.write(97);
2）一次写一个字节数组
bos.write(bytes);
3）一次写一个字节数组的一部分
bos.write(bytes,1,3);
字符流 = 字节流 + 编码表
字符输入流：Reader -- InputStreamReader
InputStreamReader isr = new InputStreamReader(new FileInputStream("..."));
1）一次读取一个字符
int ch = 0;
while((ch=isr.read())!=-1){
System.out.print((char)ch); //这里不会出现乱码
}
2）一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length=isr.read(chars))!=-1){
String s = new String(chars,0,length);
System.out.print(s);
}
简化写法：fileReader
fileReader fr = new FileReader("...");
1）一次读取一个字符
int ch = 0;
while((ch=fr.read())!=-1){
System.out.print((char)ch); //这里不会出现乱码
}
2）一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length=fr.read(chars))!=-1){
String s = new String(chars,0,length);
System.out.print(s);
}
字符缓冲输入流：BufferedReader
BufferedReader br = new BufferedReader(new OutputStreamReader(new FileOutputStream("...")))
//简化写法改进：
BufferedReader br = new BufferedReader(new FileReader("..."));
1）一次读取一个字符
int ch = 0;
while((ch=br.read())!=-1){
System.out.print((char)ch); //这里不会出现乱码
}
2）一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length=br.read(chars))!=-1){
String s = new String(chars,0,length);
System.out.print(s);
}
3）使用特殊方法一次读取一行
String line = null;
while((line = br.readLine())!=null){
System.out.print(line);
}
字符输出流：Writer --OutputStreamWriter
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("..."));
1）一次写一个int类型的数据
2）一次写一个字符数组
3）一次写一个字符数组的一部分
4）一次写一个字符串
5）一次写一个字符串的一部分
简化写法：FileWriter
FileWriter fw = new FileWriter("...");
1）一次写一个int类型的数据
2）一次写一个字符数组
3）一次写一个字符数组的一部分
4）一次写一个字符串
5）一次写一个字符串的一部分
字符缓冲输出流：BufferedWriter
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("...")));
//简化写法改进：
BufferedWriter bw = new BufferedWriter(new FileWriter("..."));
1）一次写一个int类型的数据
2）一次写一个字符数组
3）一次写一个字符数组的一部分
4）一次写一个字符串
5）一次写一个字符串的一部分
特殊的方法：写换行符：newLine();
