一、IO概述

1．什么是IO流?
存储和读取数据的解决方案l: inputo: output流∶像水流一样传输数据

2.IO流的作用?
用于读写数据（本地文件，网络)

3.IO流按照流向可以分类哪两种流?
输出流:程序   - >    文件
输入流:文件   - >    程序
4.IO流按照操作文件的类型可以分类哪两种流?
字节流:可以操作所有类型的文件
字符流:只能操作纯文本文件

5．什么是纯文本文件?
用windows系统自带的记事本打开并且能读懂的文件

txt文件，md文件，xml文件，lrc文件等

顶级父类们：

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

二、字节流

1. 一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

• public abstract void write(int b) ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

构造方法

• public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

• public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

• 构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {public static void main(String[] args) {// 使用File对象创建流对象File file = new File("a.txt");FileOutputStream fos = new FileOutputStream(file);// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("b.txt");}
}

字节输出流的细节：
              1.创建字节输出流对象
                    细节1：参数是字符串表示的路径或者是File对象都是可以的
                    细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
                    细节3：如果文件已经存在，则会清空文件
              2.写数据
                    细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
                    ‘9’
                    ‘7’
              3.释放资源
                    每次使用完流之后都要释放资源

FileoutputStream书写细节
创建字节输出流对象
细节1:参数是字符串表示的路径或者File对象都是可以的
细节2∶如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。细节3∶如果文件已经存在，则会清空文件
写数据
细节: write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCI上对应的字符
③释放资源
细节:每次使用完流之后都要释放资源

写出字节数据

write(int b) 方法，每次可以写出一个字节数据

void write(int b)                                       一次写一个字节数据
void write(byte[] b)                                  一次写一个字节数组数据
void write(byte[] b, int off, int len)            一次写一个字节数组的部分数据

           参数一：
                数组
           参数二：
                起始索引  0
           参数三：
                个数      3

//1.创建对象FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.写出数据
//fos.write(97); // a
//fos.write(98); // b
byte[] bytes = {97, 98, 99, 100, 101};/* fos.write(bytes);*/fos.write(bytes,1,2);// b c//3.释放资源
fos.close();

换行写

换行写：
                再次写出一个换行符就可以了
                windows： \r\n
                Linux:    \n
                Mac:      \r

 细节：
                在windows操作系统当中，java对回车换行进行了优化。
                虽然完整的是\r\n，但是我们写其中一个\r或者\n，
                java也可以实现换行，因为java在底层会补全。

建议：
                不要省略，还是写全了。

数据追加续写

如果想要续写，打开续写开关即可
                开关位置：创建对象的第二个参数
                默认false：表示关闭续写，此时创建对象会清空文件
                手动传递true：表示打开续写，此时创建对象不会清空文件

  //1.创建对象FileOutputStream fos = new FileOutputStream("myio\\a.txt",true);//2.写出数据String str = "kankelaoyezuishuai";byte[] bytes1 = str.getBytes();fos.write(bytes1);//再次写出一个换行符就可以了String wrap = "\r\n";byte[] bytes2 = wrap.getBytes();fos.write(bytes2);String str2 = "666";byte[] bytes3 = str2.getBytes();fos.write(bytes3);//3.释放资源fos.close();

小结：

1. FileOutputStream的作用
可以把程序中的数据写到本地文件上，是字节流的基本流。
2．书写步骤
创建对象，写出数据，释放资源
3．三步操作的细节
创建对象:文件存在、文件不存在、追加写入
写出数据:写出整数、写出字节数组、换行写
释放资源:关闭通道

字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

• public abstract int read()： 从输入流读取数据的下一个字节。

• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

实现步骤：
         *       创建对象
         *       读取数据
         *       释放资源

FilelnputStream书写细节
创建字节输入流对象
细节1∶如果文件不存在，就直接报错。

Java为什么会这么设计呢？
                    输出流：不存在，创建
                        把数据写到文件当中

                    输入流：不存在，而是报错呢？
                        因为创建出来的文件是没有数据的，没有任何意义。
                        所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。

                    程序中最重要的是：数据。

读取数据
细节1:一次读一个字节，读出来的是数据在ASCII上对应的数字

细节2:读到文件末尾了, read方法返回-1。
③释放资源
细节1:每次使用完流必须要释放资源。

读取字节数据

1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

   public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象FileInputStream fis = new FileInputStream("read.txt");// 定义变量，保存数据int b ；// 循环读取while ((b = fis.read())!=-1) {System.out.print((char)b);}// 关闭资源fis.close();}
   }
   输出结果：
   abcde

   小贴士：

