一，IO流常识

Ⅰ，IO流的概述

1，IO流用来处理设备之间的数据传输

2，Java对数据的操作都是通过流的方式

3，Java用于操作流的类都在IO包中

4，流按流向分为：

①输入流

②输出流

5，流按操作类型分为：

①字节流：字节流可以操作任何数据，因为在计算机中任何数据都是以字节存储的

②字符流：字符流只能操作纯字符数据，比较方便

Ⅱ，IO流常用父类

1，字节流的抽象父类（抽象类不能直接new对象）

InputStream

OutputStream

2，字符流的抽象父类（抽象类不能直接new对象）

reader 返回值是int而不是byte

writer

Ⅲ，IO程序书写

使用前，导入IO包中的类

使用时，进行IO异常处理

使用后，释放资源

二，IO流——字节流（FileIntputStream）

read() ：（demo1）一次读取一个字节；

（demo2）当所读取的文件全部读取完成之后，会返回-1。

这里写图片描述

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class Demo1_FileInputStream {public static void main(String[] args) throws IOException {demo1();    //从硬盘上（xxx.txt）一个一个读取字节，然后输出                                            demo2();    //通过while循环进行输出}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");   //创建流对象int b;while((b = fis.read())!= -1){System.out.println(b);}fis.close();                                            //关流释放资源}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");       //创建流对象，开流int x  = fis.read();                                        //从硬盘上读取一个字节System.out.println(x);int y  = fis.read();                                        //从硬盘上读取一个字节System.out.println(y);int z  = fis.read();                                        //从硬盘上读取一个字节System.out.println(z);fis.close();                                                //关流释放资源}   }

demo1
输出形式：
97
98
99

demo2
输出形式：
97
98
99

三，IO流——字节流（FileOutputStream）

write() ：（demo1）一次写出一个字节；

（demo2）若想实现数据的追加

package com.wsq.stream;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo2_FileOutputStream {public static void main(String[] args) throws IOException  {demo1();//如果有文件yyy.txt则会在该文件输入  abc ；若没有该文件，则系统会先创建，然后在输入  abc  到该文件内；demo2();//yy.txt文件会续写上 d}private static void demo2() throws FileNotFoundException, IOException {FileOutputStream fos = new FileOutputStream("yyy.txt",true);    //如果想续写就在第二个参数传true即可；应用于QQ聊天记录的续写fos.write(100);fos.close();                                                    //关流}private static void demo1() throws FileNotFoundException, IOException {FileOutputStream fos = new FileOutputStream("yyy.txt"); //创建字节输出流对象，如果没有就自动创建一个fos.write(97);                                          //虽然写出的是一个int数，但是到文件上的是一个字节，系统会自动去除前三个8位fos.write(98);fos.write(99);fos.close();                                            //关流}}

四，IO流——拷贝

这里写图片描述

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {demo1();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("思You.jpg");      //创建输入流对象，关联  思You.jpgFileOutputStream fos = new FileOutputStream("yy.jpg");      //创建输出流对象，关联 copy.jpgint b;while((b = fis.read()) != -1 ){fos.write(b);}fis.close();    //关流，释放资源fos.close();    //关流，释放资源}}

程序运行之后，会将原有的思You.jpg 原样复制一份，名称为 yy.jpg。

四，IO流——字节数组拷贝，定义小数组

（demo2）write (byte [] b,int off, int len)将指定byte数组中从偏移量off开始的len个字节写入此文件输出流

b：数据
off：数据中的起始偏移量
len：要写入的字节数

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo4_ArrayCopy {public static void main(String[] args) throws IOException {demo1();demo2();FileInputStream fis = new FileInputStream("xxx.txt");FileOutputStream fos = new FileOutputStream("yyy.txt");byte [] arr = new byte[1024 * 8];               //一般定义字节数组都是1024的整数倍int len;while((len = fis.read(arr)) != -1){             //如果忘记加arr。返回的就不是读取的字节个数，而是字节的码表值fos.write(arr,0,len);}fis.close();                                    //关流，释放资源fos.close();                                    //关流，释放资源}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");FileOutputStream fos = new FileOutputStream("yyy.txt");byte [] arr = new byte[2];int len;while((len = fis.read(arr)) != -1){fos.write(arr,0,len);}fis.close();                                    //关流，释放资源fos.close();                                    //关流，释放资源}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");byte [] arr = new byte[2];      //定义字节数组为2个字节int a = fis.read(arr);          //将文件上的字节读取到字节数组中，文件xxx.txt上有3个字节abcSystem.out.println(a);          //读到的有效字节个数for (byte b : arr) {            //第一次获取到文件上的a和bSystem.out.println(b);}System.out.println("——————————————————————————————————————————————————————————————————");int c = fis.read(arr);          //若有有效字节个数，就返回有效的字节个数；若没有的话，就返回-1；System.out.println(c);          //每次读取2个，由于有3个字节，所以读取一次之后还会剩余1个，故返回1；for (byte b : arr) {System.out.println(b);      //每次读取2个字节，ab读取，然后再次读取c，c将a给掩盖，会剩下cb，然后输出；}fis.close();}}

demo1运行输出结果:
这里写图片描述
demo2运行输出结果：
xxx.txt 里面的内容给拷贝到 yyy.txt 文件里面。

五，IO流——BufferedInputStream跟BufferedOutputStream拷贝

package com.wsq.stream;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo5_BufferCopy {
/*** close()方法* 具备刷新的功能，在关闭流之前，就会先刷新一次缓冲区，将缓冲区的字节全都刷到文件上，再关闭，close方法刷完之后就不能写了* * flush()方法* 具备刷新的功能，刷完之后还可以继续写* */public static void main(String[] args) throws IOException {//demo1();//flush和close方法的区别BufferedInputStream bis = new BufferedInputStream(new FileInputStream("xxx.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("wsq.txt"));int b;while((b = bis.read()) != -1){bos.write(b);bos.flush();}//      bis.close();
//      bos.close();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis  = new FileInputStream("xxx.txt");      //创建输入流对象，关联  xxx.txtFileOutputStream fos  = new FileOutputStream("copy.txt");   //创建输出流对象，关联  copy.txtBufferedInputStream bis = new BufferedInputStream(fis);     //创建缓冲区对象，对输入流fis进行包装，让其变得更加强大BufferedOutputStream bos = new BufferedOutputStream(fos);   //创建缓冲区对象，对输出流fos进行包装，让其变得更加强大int b;while((b = bis.read()) != -1){bos.write(b);}bis.close();bos.close();}}

六，IO流——录入数据拷贝到文件

问题：将键盘录入的语句拷贝到当前项目下的xxx.txt文件中，键盘录入数据当遇到quit时就退出

分析：
1，创建键盘录入对象
2，创建输出流对象，关联xxx.txt文件
3，定义无限循环
4，遇到quit退出循环
5，如果不quit，就将内容写出
6，关闭流

package com.wsq.lianxi;import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;public class Test3 {public static void main(String[] args) throws IOException {//1，创建键盘录入对象Scanner  wsq = new Scanner(System.in);//2，创建输出流对象，关联xxx.txt文件FileOutputStream fos = new FileOutputStream("xxx.txt");System.out.println("请输入数据：");//3，定义无限循环  while(true){String line = wsq.nextLine();//4，遇到quit退出循环if("quit".equals(line)){break;}//5，如果不quit，就将内容写出fos.write(line.getBytes());         //字符串写出必须转换成字节数组fos.write("\r\n".getBytes());       //输出一个   换行  }//6，关闭流fos.close();//关流}}

七，IO流——字符流（FileReader）

问题：将xxx.txt文件内的内容给读取出来

package com.yy.chario;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class Demo1_FileReader {public static void main(String[] args) throws IOException {demo1();  //只读取一个字符demo2();  //通过while循环，将xxx.txt文件内的所有内容都读取出来}private static void demo2() throws FileNotFoundException, IOException {FileReader yy = new FileReader("xxx.txt");int y;while((y = yy.read()) != -1){               //通过项目默认的码表（GBK）一次读取一个字符 System.out.print((char)y);向下转型，将int强制转换成char}yy.close();}private static void demo1() throws FileNotFoundException, IOException {FileReader  wsq = new FileReader("xxx.txt");int x = wsq.read();System.out.println(x);char s = (char) x ;//向下转型，将int强制转换成charSystem.out.println(s);wsq.close();}}

八，IO流——字符流（FileWriter）

问题：将字符串和单个字符写到wsq.txt文件内

如果没有wsq.txt这个文件，系统会自动创建出来该文件

package com.yy.chario;import java.io.FileWriter;
import java.io.IOException;public class Demo2_FileWriter {public static void main(String[] args) throws IOException {FileWriter wsq = new FileWriter("wsq.txt");wsq.write("原谅我这一生不羁放纵爱自由。");//可以直接写 字符串wsq.write(29579);                     //也可以写 单个字符wsq.write(24605);wsq.write(29738);wsq.close();}}

九，IO流——字符流的拷贝

问题：将qqq.txt文件（已创建）内容拷贝到www.txt文件里（如果没有创建，系统会自动生成该文件）。

package com.yy.chario;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {FileReader yy = new FileReader("qqq.txt");//qqq.txt这个文件必须存在FileWriter wsq= new FileWriter("www.txt");//www.txt这个文件会自动生成int y ;while((y = yy.read()) != -1){wsq.write(y);}yy.close();wsq.close();  //Writer类中有一个2K的小缓冲区，如果不关流，就会将内容写到缓冲区里，关流会将缓冲区内容刷新，再关闭}}

十，IO流——字节流与字符流的不同用处

字节流：

①字节输入，字节输出，只是对字节的一种搬运
②如果进行只写的时候，必须将字节转换成字节数组才能写出去

字符流：

①字符流也可以拷贝文件，但不推荐使用；因为，读取时，会把字节转为字符（通过GBK码表转换），写出时，会将字符转回字。
②程序需要读取一段文本，或者需要写出一段文本的时候可以使用字符流
也就是只读或者只写的情况下使用字符流，字符流是通过码表进行读写的，整个字符整个字符进读写的
③读取的时候是按照字符的大小读取的不会出现半个中文；写出的时候可以直接将字符串写出，不用转换为字节数组
④不可以拷贝非纯文本的文件；因为在读的时候会将字节转换成字符，在转换过程中，就会用?替代，写出的时候会将字符转换成字节写出去；如果是？，直接写出，这样写出之后的文件就会乱，看不了了。

十一，IO流——字符流拷贝的不同形式

demo1()：将qqq.txt这个文件上的内容，拷贝到www.txt这个文件上
demo2()：字节流不可以拷非文本的文件；运行结束之后，我们会发现，所拷贝之后的王思琪.jpg 无法打开
demo3()：自定义字符数组的拷贝
demo4()：带缓冲区的字符流拷贝

package com.yy.chario;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {
//      demo1();  将qqq.txt这个文件上的内容，拷贝到www.txt这个文件上
//      demo2();  字节流不可以拷   文本的文件；运行结束之后，我们会发现，所拷贝之后的 王思琪.jpg 无法打开
//      demo3();  自定义字符数组的拷贝
//      demo4();  带缓冲区的字符流拷贝        }private static void demo4() throws FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("zzz.txt"));//若有zzz.txt该文件，系统会将该文件的原有内容给清空掉，然后在去拷贝；若该文件不存在，则系统会先创建，再拷贝；int c;while((c = br.read()) != -1){           //读取xxx.txt文件里面的内容，读取到缓冲区里面bw.write(c);                        //将读取到缓冲区（大小为8192=1024*8，16K）的内容给写出去}   br.close();bw.close();}private static void demo3() throws FileNotFoundException, IOException {FileReader fr = new FileReader("www.txt");//www.txt必须事先创建好FileWriter fw = new FileWriter("sss.txt");//sss.txt有没有无所谓，若没有，系统会自动创建，然后将www.txt上的内容给拷贝到该文件上char [] arr = new char[ 1024* 8 ];        //自定义一个字符数组int len;                                    while((len = fr.read(arr)) != -1){        //将文件上的数据读取到字符数组中fw.write(arr,0,len);                  //将字符数组中的数据写到文件上}fr.close();fw.close();}private static void demo2() throws FileNotFoundException, IOException {FileReader yy = new FileReader("思You.jpg");//添加一个字节文件（思You.jpg），用一个字符流去读取一个字节文件（思You.jpg）FileWriter wsq= new FileWriter("王思琪.jpg");//拷贝到  王思琪.jpg  时，该文件损坏       int y ;while((y = yy.read()) != -1){               //进行循环，读取思You.jpgwsq.write(y);                           //拷贝到 王思琪.jpg上}yy.close();wsq.close();  //Writer类中有一个2K的小缓冲区，如果不关流，就会将内容写到缓冲区里，关流会将缓冲区内容刷新，再关闭}private static void demo1() throws FileNotFoundException, IOException {FileReader yy = new FileReader("qqq.txt");//qqq.txt这个文件必须存在FileWriter wsq= new FileWriter("www.txt");//www.txt这个文件会自动生成int y ;while((y = yy.read()) != -1){             //进行循环，读取qqq.txt文本上的内容wsq.write(y);                         //拷贝到www.txt文本上}yy.close();wsq.close();  //Writer类中有一个2K的小缓冲区，如果不关流，就会将内容写到缓冲区里；如果关流，就会将缓冲区内容刷新，再关闭}}

十二，IO流——带缓冲区Buffered的换行两种方法

带缓冲区Buffered的换行：也就是，若文本有换行，读取的时候也会进行换行。

带缓冲区的特殊方法：

readLine();属于 BufferedReader
newLine(); 属于 BufferedWriter

newLine() 与 \r\n 的区别

newLine()是跨平台的方法
而 \r\n只支持的是Windows系统

package com.yy.chario;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo4_Buffered {public static void main(String[] args) throws IOException {demo1();//readLine();demo2();//newLine();}private static void demo2() throws FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("xxx.txt"));String line;while((line = br.readLine()) != null){bw.write(line);                                         //写出回车换行符bw.newLine();                                           //bw.write("\r\n");                                     //跟这个bw.newLine()方法效果一样}   br.close();bw.close();
}private static void demo1() throws FileNotFoundException, IOException {/*   public String readLine()  读取一个文本行，通过下列字符之一即可认为某行已终止，换行('\n')、回车('\r')或者回车后直接跟着换行返回：包含该行内容的字符串，不包含任何行终止符，如果已达到流末尾，则返回null*/BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));//将zzz.txt文件里面的内容给输出到Buffered缓冲区内String line;while((line = br.readLine()) != null){System.out.print(line);                                        //从控制台输出出来}br.close();
}}

十三，IO流——字符流-文本反转

案例：

将一个文本文档的文本反转，第一行和倒数第一行交换，第二行和倒数第二行交换

分析：

1，创建输入输出流对象
2，创建集合对象
3，将读到的数据存储在集合中
4，倒着遍历集合，将数据写到文件上
5，关流

package com.wsq.test;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;public class Test1 {public static void main(String[] args) throws IOException {demo1();                            //正常步骤demo2();                            //改进之后}private static void demo2() throws FileNotFoundException, IOException {/*** 注意事项，流对象，早开晚关，什么时候用到什么时候开，用完之后就关掉* 改进之后：* */BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));ArrayList<String> list = new ArrayList<>();String line;while((line = br.readLine()) != null){list.add(line);}br.close();BufferedWriter bw = new BufferedWriter(new FileWriter("likewsq.txt"));for(int i = list.size() - 1 ; i>=0 ; i--){bw.write(list.get(i));                      //把数据给写出去bw.newLine();                               //换行}bw.close();}private static void demo1() throws FileNotFoundException, IOException {//1，创建输入输出流对象BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("likewsq.txt"));//2，创建集合对象ArrayList<String> list = new ArrayList<>();//3，将读到的数据存储在集合中String line;while((line = br.readLine()) != null){list.add(line);}//4，倒着遍历集合，将数据写到文件上for(int i = list.size() - 1 ; i>=0 ; i--){bw.write(list.get(i));                      //把数据给写出去bw.newLine();                               //换行}//5,关流br.close();bw.close();}}

十四，IO流——字符流-LineNumberReader

public class LineNumberReader extends BufferedReader

跟踪行号的缓冲字符输入流。

此类定义了方法getLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。
默认情况下，行编号从 0 开始。该行号随数据读取在每个行结束符处递增，并且可以通过调用 setLineNumber(int) 更改行号。但要注意的是，setLineNumber(int) 不会实际更改流中的当前位置；它只更改将由 getLineNumber() 返回的值。
可认为行在遇到以下符号之一时结束：换行符（’\n’）、回车符（’\r’）、回车后紧跟换行符。

package com.yy.chario;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;public class Demo5_LineNumberReader {public static void main(String[] args) throws IOException {LineNumberReader wsq = new LineNumberReader(new FileReader("xxx.txt"));String line;wsq.setLineNumber(100);//设置当前行号，若为100，这xxx.txt文件内容从行号从101开始while((line = wsq.readLine()) != null){System.out.println(wsq.getLineNumber() + " "+line);//获得当前行号}wsq.close();}}

十五，IO流——装饰设计模式

package com.yy.chario;public class Demo6_Wrap {
/*** 装饰设计模式的好处：* 耦合性不强，被装饰的类的变化，与装饰类的变化无关* 如果是继承的话，耦合性太强* */public static void main(String[] args) {HeiMaStudent wsq = new HeiMaStudent(new Student());wsq.Coder();}}interface Coder{public void Coder();
}class Student implements Coder{@Overridepublic void Coder() {System.out.println("javase");System.out.println("javaweb");}
}
class HeiMaStudent implements Coder{//1，获取被装饰类的引用private Student wsq;                        //获取学生引用，通过构造方法//2，在构造方法中传入被装饰类的对象public HeiMaStudent (Student s){this.wsq = wsq;}//3，对原有的功能进行升级@Overridepublic void Coder() {wsq.Coder();System.out.println("ssh");System.out.println("数据库");System.out.println("大数据");System.out.println("......");}
}

十六，IO流——用指定的码表读写字符

将utf_8.txt文件上(该文件存在)的内容(UTF-8编码)拷贝到gbk.txt文件(该文件存在与否都可以)上(GBK码表)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;public class Demo7_TransIO {public static void main(String[] args) throws IOException {demo1();demo2();demo3();    }private static void demo3() throws UnsupportedEncodingException, FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("utf_8.txt"),"utf_8"));//更高效的读BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk"));  //更高效的写int wsq;while((wsq = br.read()) != -1){bw.write(wsq);}br.close();bw.close();}private static void demo2() throws UnsupportedEncodingException, FileNotFoundException, IOException {InputStreamReader yy = new InputStreamReader(new FileInputStream("utf_8.txt"),"utf-8");//字节流通向字符流的桥梁,用指定码表读字符OutputStreamWriter wsq = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");//字符流通向字节流的桥梁,用指定码表写字符int c;while((c = yy.read()) != -1){wsq.write(c);}yy.close();wsq.close();}private static void demo1() throws FileNotFoundException, IOException {//用默认编码表读写，出现乱码FileReader fr = new FileReader("utf_8.txt");FileWriter fw = new FileWriter("gbk.txt");int wsq;while((wsq = fr.read()) != -1){fw.write(wsq);}fr.close();fw.close();}}

十七，IO流——获取文本上的字符出现的次数

案例：

获取xxx.txt(该文本已创建，并且有内容)文本上每个字符出现的次数，将结果写在wsq.txt上

获取一个文本上每个字符出现的次数，将结果写在wsq.txt上
- 分析：
- 1，创建带缓冲的输入流对象
- 2，创建双列集合对象TreeMap
- 3，将读到的字符存储在双列集合中，存储的时候要做判断，如果不包含这个键，就将键和1存储，如果包含这个键，就将改建和值加1存储
- 4，关闭输入流
- 5，创建输出流对象
- 6，遍历集合，将集合中的内容写到wsq.txt中
- 7，关闭输出流

package com.wsq.test;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.TreeMap;public class Test3 {public static void main(String[] args) throws IOException {//1，创建带缓冲的输入流对象BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));//2，创建双列集合对象TreeMapTreeMap<Character, Integer> yy = new TreeMap<>();//3,将读到的字符存储在双列集合中，存储的时候要做判断，如果不包含这个键，就将键和1存储，如果包含这个键，就将改建和值加1存储int qq;while((qq = br.read()) != -1){char y = (char) qq;                     //强制类型转换/*if(!yy.containsKey(y)){               //判断是否包含这个键yy.put(y, 1);                       //如果不包含就将键和值为1添加进来}else{yy.put(y,yy.get(y) + 1);}*/yy.put(y, !yy.containsKey(y) ? 1 : yy.get(y) + 1 );}//4，关闭输入流br.close();//5，创建输出流对象BufferedWriter  bw = new BufferedWriter(new FileWriter("wsq.txt"));//6，遍历集合，将集合中的内容写到wsq.txt中for(Character key : yy.keySet()){switch (key) {case '\t':bw.write("\\t" + "=" + yy.get(key));break;case '\n':bw.write("\\n" + "=" + yy.get(key));break;case '\r':bw.write("\\r" + "=" + yy.get(key));break;default:break;}bw.write (key + "=" + yy.get(key));bw.newLine();}//7，关闭输出流bw.close();}}

十八，IO流——测试版软件

当我们下载一个试用版软件，没有购买正版的时候，每执行一次就会提醒我们还有多少次使用机会，用所学过的IO流知识，模拟试用版软件
使用10次机会，执行一次就提示一次您还有几次机会，如果次数到了，提示购买正版
分析：
1，创造带缓冲的输入流对象，因为要使用readLine方法，可以保证数据的原样性
2，将读到的字符串转换为int数
3，对int数进行判断，如果大于0，就将其–写回去，如果不大于0，就提示请购买正版
4，在if判断中要将–的结果打印，并将结果通过输出流写到文件上

package com.wsq.test;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {//1，创造带缓冲的输入流对象，因为要使用readLine方法，可以保证数据的原样性BufferedReader br = new BufferedReader(new FileReader("config.txt"));//2，将读到的字符串转换为int数String line = br.readLine();//System.out.println(line);int times = Integer.parseInt(line);         //将数字字符串转换为数字//3，对int数进行判断，如果大于0，就将其--写回去，如果不大于0，就提示请购买正版if(times > 0){//4，在if判断中要将--的结果打印，并将结果通过输出流写到文件上System.out.println("您还有" + times-- +"次机会");FileWriter fw = new FileWriter("config.txt");fw.write(times + "");fw.close();}else{System.out.println("您的试用次数已到，请购买正版");}br.close();//关闭流}}

十九，IO流——递归

案例：从键盘输入接收一个文件件路径，打印出该文件夹下所有的.java文件名

分析：
- 从键盘接收一个文件夹路径
- 1，如果录入文件夹的是不存在，给予提示
- 2，如果录入的是文件路径，给予提示
- 3，如果是文件夹路径，直接返回
打印出该文件夹路径下的所有的.java文件名
- 1，获取到该文件夹路径下的所以的文件和文件夹，存储在File数组中
- 2，遍历数组，对每一个文件或文件夹做判断
- 3，如果是文件，并且后缀是.java的，就打印
- 4，如果是文件夹，就递归调用

package com.wsq.test;import java.io.File;
import java.util.Scanner;public class Test5 {public static void main(String[] args) {File dir = getDir();                 //获取文件夹路径printJavaFile(dir);}/*** 获取键盘录入的文件夹路径* 1，返回值类型File，因为是返回的是文件夹* 2，不需要有参数* */public static File getDir(){             //获取文件夹路径Scanner wsq = new Scanner(System.in);//创建键盘录入对象System.out.println("请输入一个文件夹路径");while(true){String line = wsq.nextLine();    //将键盘录入的文件路径存储File dir = new File(line);       //封装成File对象if(!dir.exists()){               //如果录入的文件路径不存在System.out.println("您录入的文件夹路径不存在，请重新录入");}else if(dir.isFile()){          //如果录入 的是文件路径System.out.println("您录入的是文件路径，请重新录入文件夹路径");}else{return dir;}}}/*** 获取文件夹路径下的所有.java文件* 1，返回值类型void* 2，参数列表File dir* * */public static void printJavaFile(File dir){//1，获取到该文件夹路径下的所以的文件和文件夹，存储在File数组中File [] subFiles = dir.listFiles(); //2，遍历数组，对每一个文件或文件夹做判断for (File subFile : subFiles) {//3，如果是文件，并且后缀是.java的，就打印if(subFile.isFile() && subFile.getName().endsWith(".java")){System.out.println(subFile);//4，如果是文件夹，就递归调用}else if(subFile.isDirectory()){printJavaFile(subFile);}}}
}

二十，IO流——序列流


package com.yy.otherio;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;public class Demo1_SequenceInputStream {public static void main(String[] args) throws IOException {demo1();demo2();demo3();}private static void demo3() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");FileInputStream fis2 = new FileInputStream("b.txt");FileInputStream fis3 = new FileInputStream("c.txt");Vector<FileInputStream> v = new Vector<>();                     //创建集合对象v.add(fis1);                                                    //将流对象存储进来v.add(fis2);v.add(fis3);Enumeration<FileInputStream> en = v.elements();         SequenceInputStream sis = new SequenceInputStream(en);          //将枚举中的输入流整合成一个 FileOutputStream fos = new FileOutputStream("d.txt");           int sole;while((sole = sis.read()) != -1){fos.write(sole);}sis.close();fos.close();}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");FileInputStream fis2 = new FileInputStream("b.txt");SequenceInputStream sis = new SequenceInputStream(fis2,fis1);FileOutputStream fos = new FileOutputStream("c.txt"); int yy;while((yy = sis.read()) != -1){fos.write(yy);}sis.close();                    //sis在关闭的时候，会将构造方法中传入的流对象也都关闭fos.close();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");        //创建字节输入流，关联a.txtFileOutputStream fos = new FileOutputStream("c.txt");       //创建字节输出流，关联c.txtint wsq;while((wsq = fis1.read()) != -1){                           //不断的在a.txt上读取字节fos.write(wsq);                                         //将读到的字节写到c.txt上}fis1.close();                                               //关闭字节输入流FileInputStream fis2 = new FileInputStream("b.txt");int yy;while((yy = fis2.read()) != -1){fos.write(yy);}fis2.close();fos.close();}}