20.01 IO流（IO流概述及分类）
1.IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中
字节流：字节流可以操作任何数据，计算机中任何数据都以字节的形式存储的
字符类：字符类只能操作纯字符数据，较为方便
2.IO流常用父类
字节流的抽象父类: InputStream OutputStram
字符流的抽象父类： Reader Writer
3.IO流程序书写
使用前： 导入IO包中的类
使用时： 进行IO异常处理
使用后： 释放资源
20.02 IO流(FileInputStream)
1.read() 一次读入一个字节
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class day20_02 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("xxx"); //创建流对象
int x = fis.read(); //从硬盘上读取一个字节，读取xxx文件内的 a
int y = fis.read(); //再次创建对象，指针向后移动一次，读取到xxx文件内的 b
System.out.println(x);
System.out.println(y);
fis.close(); //关流，释放资源
System.out.println("-------------------"); //优化版（一般使用如下方式）
FileInputStream fis2 = new FileInputStream("xxx");
int b ;
while((b=fis2.read()) != -1){
System.out.println(b);
}
} }
20.03 IO流（read()方法返回值为什么是int）
1.read() 读取的是一个字节，为什么返回的是int，不是byte
因为自己输入流可以操作任意类型的文件，比如音频图片等，这些文件底层都是二进制形式存储的，如果内次读取都返回byte
有可能读到中间的时候遇到11111111，那么这11111111是byte类型的-1，这时候程序遇到-1就会停止
20.04 IO流(FileOutputStream)
2.write() 一次写出一个字节
20.05 IO流(FileOutputStream追加)
FileOutputStream的构造方法 写出数据 如何实现 数据的追加写入
FileOutputStream fos = new FileOutputStream("yyy.txt",true);
20.06 IO流（拷贝图片）
1.FileInputStream
2.FileOutputStream
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class day20_06 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("02.jpg");
FileOutputStream fos = new FileOutputStream("copy.jpg"); int b ;
while((b=fis.read()) != -1){
fos.write(b);
}
fis.close();
fos.close();
}
}
20.07 IO流（拷贝音频文件画原理图）
20.08 IO流（字节数组拷贝之available()方法）
byte[] arr = new byte[fis.available()];//创建一个根输入文件一样大的数组
此方法在开发中不推荐，加入要传一个10个G的电影，创建一个10个G的数组，不合理
20.09 IO流（定义小数组）
20.10 IO流（定义小数组的标准格式）
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class day20_09 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("xxx");
FileOutputStream fos = new FileOutputStream("copy2"); //byte[] arr = new byte[2];
byte[] arr = new byte[1024 * 8]; //标准数组
int len;
while((len = fis.read(arr)) != -1) { //第一次获取到文件上的a和b
fos.write(arr,0,len);
}
fis.close();
fos.close();
}
}
20.11 IO流（BufferedInputStream和BufferedOutputStream拷贝）
1.缓冲思想
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快，这也是加入了缓冲区效果，
Java本身在设计的时候就加入这样的思考，所以提供了字节缓冲区流
2.BufferedInputStream
BufferedInputStream内置了一个缓冲区（数组）
从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性读取8192个，存在缓冲区中返回给程序。
程序再次读取时，就不用找文件了，直接从缓冲区中获取；直到所有的都被读取过了，才重新开始
3.BufferedOutputStream
BufferedOutputStream也内置了一个缓冲区（数组），
程序向流中写出数据时，先写到缓冲区中，直到缓冲区写满，BufferedOutputStream才会把缓冲区的数据一次性写到文件里
4.拷贝的代码
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class day20_10 {
/**
* @param args
* @throws IOException
*/
public static <BufferInputStream> void main(String[] args) throws IOException {
/*FileInputStream fis = new FileInputStream("02.jpg"); //输入流对象，关联02.jpg
FileOutputStream fos = new FileOutputStream("copy2.jpg"); //输出流对象，关联copy2.jpg BufferedInputStream bis = new BufferedInputStream(fis); //创建缓冲区对象，对输入流进行包装
BufferedOutputStream bos = new BufferedOutputStream(fos);
*/ BufferedInputStream bis = new BufferedInputStream( new FileInputStream("02.jpg")); //创建缓冲区对象，对输入流进行包装
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy2.jpg")); int b;
while((b = bis.read()) != -1){
bos.write(b);
}
bis.close();
bos.close();
}
}
5.小数组的读写和带有Buffer的哪个读写gengk
定义小数组如果是8192个字节大小和Buffer比较的话
定义小数组会略胜一筹，因为读和写是一个数组，Buffer操作的是两个数组
20.12 IO流（flush和close方法的区别）
flush() 刷新缓冲区的，刷新后可以再次写出
close() 关闭释放流资源
20.13 IO流（字节流读取中文）
1.字节流读取中文：可能会读取到半个中文，造创乱码
2.字节流写出中文：字节流直接操作的字节，所以写出中文必须将字符串转换为字节数组
20.14 IO流（流的标准处理异常代码）
try finally
20.15 IO流（流的标准处理异常代码）
20.16 IO流（图片加密）
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class day20_16 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream( new FileInputStream("02.jpg")); //创建缓冲区对象，对输入流进行包装
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy3.jpg")); /*运行此程序 生成照片打不开， 加密。关闭上面两行，打开下面两行 再次运行，解密
BufferedInputStream bis = new BufferedInputStream( new FileInputStream("copy3.jpg")); //
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy4.jpg"));*/
int b;
while((b = bis.read()) != -1){
bos.write(b^123);
}
bis.close();
bos.close();
} }
加密
20.17 IO流（拷贝文件）
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class day20_17 {
/**
* 分析：
* 1.创建键盘录入对象
* 2.定义方法对键盘录入的路径进行判断，是文件才返回
* 3.在主方法中结束该文件
* 4.读写该文件x
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File file = getFile();
BufferedInputStream bis = new BufferedInputStream( new FileInputStream(file)); //创建缓冲区对象，对输入流进行包装
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));
int b;
while((b = bis.read()) != -1){
bos.write(b^123);
}
bis.close();
bos.close();
}
/*定义一个方法获取键盘录入的路径，并封装成File
* 1.返回值类型File
* 2.参数列表无
* */
public static File getFile(){
Scanner sc =new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入一个文件的路径：");
while(true){
String line = sc.nextLine(); //接收键盘录入的路径
File file = new File(line);
if(!file.exists()){
System.out.println("录入的文件路径是：");
}else if(file.isDirectory()){
System.out.println("您录入的是文件夹路劲，请重新录入:");
}else{
return file;
}
}
}
}
20.18 IO流（录入数据拷贝到文件）
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class day20_18 {
/**
* 录入数据拷贝到文件
* 分析：
* 1.创建键盘录入对象
* 2.创建输出流对象，关联text.txt
* 3.定义无限循环
* 4.遇到quit退出循环
* 5.如果不quit，将内容写出
* 6.关闭流
*输出： 123
123
quit * @throws IOException
*/
public static void main(String[] args) throws IOException {
Scanner sc =new Scanner(System.in); //创建键盘录入对象
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("请输入一个文件的路径：");
while(true){
String line = sc.nextLine(); //接收键盘录入的路径
if("quit".equals(line)){
break;
}
fos.write(line.getBytes()); //字符串写出必须转换成字节数组
fos.write("\r\n".getBytes());
}
fos.close();
}
}
20.19 IO流（IO流概述及分类）
20.20 IO流（IO流概述及分类）