虽然读取了一个字节，但是会自动提升为int类型。

流操作完毕后，必须释放系统资源，调用close方法，千万记得

2.使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public class ByteStreamDemo5 {public static void main(String[] args) throws IOException {/*public int read(byte[] buffer)      一次读一个字节数组数据*///1.创建对象FileInputStream fis = new FileInputStream("myio\\a.txt");//2.读取数据byte[] bytes = new byte[2];//一次读取多个字节数据，具体读多少，跟数组的长度有关//返回值：本次读取到了多少个字节数据int len1 = fis.read(bytes);System.out.println(len1);//2String str1 = new String(bytes,0,len1);System.out.println(str1);int len2 = fis.read(bytes);System.out.println(len2);//2String str2 = new String(bytes,0,len2);System.out.println(str2);int len3 = fis.read(bytes);System.out.println(len3);// 1String str3 = new String(bytes,0,len3);System.out.println(str3);// ed//3.释放资源fis.close();}
}

复制文件

public class ByteStreamDemo6 {public static void main(String[] args) throws IOException {/**   练习：*       文件拷贝*       把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。** */long start = System.currentTimeMillis();//1.创建对象FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while((len = fis.read(bytes)) != -1){fos.write(bytes,0,len);}//3.释放资源fos.close();fis.close();long end = System.currentTimeMillis();System.out.println(end - start);}
}

流的关闭原则：先开后关，后开先关。

三、IO异常的处理

JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分，代码使用演示：

package com.itheima.mybytestream2;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class ByteStreamDemo7 {public static void main(String[] args) {/***    利用try...catch...finally捕获拷贝文件中代码出现的异常*** *///1.创建对象FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("D:\\itheima\\movie.mp4");fos = new FileOutputStream("myio\\copy.mp4");//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while((len = fis.read(bytes)) != -1){fos.write(bytes,0,len);}} catch (IOException e) {//e.printStackTrace();} finally {//3.释放资源if(fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

try (创建流对象语句，如果多个,使用';'隔开) {// 读写数据
} catch (IOException e) {e.printStackTrace();
}

使用演示：

package com.itheima.mybytestream2;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class ByteStreamDemo8 {public static void main(String[] args) {/***    JDK7:IO流中捕获异常的写法**      try后面的小括号中写创建对象的代码，*          注意：只有实现了AutoCloseable接口的类，才能在小括号中创建对象。*     try(){**     }catch(){**     }** */try (FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4")) {//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}}
}

JDK9的改进(扩展知识点了解内容)

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

改进前格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式：创建新的变量保存
try (Resource r1 = resource1;Resource r2 = resource2) {// 使用对象
}

改进后格式：

package com.itheima.mybytestream2;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class ByteStreamDemo9 {public static void main(String[] args) throws FileNotFoundException {/***    JDK9:IO流中捕获异常的写法*** */FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");try (fis;fos) {//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}}
}

四、字符集

1．在计算机中，任意数据都是以二进制的形式来存储的
2．计算机中最小的存储单元是一个字节
3. ASCII字符集中，一个英文占一个字节
4．简体中文版windows，默认使用GBK字符集
5.GBK字符集完全兼容ASCII字符集
        一个英文占一个字节，二进制第一位是0
        一个中文占两个字节，二进制高位字节的第一位是1

1. Unicode字符集的UTF-8编码格式
一个英文占一个字节，二进制第一位是0，转成十进制是正数
一个中文占三个字节，二进制第一位是1，第一个字节转成十进制是负数

为什么会产生乱码？

1，不要用字节流读取文本文件
2，编码解码时使用同一个码表，同一个编码方式

Java中编码的方法
            public byte[] getBytes()                        使用默认方式进行编码
            public byte[] getBytes(String charsetName)      使用指定方式进行编码

        Java中解码的方法
            String(byte[] bytes)                            使用默认方式进行解码
            String(byte[] bytes, String charsetName)        使用指定方式进行解码

//1.编码String str = "ai你哟";byte[] bytes1 = str.getBytes();System.out.println(Arrays.toString(bytes1));byte[] bytes2 = str.getBytes("GBK");System.out.println(Arrays.toString(bytes2));//2.解码String str2 = new String(bytes1);System.out.println(str2);String str3 = new String(bytes1,"GBK");System.out.println(str3);String str4=new String(bytes2,"GBK");System.out.println(str4);
结果为：
[97, 105, -28, -67, -96, -27, -109, -97]
[97, 105, -60, -29, -45, -76]
ai你哟
ai浣犲摕
ai你哟

五、字符流

        字符流的底层其实就是字节流
        字符流=字节流+字符集
特点：
输入流:一次读一个字节，遇到中文时，一次读多个字节
输出流:底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中

使用场景：

对纯文本文档进行读写操作

IO流体系：

1字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。

• public int read()： 从输入流读取一个字符。

• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

2 FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

   idea中UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

1创建字符输入流对象

2读取数据

成员方法	说明
public int read()	读取数据，读到末尾返回-1
public  read(char[ ] buffer)	读取多个数据，读到末尾返回-1

细节1:按字节进行读取，遇到中文，一次读多个字节，读取后解码，返回一个整数

细节2:读到文件末尾了，read方法返回-1。

3.释放资源

Public int close()                释放资源、关流
 

import java.io.FileReader;
import java.io.IOException;public class CharStreamDemo1 {public static void main(String[] args) throws IOException {/*第一步：创建对象public FileReader(File file)        创建字符输入流关联本地文件public FileReader(String pathname)  创建字符输入流关联本地文件第二步：读取数据public int read()                   读取数据，读到末尾返回-1public int read(char[] buffer)      读取多个数据，读到末尾返回-1第三步：释放资源public void close()                 释放资源/关流*///1.创建对象并关联本地文件FileReader fr = new FileReader("myio\\a.txt");//2.读取数据 read()//字符流的底层也是字节流，默认也是一个字节一个字节的读取的。//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节//read（）细节：//1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个//2.在读取之后，方法的底层还会进行解码并转成十进制。//  最终把这个十进制作为返回值//  这个十进制的数据也表示在字符集上的数字//  英文：文件里面二进制数据 0110 0001//          read方法进行读取，解码并转成十进制97//  中文：文件里面的二进制数据 11100110 10110001 10001001//          read方法进行读取，解码并转成十进制27721// 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了int ch;while((ch = fr.read()) != -1){System.out.print((char)ch);}//3.释放资源fr.close();}
}

3 字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

• void write(int c) 写入单个字符。

• void write(char[] cbuf)写入字符数组。

• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

• void write(String str)写入字符串。

• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

• void flush()刷新该流的缓冲。

• void close() 关闭此流，但要先刷新它。

• 4 FileWriter类

  java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

• 

  构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。

• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

第一步：创建对象
public FileWriter(File file)                                                 创建字符输出流关联本地文件
public FileWriter(String pathname)                                  创建字符输出流关联本地文件
public FileWriter(File file,  boolean append)                    创建字符输出流关联本地文件，续写
public FileWriter(String pathname,  boolean append)     创建字符输出流关联本地文件，续写

细节1:参数是字符串表示的路径或者File对象都是可以的
细节2:如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的细节3:如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关
 

第二步：读取数据
void write(int c)                                                              写出一个字符
void write(String str)                                                      写出一个字符串
void write(String str, int off, int len)                                写出一个字符串的一部分
void write(char[] cbuf)                                                    写出一个字符数组
void write(char[] cbuf, int off, int len)                              写出字符数组的一部分

第三步：释放资源
public void close()                                                        释放资源/关流

字符流原理解析

输入：

1.创建字符输入流对象
底层:关联文件，并创建缓冲区（长度为8192的字节数组)
2读取数据
底层:1.判断缓冲区中是否有数据可以读取
        2.缓冲区没有数据:就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲t
           如果文件中也没有数据了，返回-1
        3.缓冲区有数据:就从缓冲区中读取。
           空参的read方法:一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回有参的read方法:把读取字节，解码，强转三步合并了，强转之后的字符放到数组中

输出：

flush和close方法

成员方法	说明
public void flush()	将缓冲区中的数据，刷新到本地文件中
public void close()	释放资源/关流

flush刷新:刷新之后，还可以继续往文件中写出数据
close关流:断开通道，无法再往文件中写出数据
 

练习一、拷贝文件夹

package com.itheima.mytest;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test01 {public static void main(String[] args) throws IOException {//拷贝一个文件夹，考虑子文件夹//1.创建对象表示数据源File src = new File("D:\\aaa\\src");//2.创建对象表示目的地File dest = new File("D:\\aaa\\dest");//3.调用方法开始拷贝copydir(src,dest);}/** 作用：拷贝文件夹* 参数一：数据源* 参数二：目的地** */private static void copydir(File src, File dest) throws IOException {dest.mkdirs();//递归//1.进入数据源File[] files = src.listFiles();//2.遍历数组for (File file : files) {if(file.isFile()){//3.判断文件，拷贝FileInputStream fis = new FileInputStream(file);FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));byte[] bytes = new byte[1024];int len;while((len = fis.read(bytes)) != -1){fos.write(bytes,0,len);}fos.close();fis.close();}else {//4.判断文件夹，递归copydir(file, new File(dest,file.getName()));}}}
}

练习二、加密和解密

package com.itheima.mytest;import java.io.*;public class Test02 {public static void main(String[] args) throws IOException {/*为了保证文件的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。加密原理：对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中。解密原理：读取加密之后的文件，按照加密的规则反向操作，变成原始文件。^ : 异或两边相同：false两边不同：true0：false1：true100:110010010: 10101100100^ 0001010__________1101110^ 0001010__________1100100*/}public static void encryptionAndReduction(File src, File dest) throws IOException {FileInputStream fis = new FileInputStream(src);FileOutputStream fos = new FileOutputStream(dest);int b;while ((b = fis.read()) != -1) {fos.write(b ^ 2);}//4.释放资源fos.close();fis.close();}}

练习三、修改文件中的数据

package com.itheima.mytest;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;public class Test03 {public static void main(String[] args) throws IOException {/*文本文件中有以下的数据：2-1-9-4-7-8将文件中的数据进行排序，变成以下的数据：1-2-4-7-8-9*///1.读取数据FileReader fr = new FileReader("myio\\a.txt");StringBuilder sb = new StringBuilder();int ch;while((ch = fr.read()) != -1){sb.append((char)ch);}fr.close();System.out.println(sb);//2.排序String str = sb.toString();String[] arrStr = str.split("-");//2-1-9-4-7-8ArrayList<Integer> list = new ArrayList<>();for (String s : arrStr) {int i = Integer.parseInt(s);list.add(i);}Collections.sort(list);System.out.println(list);//3.写出FileWriter fw = new FileWriter("myio\\a.txt");for (int i = 0; i < list.size(); i++) {if(i == list.size() - 1){fw.write(list.get(i) + "");}else{fw.write(list.get(i) + "-");}}fw.close();}
}

package com.itheima.mytest;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;public class Test04 {public static void main(String[] args) throws IOException {/*文本文件中有以下的数据：2-1-9-4-7-8将文件中的数据进行排序，变成以下的数据：1-2-4-7-8-9细节1：文件中的数据不要换行细节2:bom头*///1.读取数据FileReader fr = new FileReader("myio\\a.txt");StringBuilder sb = new StringBuilder();int ch;while((ch = fr.read()) != -1){sb.append((char)ch);}fr.close();System.out.println(sb);//2.排序Integer[] arr = Arrays.stream(sb.toString().split("-")).map(Integer::parseInt).sorted().toArray(Integer[]::new);//3.写出FileWriter fw = new FileWriter("myio\\a.txt");String s = Arrays.toString(arr).replace(", ","-");String result = s.substring(1, s.length() - 1);fw.write(result);fw.close();}
}