IO流

概述

        生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了`ctrl+s` ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

        我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为`输入input` 和`输出output` ，即流向内存是输入流，流出内存的输出流。

        Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据

IO的分类

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从`其他设备`上读取到`内存`中的流。

程序 - > 文件

输出流 ：把数据从`内存` 中写出到`其他设备`上的流。

文件 - > 程序

格局数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。

字符流 ：以字符为单位，读写数据的流。

注意：

纯文本文件：能用Windows自带的记事本打开能读懂的文件

如md和txt

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");}
}

 写出数据的三种方法

写出字节数据 ： write(int b) 方法

代码演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 写出数据fos.write(97); // 写出第1个字节fos.write(98); // 写出第2个字节fos.write(99); // 写出第3个字节// 关闭资源fos.close();}
}
输出结果：
abc

1.创建字节输出流对象细节：

        细节1：参数是字符串表示的路径或者是file对象都是可以的

        细节2：如果文件不存在会创建一个新的文件，但是要保障父级路径是存在的

        细节3：如果文件已经存在，则会清空文件

2.写数据：

        细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符

3.释放资源

        每次使用完流之后都要释放资源（不然文件一直处于占用状态）

写出字节数组：write(byte[] b)

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 字符串转换为字节数组byte[] b = "黑马程序员".getBytes();// 写出字节数组数据fos.write(b);// 关闭资源fos.close();}
}
输出结果：
黑马程序员

写出指定长度字节数组：write(byte[] b, int off, int len)

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 字符串转换为字节数组byte[] b = "abcde".getBytes();// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。fos.write(b,2,2);// 关闭资源fos.close();}
}
输出结果：
cd

数据追加续写

        经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

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

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

        这两个构造方法，参数中都需要传入一个boolean类型的值，`true` 表示追加数据，`false` 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，

代码演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt"，true);     // 字符串转换为字节数组byte[] b = "abcde".getBytes();// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。fos.write(b);// 关闭资源fos.close();}
}
文件操作前：cd
文件操作后：cdabcde

写出换行

换行符：

        Windows：\r\n

        Linux系统：\n

        Mac: \r

细节：

        在windows系统中，Java对回车换行进行了优化

        虽然完整的是\r\n，但是我们写其中一个\r或者\n,

        java也可以实现换行，因为Java在底层会自动补全

建议：

        不要省略，还是写全

代码演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");  // 定义字节数组byte[] words = {97,98,99,100,101};// 遍历数组for (int i = 0; i < words.length; i++) {// 写出一个字节fos.write(words[i]);// 写出一个换行, 换行符号转成数组写出fos.write("\r\n".getBytes());}// 关闭资源fos.close();}
}输出结果：
a
b
c
d
e

FileInputStream类

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

构造方法：        

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

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

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

代码演示：

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

读取字节数据：

字节输入流的细节：

1.创建字节输入流对象

        细节1：如果文件不存在，就直接报错

        Java为什么会这么设计呢？

        输出流：不存在，创建

                把数据写到文件当中

        

        输入流：不存在，则是报错呢？

                读取的时候，数据在文件当中

                所以Java就没有这种无意义的逻辑，文件不存在直接报错

         程序中最重要的是：数据

        

2.写数据

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

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

3.释放资源

        细节：每次使用完流之后都要释放资源

read方法

        读一次数据，就移动一次指针指向下一个元素

代码演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象FileInputStream fis = new FileInputStream("read.txt");// 读取数据，返回一个字节int read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);// 读取到末尾,返回-1read = fis.read();System.out.println( read);// 关闭资源fis.close();}
}
输出结果：
a
b
c
d
e
-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.println((char)b);}// 关闭资源fis.close();}
}
输出结果：
a
b
c
d
e

> 小贴士：

>

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

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

使用字节数组读取：read(byte[] b)

        每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回`-1`

代码演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象.FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde// 定义变量，作为有效个数int len ；// 定义字节数组，作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {// 每次读取后,把数组变成字符串打印System.out.println(new String(b));}// 关闭资源fis.close();}
}输出结果：
ab
cd
ed

        错误数据`d`，是由于最后一次读取时，只读取一个字节`e`，数组中，上次读取的数据没有被完全替换，所以要通过`len` ，获取有效的字节，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象.FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde// 定义变量，作为有效个数int len ；// 定义字节数组，作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {// 每次读取后,把数组的有效字节部分，变成字符串打印System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数}// 关闭资源fis.close();}
}输出结果：
ab
cd
e

> 小贴士：

>

> 使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

