目录：

IO流

IO流概述及其分类

A:IO流概述
	IO流用来处理设备之间的数据传输
	Java对数据的操作是通过流的方式
	Java用于操作流的对象都在IO包中 java.io
B:IO流分类
	a:按照数据流向 站在内存角度
		输入流	读入数据
		输出流	写出数据
	b:按照数据类型
		字节流 可以读写任何类型的文件 比如音频 视频  文本文件
		字符流 只能读写文本文件
		什么情况下使用哪种流呢?
		如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
		如果你什么都不知道，就用字节流

IO流基类概述和FileOutputStream的构造方法

A:IO流基类概述
	a:字节流的抽象基类：
		InputStream ，OutputStream。
	b:字符流的抽象基类：
		Reader ， Writer。
	注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
	如：InputStream的子类FileInputStream。
	如：Reader的子类FileReader。
B:FileOutputStream的构造方法
	由一个案例引出使用IO流写数据，由于字节流先出现就先学习字节输出流基类OutputStream，
	使用具体子类FileOutputStream

	Io流的分类:
	- (1): 按照流向进行划分
 		输入流
 		输出流
- (2): 按照操作的数据类型进行划分
- 字节流
- 字节输入流	InputStream		读
- 字节输出流	OutputStream	写
- 字符流
- 字符输入流 	Reader			读
- 字符输出流	Writer			写
- 
- 需求:	往一个文本文件中写一串数据 Hello,IO
- 分析:
- a: 我们现在操作的是文本文件,所有按照我们的想法,我们优先现在字符流,但是字节流是优先于字符流. 所以先使用字节流
- b: 因为我们要写数据,所以我们应该使用字节流中输出流	OutputStream
- 我们发现OutputStream是一个抽象类,我们不能对其进行直接实例化,而我们需要使用子类对其进行实例化.那么选择哪个子类呢?
- 我们现在操作的是文件所以我们选择的是FileOutputStream

FileOutputStream写出数据

A: 构造方法
	FileOutputStream(File file)
	FileOutputStream(String name)
B:案例演示
	FileOutputStream写出数据
	public static void main(String[] args) throws IOException {
        //异常的处理 File
        //I/O InputStream 输入流  OutPutStream 输出流  处理设备之间的一个数据传输
        //流按照流向分：分为 输入流和输出流
        //按照读写文件的类型分：分为字节流（可以读写任意类型的文件）和字符流（读写文本文件）
        //字节流：
       //文件输入输出 流
        //文件输出流：写出数据
        //
        //FileOutputStream(File file)
        //创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

        //FileOutputStream(String name)
        //创建一个向具有指定名称的文件中写入数据的输出文件流。
        File file = new File("a.txt");
        //file.createNewFile();
        //输入流，所关联的文件，如果该文件不存在 ，那么会自动帮你创建
        FileOutputStream out = new FileOutputStream(file);

        FileOutputStream fileOutputStream = new FileOutputStream("b.txt");
        //流用完之后必须释放资源
        out.close();
        fileOutputStream.close();

    }
	
	注意事项：
		创建字节输出流对象了做了几件事情?
		a:调用系统资源创建a.txt文件
	  	b:创建了一个fos对象
	  	c:把fos对象指向这个文件
		为什么一定要close()?

		a: 通知系统释放关于管理a.txt文件的资源
		b: 让Io流对象变成垃圾,等待垃圾回收器对其回收

FileOutputStream的三个write()方法

A:FileOutputStream的三个write()方法
	public void write(int b):写一个字节  超过一个字节 砍掉前面的字节
	public void write(byte[] b):写一个字节数组
	public void write(byte[] b,int off,int len):写一个字节数组的一部分
B:案例演示:	FileOutputStream的三个write()方法
public static void main(String[] args) throws IOException {
        //通过文件输出流，往他所关联的件中，写出数据
        FileOutputStream out = new FileOutputStream("a.txt");
        //写数据
        out.write(97); //一次写入一个字节
        out.write(98);
        out.write(99);
        out.write(100);
        out.write(300); //超过了一个字节，会丢弃掉多余字节
        byte[] bytes = {101, 102, 103, 104};
        out.write(bytes);//一次写入一个字节数组
        out.write(bytes, 2, 2);//一次写入字节数组的一部分，从2索引开始，写2个字节
        String str = "杨家有女初长成,养在深闺人未识";
        //UTF-8 编码 一个汉字占三个字节
        byte[] bytes1 = str.getBytes();//将一个字符串，转换成字节数组
        out.write(bytes1);
        out.close();
    }

FileOutputStream写出数据实现换行和追加写入

A:案例演示:	FileOutputStream写出数据如何实现数据的换行

		 windows下的换行符只用是 \r\n
		  Linux		\n
 		  Mac		\r

 eclipse/IDEA 中的记事本软件以及editplus这样的第三种软件都做了平台的兼容

public static void main(String[] args) throws IOException {
FileOutputStream out = new FileOutputStream(“b.txt”);
out.write(“回眸一笑百媚生,六宫粉黛无颜色”.getBytes());
out.write("\r\n".getBytes());//写入一个回车换行符
out.write(“回眸一笑百媚生,六宫粉黛无颜色”.getBytes());
out.write("\r\n".getBytes());//写入一个回车换行符
out.write(“回眸一笑百媚生,六宫粉黛无颜色”.getBytes());
out.write("\r\n".getBytes());//写入一个回车换行符
out.write(“回眸一笑百媚生,六宫粉黛无颜色”.getBytes());

    //各个平台的换行符，都不一样
    //windows 平台 \r\n
    //Linux		\n
    //Mac		\r
    //流用完之后，必须释放资源
    out.close(); //关闭流
}