练习：小文件拷贝

        FileOutputStream fos = new FileOutputStream("a.txt");FileInputStream fis = new FileInputStream("b.txt");byte[] bytes = new byte[1024];int len;long start = System.currentTimeMillis();while((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}fos.close();fis.close();//统计拷贝时间long end = System.currentTimeMillis();System.out.println("拷贝时间：" + (end - start) + "ms");

> 小贴士：

>

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

字符集

字符集（GBK）

字符集（Unicode）

为什么会有乱码？

原因1：

        读取数据时未读完整个汉字

原因2：

        编码和解码时的方式不一样

如何不产生乱码？

1、不要用字节流读取文本文件

2、编码解码时使用同一个码表，同一个编码方式

扩展：

疑问：字节流读取中文会乱码，但是为什么拷贝不会乱码呢？

因为拷贝时，数据源没有丢失，用记事本（采用对应的解码方式）打开不会出现乱码

Java中的编码和解码

字符流

字符流的底层其实就是字节流

字符流=字节流+字符集

特点：

        输入流：一次读一个字节。遇到中文时，一次读多个字节

        输出流：底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中

使用场景

        对于出纯文本文件进行读写操作

FileReader

无参read（）代码演示 

        FileReader fileReader = new FileReader("a.txt");//读取数据read（）//字符流的底层也是字节流，默认也是一个字节一个字节的读取的//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读3个字节//read（）细节//在读取之后，方法的底层还会进行解码并转成十进制//  最终把这个十进制作为返回值//  这个十进制的数据也表示在字符集上的数字//  英文：文件里面二进制数据  0110 0001//          read（）方法进行读取，转成十进制97//  中文：文件里面二进制数据  11100110 10110001 10001001//          read（）方法进行读取，转成十进制27721//  我想看到中文汉字，就是把这些十进制数据，再进行强转就行了int ch = 0;while ((ch = fileReader.read()) != -1) {System.out.print((char)ch);}fileReader.close();

有参read（）代码演示

        FileReader fileReader = new FileReader("a.txt");int len;char[] chars = new char[1024];while((len=fileReader.read(chars))!=-1){System.out.println(new String(chars,0,len));}fileReader.close();

注意：

        无参的ch表示拿到的字符的十进制

        有参的len表示读取到字符的个数

FileWriter

基本写出数据

`write(int b)` 方法，每次可以写出一个字符数据，代码使用演示：

        FileWriter fw = new FileWriter("fw.txt");     // 写出数据fw.write(97); // 写出第1个字符fw.write('b'); // 写出第2个字符fw.write('C'); // 写出第3个字符fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。/*【注意】关闭资源时,与FileOutputStream不同。如果不关闭,数据只是保存到缓冲区，并未保存到文件。*/// fw.close();输出结果：
abC田

> 小贴士：

>

> 1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。

> 2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要`flush` 方法了。

* `flush` ：刷新缓冲区，流对象可以继续使用。

* `close `:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");// 写出数据，通过flushfw.write('刷'); // 写出第1个字符fw.flush();fw.write('新'); // 继续写出第2个字符，写出成功fw.flush();// 写出数据，通过closefw.write('关'); // 写出第1个字符fw.close();fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closedfw.close();}
}

> 小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

1. **写出字符数组** ：`write(char[] cbuf)` 和 `write(char[] cbuf, int off, int len)` ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     // 字符串转换为字节数组char[] chars = "黑马程序员".toCharArray();// 写出字符数组fw.write(chars); // 黑马程序员// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。fw.write(b,2,2); // 程序// 关闭资源fos.close();}
}

2. **写出字符串**：`write(String str)` 和 `write(String str, int off, int len)` ，每次可以写出字符串中的数据，更为方便，代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     // 字符串String msg = "黑马程序员";// 写出字符数组fw.write(msg); //黑马程序员// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。fw.write(msg,2,2);	// 程序// 关闭资源fos.close();}
}

续写和换行

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象，可以续写数据FileWriter fw = new FileWriter("fw.txt"，true);     // 写出字符串fw.write("黑马");// 写出换行fw.write("\r\n");// 写出字符串fw.write("程序员");// 关闭资源fw.close();}
}
输出结果:
黑马
程序员

> 小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

>

> 当我们单纯读或者写文本文件时  使用字符流 其他情况使用字节流

字符流综合练习

练习1：拷贝

        需求：拷贝一个文件夹，考虑子文件夹

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()));}}}
}

练习2：文件加密

        需求：为了保证文件的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。

        加密原理：对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件夹中

        解密原理：读取加密之后的文件，按照加密的规则反向操作，变成原始文件

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();}}

练习3：修改文件中的数据

文本文件中有以下的数据：

        2-1-9-4-7-8

将文件中的数据进行排序，变成以下的数据：

        1-2-4-7-8-9

public class test {public static void main(String[] args) throws IOException {//读取数据FileReader fileReader =new FileReader("a.txt");StringBuilder stringBuilder=new StringBuilder();int ch;while ((ch=fileReader.read())!=-1){stringBuilder.append((char)ch);}fileReader.close();//排序String str=stringBuilder.toString();String[] str1=str.split("-");ArrayList<Integer> list=new ArrayList<>();for (String s : str1) {int i=Integer.parseInt(s);list.add(i);}Collections.sort(list);System.out.println(list);//写出FileWriter fileWriter=new FileWriter("b.txt");for (int i = 0; i < list.size(); i++) {if(i==list.size()-1){fileWriter.write(list.get(i)+"");}else {fileWriter.write(list.get(i)+"-");}}fileWriter.close();}
}

简化写法

        //排序Integer[] integers = Arrays.stream(stringBuilder.toString().split("-")).map(Integer::parseInt).sorted().toArray(Integer[]::new);System.out.println();//写出FileWriter fileWriter = new FileWriter("b.txt");String s = Arrays.toString(integers).replace(", ","-");String result = s.substring(1, s.length() - 1);System.out.println(result);fileWriter.write(result);fileWriter.close();

细节1：

        文件中的数据不要换行

细节2：bom头