B:案例演示:	FileOutputStream写出数据如何实现数据的追加写入

public static void main(String[] args) throws IOException {

        //注意事项：
        //创建字节输出流对象了做了几件事情 ?
        //        a : 调用系统资源创建a.txt文件
        //b:
        //创建了一个fos对象
        //c:
        //把fos对象指向这个文件
        //为什么一定要close() ?
        //
        //        a : 通知系统释放关于管理a.txt文件的资源
        //b:
        //让Io流对象变成垃圾, 等待垃圾回收器对其回收

        //FileOutputStream(File file, boolean append)
        //创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
        //
        //
        //FileOutputStream(String name, boolean append)
        //创建一个向具有指定 name 的文件中写入数据的输出文件流。
        //参数2：true 代表追加写入，false 不追加
        FileOutputStream out = new FileOutputStream("c.txt",true);
        out.write("回眸一笑百媚生,六宫粉黛无颜色".getBytes());
        out.write("\r\n".getBytes());//写入一个回车换行符
        out.write("回眸一笑百媚生,六宫粉黛无颜色".getBytes());
        //释放资源
        out.close();
    }

FileOutputStream写出数据加入异常处理

A:案例演示:FileOutputStream写出数据加入异常处理
public static void main(String[] args) throws IOException {

        //
        //FileInputStream(String name)
        //通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
        //
        //FileInputStream(File file)
        //通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
        //文件输入流
        File file = new File("e.txt");
        //输入流所关联的文件，如果不存在，就会报错
        FileInputStream in = new FileInputStream(file);

        FileInputStream in2 = new FileInputStream("e.txt");


    }

FileInputStream读取数据一次一个字节

A:案例演示:	int read():一次读取一个字节
                如果没有数据返回的就是-1
public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("e.txt");
        //读取文件中的数据
        int len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len);
        len = in.read();//一次读取一个字节
        System.out.println(len); //读取不到返回-1

        in.close();//记得流用完之后，释放资源
    }

字节流复制文本文件

A:案例演示:	字节流一次读写一个字节复制文本文件

 分析:
 - a: 创建字节输入流对象和字节输出流对象
- b: 频繁的读写操作
- c: 释放资源
public static void main(String[] args) throws IOException {
        //我们可以使用文件输入输出流，进行文件的复制
        //方式：读取一个字节，写入一个字节来复制
        FileInputStream in = new FileInputStream("MyTest.java");
        FileOutputStream out = new FileOutputStream("E:\\MyTest.java");
        //循环的读写
        //定义一个变量
        int len=0; //表示读取到的字节
        while ((len=in.read())!=-1){
            out.write(len);
            out.flush();//刷新
        }
        //释放资源
        in.close();
        out.close();
    }

​

字节流复制MP3

A:案例演示:	字节流一次读写一个字节复制MP3

public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("demo.mp3");
        FileOutputStream out = new FileOutputStream("E:\\曾经的你.mp3");
        int len=0;
        long start = System.currentTimeMillis();
        while ((len=in.read())!=-1){
           out.write(len);
           out.flush();
        }
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"毫秒");
        in.close();
        out.close();
    }

FileInputStream读取数据一次一个字节数组

A:案例演示:	int read(byte[] b):一次读取一个字节数组
		返回的int类型的值表示的意思是读取到的字节的个数,如果没有数据了就返回-1
public static void main(String[] args) throws IOException {
        //很显然，一次读写一个字节的方式 ，复制文件，效率太低
        //我们可以一次读写一个字节数组的方式来复制文件
        FileInputStream in = new FileInputStream("demo.mp3");
        FileOutputStream out = new FileOutputStream("E:\\曾经的你2.mp3");
        //定义一个字节数组，充当缓冲区
        byte[] bytes = new byte[1024 * 8];
        int len = 0;//记录每次读取到的有效字节个数
        long start = System.currentTimeMillis();
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
        }
        long end = System.currentTimeMillis();
        System.out.println((end - start) + "毫秒");
        in.close();
        out.close();
    }

FileInputStream读取数据的两种方式比较图解

A:画图演示:	FileInputStream读取数据的两种方式比较图解

BufferedOutputStream写出数据

A:缓冲思想
	字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
	这是加入了数组这样的缓冲区效果，java本身在设计的时候，
	也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
B:BufferedOutputStream的构造方法
	查看API
	BufferedOutputStream(OutputStream out)
C:案例演示
	BufferedOutputStream写出数据

20.21_IO流(BufferedInputStream读取数据)(掌握)

A:BufferedInputStream的构造方法
	查看API
	BufferedInputStream(InputStream in)
B:案例演示
	BufferedInputStream读取数据

BufferedInputStream bfr = new BufferedInputStream(new FileInputStream("demo.mp3"));
        BufferedOutputStream bfw = new BufferedOutputStream(new FileOutputStream("demo2.mp3"));
        //读取一个字节写入一个字节
        int len=0;
        byte[] bytes = new byte[1024 * 8];
        while ((len=bfr.read(bytes))!=-1){
            bfw.write(bytes,0,len);
        }
        bfr.close();
        bfw.close();