Java IO流

1.1IO流的概述

如果把数据储存到变量 数组 集合里面。都是不能永久保存的因为数据都是存储在内存里面，只要代码运行结束，所有数据都会丢失。

目的：

将数据写到文件当中，实现数据永久化存储，

把文件中的数据读取到内存中(java程序)

IO的数据传输，可以看做是一种数据流动，按照流动方向，以内存为参照物，进行读写操作。

I表示input，是数据从硬盘进行内存的过程，称之为读数据，

O表示input，是数据内存进行到硬盘的过程，称之为写数据。

1.2 IO的分类

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

输入流：是把数据从硬盘上读取到内存中的流。

输出流：是把内存的数据读取到硬盘上面的流。

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

字节流：以字节为单位，操作所有的类型的文件，包括音频视频图片等，

字符流：以字符为单位，只能操作纯文本文件，能用windows记事本打开的且能读懂的

1.3 IO的顶层父类：

字节输入流：顶层父类 InputStream

字节输出流：顶层父类 OutputStream

字符输入流：顶层父类Reader

字符输出流：顶层父类Writer

二：字节流

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

字节输出流OutputStream

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

public abstract void write(int b)：一次写一个字节数据。

public void write(byte[] b)：一次写一个字节数组数据。

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

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

2.2FileOutputStream类

FileOutputStream概述：

java.Io.FileOutputStream这个类是OutputSream的子类用来表示文本输出流，用于将数据写出到文本。

FileOutputSream的构造方法 

public FileOutputSream（File  file）创建文件输出流以写入由指定的File对象表示的文件。 

public FileOutputStream（String name）：创建文件输出流以指定的名称写入到文件里面

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

运行前：

运行后：

public void write(byte[] b)：一次写一个字节数组数据。

运行结果：

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

运行后：

这里面fos.write里面的0表示从哪里开始写，后面的6表示写几个，我上面写的是写六个

2.3数据的换行与追加。

数据的追加续写：

public FileOutputStream(File file, boolean append)： 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容。

public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容。

写出换行：

Windows：\r\n

linux:\n

max:\r

Windows系统就用第一个表示换行。

字节输入流InputSream：

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

public abstract int read()： 每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1。

public int read(byte[] b)： 每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到

末尾时，返回 -1。public void close()：关闭此输入流并释放与此流相关联的任何系统资源。

注意：当创建一个输入流对象是，必须传入一个文件路径，改路径下如果没有你写的这个路径就会抛出异常

读取字节：

int 热啊的() 每次可以读取一个字节的数据：提升为int类型，读取到文件末尾，返回-1

如图：

被读取的数据

读取到的数据：

其实重复的数据我们可以用循环：

疑问为什么读取到的数据都是数字呢？

因为它会自动给读取到的字节自动转换成码表对应的数字或者符号。

那要怎么样才能变成abcd呢 ，可以使用char将数字转换成字节。

说了这么做个练习题，我现在想用java程序拷贝一个视频并计算它用了多少秒怎么做呢，

接下来上操作。

D盘的视频：

我们读取完视频的时间为7秒

当然啊我读取在idea里面啊 idea是看不了视频和图片的如果想看可以通过别的方式打开，

IO流资源的处理：

Jdk7版本前异常的捕获处理：

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

这是Jdk7之前的异常捕获的处理：

JDK7及以后的捕获的处理方式：

JDK7版本对流的释放做了优化 . 可以使用 try-with-resource 语句 , 该语句确保了每个资源在语句结束时自动关闭。简单理解 : 使用此语句,会自动释放资源 , 不需要自己在写finally代码块了注意 : 使用前提 , 资源的类型必须是AutoCloseable接口的实现类

列：

刚刚读的那个拷贝的文件我们还可以改进一下；因为现在在几mb就要我7秒的时间，

那如果大一点是不是要几个小时：如何去改进；刚刚我们是一个一个字节的去读取，

我们知道FileInputStream可以一次读一次也可以一次读一组，一组指的师数组，

接下来我们来改进一下：刚刚是七秒改进一下是多少秒呢：

刚刚是七秒改进一下变成了0秒所以说改进之后的效率大大提升了。

三.字节缓冲流

昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream

字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流的构造方法

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

public BufferedInputStrem(InputSream in)创建一个新的缓冲输入流。

public BufferedOutputSream(OutputSream out)创建一个新的缓冲输出流。

继续拿我们拷贝的那个文件做演示。

可以看出还是零秒因为这个文件比较小如果想效果更加明显可以换大一点的文件来拷贝。

缓冲流的实现原理也很简单；

四.Properties集合

4.1Properties类的概述：

java。utll。Prperties，继承于H爱上他别，来表示持久的属性，

集，它使用键值结构储存数据，每一个键及其对应的值都是一个字符串。

Properties类的构造方法

public properties()：创建一个空的属性列表

4.3 Properties类存储方法

public Object setProperty(String key, String value)： 保存一对属性。

public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。

public Set stringPropertyNames() ：获取所有键的名称的集合。

也可以通过键循环找值的方式：

回顾一下。

Properties类与流相关的方法

作用：通过流对象，可以关联到配置文件上，这样就能够加载配置，文件中的数据了；

public void load （InputSream InSream）:以字节流的形式，把文件中的键值对，读取到集合里面

public void load(Reader reader)：以字符流形式 , 把文件中的键值对, 读取到集合中

public void store(OutputStream out, String comments)：把集合中的键值对,以字节流形式写入文件中 , 参数二为注释

public void store(Writer writer, String comments)：把集合中的键值对,以字符流形式写入文件中 , 参数二为注释

列如：

这是文件里面的内容：

写入到集合Properties集合里面：

注意事项：

文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。如果配置文件中有中文，那么加载文件文件时，使用字符流,但是开发中一般配置文件中不要写中文

ResourceBundIe工具类；

java.util.ResourceBundle它是一个抽象类我们可以使用它的子类

PropertyResourceBundle来读取以.properties结尾的配置文件。

通过静态方法直接获取对象：static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。参数注意: baseName

属性集名称不含扩展名。

属性集文件是在src目录中的

ResourceBundle中常用方法：String getString(String key) : 通过键，获取对应的值

五.字符集

为什么字节流读取纯文本文件，会出现乱码 ？

如果使用字节流 , 把文本文件中的内容读取到内存时, 可能会出现乱码

如果使用字节流 , 把中文写入文本文件中 , 也有可能会出现乱码

列如：

这是一份文件：

这就是乱码：为什么会出现这种乱码的情况呢；因为我们的文字是以多个字符或者说数字组成单独的读取一个字符或者一个数字就会出现拼接不全然后就会出现我们不认识的一些东西这些东西我们通常就称之为乱码

一般我们的汉字占三个字符所以一下一下读取三个字符可以实现文本读取但还是存在一些问题

字符集（Character set）

顾名思义是字符的集合。字符是各种文字和符号的总称，包括文字、标点符号、图形符号、数字、控制符号等。常用的字符集有：ASCII字符集、GBK字符集、Unicode字符集等。

标准ASCII字符集

ASCII(American Standard Code for Information Interchange)： 美国信息交换标准代码，包括了英文、符号等。

标准ASCII使用1个字节存储一个字符，首尾是0，总共可表示128个字符。

码表：

GBK（汉字内码扩展规范，国标）

window系统默认的码表。兼容ASCII码表，也包含了21003个汉字，并支持繁体汉字以及部分日韩文字。

GBK是中国的码表，一个中文以2个字节的形式存储。但不包含世界上所有国家的文字。

英文、数字占1个字节。

Unicode字符集(统一码，也叫万国码)

Unicode是国际组织制定的，可以容纳世界上所有文字、符号的字符集。UTF-8是Unicode字符集的一种编码方案，采取可变长编码方案，共分四个长度区：1个字节，2个字节，3个字节，4个字节英文字符、数字等只占1个字节（兼容标准ASCII编码），汉字字符占用3个字节。、

注意1：技术人员在开发时都应该使用UTF-8编码!注意

2：字符编码时使用的字符集，和解码时使用的字符集必须一致，否则会出现乱码注意

3：英文，数字一般不会乱码，因为很多字符集都兼容了ASCII编码。

把生活中的数据和计算机中的数据整合在一起，存放在一张表格中

编码：按照编码表规则，将字符存储到计算机中。把看得懂的数据，变为看不懂的数据解码：

按照同样的编码表规则，将存储在计算机中的二进制数据解析显示出来。把看不懂的数据，变为看得懂的数据

例如：存储一个字符a，首先需在码表中查到对应的数字是97，然后按照转换成二进制的规则进行存储。称为编码。

读取的时候，先把二进制解析出来，再转成97，通过97查找码表中对应的字符是a。称为解码。

六.字符流：

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2.1 字符输出流【Writer】

字符输出流Writer类的概述j

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

字符输出流Writer类的常用方法

public void write(int c)：写出一个字符。

public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。

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

public void write(String str) ：写出一个字符串。

public void write(String str,int off,int len)：写出一个字符串的一部分。

public abstract void close()：关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据。

public abstract void flush()：刷新流，还可以继续写数据。

FileWriter类

FileWriter类的概述：

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

FileWriter类的构造方法

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

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

FileWriter(File file,boolean append)： 创建一个新的 FileWriter，追加写入。

FileWriter(String fileName,boolean append)： 创建一个新的 FileWriter，追加写入

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

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

close：关闭流，释放系统资源。关闭前会刷新缓冲区。防止数据丢失

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

列如：

运行前

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

运行后

close：关闭流，释放系统资源。关闭前会刷新缓冲区。防止数据丢失

当然关闭流也可以刷新出来内容但是写了关闭流之后就不能添加新的数据进去。

不然就会报错，

2.3 字符输入流【Reader】

字符输入流Reader类的概述

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

字符输入流Reader类的常用方法

public int read()：每次可以读取一个字符的数据，读取到文件末尾，返回-1。 返回字符数据的编码值。

public int read(char[] cbuf)：一次最多读取cbuf.length个字符数据，并把读取的字符数据存储到cbuf数组中。返回实际读取到的字符数据个数。 读取到文件末尾返回：-1

FileReader类

FileReadder类的概述：

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

FileReader类的构造方法

FileReader（File File）创建一个新的FileReader，给定要读取的File对象

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

列如：

被读取的内容

可以看到既有文字也有英文还有逗号这样读取出来会不会像之前一样出现乱码的请款呢。

读取后：

如果文本更长的话还可以借助数组来读取：

列如：

七.字符缓冲流

7.1字符缓冲流概述，

字符缓冲流呢？本身是不具备读与写的功能，真正读写的还得看字符流。

字符缓冲流的构造方法

public BufferedReader(Reader in)创建一个新的缓冲输入流

public BufferedWriter(Writer out)创建一个新的缓冲输出流。

练习：读取一份纯文本文件：

代码：

读取到2.txt里面的内容

也没有出现乱码的情况；

字符缓冲流的特性与功能：

字符缓冲流的基本方法与普通字符调用方式一致，不能简述，

特有方法

BufferedReader：public String readLine(): 读取文件一行数据, 不包含换行符号 , 读到文件的末尾返回null。

BufferedWriter：public void newLine(): 写一个行分隔符，会根据操作系统的不同,写入不同的行分隔符。 需求：读取文件中的数据排序后再次写出去

列如：练习给文件里面的内容按小到大排序，要求每五个数字换一行

文件的内容：

四转换流：

我们idea普遍是使用utf-8的一般这个是一次性读取三个字节，但是当文本遇到其他编码的文件比如GBK GBK他是一个汉字占两个字符的，所以如果强行读取的可能就会出现乱码的情况；所以就有我们的转行流

InputStreamReader类

InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁，他读取字节，并使用指定的字符集将其解码为字符；他的字符集可以有名称指定，也可以接受平台的默认字符集。

InputStreamReader类的构造方法

InputStreamReader(InputStream in)，创建一个默认字符集的字符流

InputStreamReader(InputStream in,charsetName):创建一个指定字符集的字符流。

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

String str = "读写文件的地址";

InputStraemReader isr = 
        new InputStreamReader(new FileputStream(str),"读写的编码如utf-8还是GBK")

int len;//读到的内容返回给len

while((len=isr.read()) !=-1){//循环读取里面的内容

System.out.printIn((char)len)//类型强行转换
}

isr.close;
}

}

OutputStreamWriter类

OutputSreamWriter类的概述

OutputStreammWriter是Writer的子类，是字符流到字节流的桥梁，可以转行文件的编码，同意也可以接受系统默认的编码；

OutputStreamWriter构造方法

OutputSreamWriter(OutputSreamWriter in)创建使用默认编码的字符流，

默认编码为utf-8

OutputSreamWriter(OutputSreamWriter in,String charsetName)创建一个指定编码的字符集

public static void main(String[] args) throws Exception{
String str="写入文件的地址";
OutputSreamSWriter osw = 
        new OutputStreamWriter(new FileOutputStream(str));//写入默认字符集
    osw.writer("你好");

    
osw.close;
}

public static void main(String[] args) throws Exception{
String str="写入文件的地址";
OutputSreamSWriter osw = 
        new OutputStreamWriter(new FileOutputStream(str),"GBK");//写入指定字符集
    osw.writer("你好");

    
osw.close;
}

转换流的作用

读写特定的编码文件

转换流是字节流和字符流的桥梁。

练习：需求读写取GBK编码的文件

public static void main(String [] aygs)throw exception{
String str ="Java_7_30\\A\\1.txt";//写入的文件地址
OutputStreamWriter osw = 

new OutputSreamWriter(new FileOutputSream (str),"GBK");//指定文件编码

osw.Writer("你好啊海绵宝宝");
OSW.close;

}

public static void main(String [] aygs)throw exception{
String str ="Java_7_30\\A\\1.txt";//读入的文件地址
OutputStreamWriter osw = 

new OutputSreamWriter(new FileOutputSream (str),"GBK");//指定文件编码

int len;
while((len=osw.Reader()) !=-1){
System.out.printIn((char)len);
}
OSW.close;

}

九.对象操作流

对象操作流的概述

可以把对象以字节的形式写到本地文件，直接打开文件，是看不懂的，需要再次用对象操作读取到内存中才能读懂；

对象流分为两类：对象操作流与对象输入流(ObjectInputStream）和对象操作输出流(ObjectOutputSream).

对象操作输出流（对象序列化流）：就是将对象写到本地文件，或者可以说在网上传输对象。

对象输入流(对象反序列化流）:把写到文件中的对象读到内存中，或者接受网络中传输的对象。

9.1ObjectOutputSream类

ObjectOutputSream类的概述。

java.io.ObjectOutputStream类，将java对象的原始数据类型写到文件，实现对象的持久化储存。

9.2ObjectOutputSream的构造方法。

public.ObjectOutputSream(OutputSream out):创建一个指定OutputStream的ObjectOutputStream。

public static void main(String [] aygs) throws Exception{
FileOutputStream fos=
 new FileOutputStream("D:\\1.txt");

ObjectOutputSream out = 
new ObjectOutputSream(fos)
}

9.3ObjectOutputSream 类的序列化操作

该序列化必须是实现java.io.Serilzable接口，Serializable是一个标记接口

public final void writeObject(Object obj):将指定的对象写出；

public class User implements Serlizable{
private String name;
private int age;

public User(){
}//无参构造方法

//创建get和set方法//已省略

}

public static void main(String [] aygs)throw Exception{
//创建流对象
String str = "java7-30\\A\\1.txt";
ObjectOutputSream oos = 
        new ObjectOutputStream(new fileOutputStream(str))
User user = new User;
user.setName("海绵宝宝");
user.(23);
oos.writeObject(user);//把对象写入文件中
oos.close; 

//测试：
System.out.prinTin(user.getName()+user.getAge());
}

9.4序列化集合

需求：用对象操作流读取多个对象。创建多个Javabean类的对象写到文件中，再次再次读取到内存。

public class User implements Serlizable{
private String name;
private int age;

public User(){
}//无参构造方法

//创建get和set方法//已省略

}

public static void main (String [] aygs)throws Exception{
//创建序列化对象
String dest= "Java7-30\\A\\1.txt";//注意这里填写自己的地址
ObjectOutputStream oos = 
        new ObjectOutputSream(new FileOutputStream(dest))

//创建用户对象；
User user = new User();
user.getName("海绵宝宝");
user.getAge(23);

User user1 = new User();
user1.getName("派大星");
user1.getAge(24);

List <User> list = new ArraysList<>();//集合对象

Collections.addAll(list,user,user1);

oos.writrObject(userList);//序列化，向文件中写入序列化对象（集合中的存储的元素必须有实现Seriallizable接口）

oos.close;//释放资源

public static void main (String [] aygs)throws Exception{
//创建序列化对象
String dest= "Java7-30\\A\\2.txt";//填写读入的地址
ObjectInputSream ois =
     new ObjectInputSream(new FileInputStream(ois));

//使用反序列化读取文件的对象；
List<Useer> userlist = (List<User>).ois.readObject();

ois.close;//释放资源

//测试
for(User user : userList){
System.outprintIn(user.getName()+"..."+user.getAge());
}
}

9.5序列化的注意事项：

如果一个类被序列化之后，那么这个类必须实现Serializable这个接口。

这是一个标记性接口没有，里面没有任何抽象方法。

只要实现了这个接口就可以被序列化，用对象序列化流序列化一个对象后，假如我们修改了这个类里面的内容，那么就会报错，如何解决：我们可以给这个被序列化的类加一个：serialVersionUID

javabean这个类

建议最好建立两个测试类效果会更加明显

写入文件的测试类

读取文件的测试类

接下来我们给被序列化的类加一点东西：

添加完这些东西之后在去运行读取文件的测试类的这是测试类是就会报错怎么解决

我们再去运行读取文件的测试类看看

注意：添加完之后必须重新运行写和读的测试类：不然单纯运行读取的测试类是会报错的，因为没有运行添加上面的数据就相当于没有刷新，里面还是未添加前的数据；

十：打印流

打印流能够放便打印多种数据类型的值，写数据也可以实现自动换行。

打印流的构造方法

public PrintStream（String fileName）：使用指定的文件名创建一个新的打印流。

使用：

public static void main(String[] args)throws IOException {
        PrintStream out = new PrintStream("Java7-31\\A\\1.text");
        out.println("1314");
        out.println("加菲猫");
        out.println("电击小子");
        out.close();
    }

package Job01;
import java.io.IOException;
import java.io.PrintStream;
public class Topic01 {
    public static void main(String[] args)throws IOException {
        PrintStream ps =System.out;//打印到控制台
        ps.println("你好");
        
        PrintStream out = new PrintStream("Java7-31\\A\\1.text");//打印到文件
        out.println("1314");
        out.println("加菲猫");
        out.println("电击小子");
        out.close();
    }
}

二.装饰者模式:

装饰者模式简单来说就是在不改变源码的情况下给这个对象进行一系列的增强。

原则：

装饰者和被装饰者必须要有共同的父类接口：

在装饰类中必须传入一个被装饰类的对象

在装饰类中进行方法扩展

在装饰类中对于不需要进行扩展的方法，就跟被装饰类的方法一样不需要进行改变

使用装饰者：

操作：首先建立一个实现类写要增强的方法：

package Job01;
public interface car {//实现类对象在这里写要增强的要增强的方法
    public  void run();

}

第二步让被修饰者去继承这个实现类

package Job01;
public class QQcar implements car{
    public void color (){
        System.out.println("小汽车的颜色是蓝色");
    }
    public  void run(){
        System.out.println("小汽车一秒跑1米");//这里我觉得这个车跑的太慢了我想要他一秒钟跑一千米，
    }
    public void gasoline(){
        System.out.println("汽车加92的油");
    }
}

第三步在建立一个修饰类：

package Job01;
public class QQcarpro implements car{
    private QQcar qqcar;//被修饰者的成员变量
public QQcarpro(QQcar qqcar) {
    this.qqcar = qqcar;
}//写一个有参构造方法,返回值是被修饰者
    @Override
    public void run() {
        System.out.println("每一秒跑1千米");//这里写入增强的方法
    }
}

在类一个测试类：

package Job01;
import java.io.IOException;
public class Text {
    public static void main(String[] args) {
        QQcar car = new QQcar();
        QQcarpro pro = new QQcarpro(car);
        
        pro.run();//增强后的方法每一秒跑1千米
        car.color();//原来不需要增强的方法：小汽车的颜色是蓝色
    }
}

其实这个就相当于与我们IO流里面的方法，

从一开始的FileInputStream 一次读一个到后面一次读一行，还有缓冲流等，这些都是方法的增强，在不改变FileInputStream一次读一行的基础上，给方法进行升级。

commons-io工具包：

工具包就是用了简化我们的代码的；

public static int copy(InputStream in, OutputStream out)； 把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以下)

public static long copyLarge(InputStream in, OutputStream out)；把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以上)

commons-io还提供了一个工具类org.apache.commons.io.FileUtils，封装了一些对文件操作的方法：

public static void copyFileToDirectory(final File srcFile, final File destFile) //复制文件到另外一个目录下。

public static void copyDirectoryToDirectory( file1 , file2 );//复制file1目录到file2位置。

使用：

package zhuanshizhe;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import java.io.*;
public class Room01 {
    public static void main(String[] args)throws Exception {
        //文件专属
        FileInputStream fis =
                new FileInputStream("D:\\youxi 1\\1.webp");
        BufferedInputStream bis =
                new BufferedInputStream(fis);
        FileOutputStream fos =
                new FileOutputStream("D:\\youxi 1\\2.webp");
        BufferedOutputStream bos =
                new BufferedOutputStream(fos);
        IOUtils.copy(bis, bos);//使用IOutils工具包
        
        
        
        //文件夹专属
        File src = new File("D:\\youxi 1");
        File dest = new File("D:\\2");
        FileUtils.copyDirectoryToDirectory(src, dest);//使用Fileuttils工具包

    }
}

注意：使用这个工具包的时候需要一个工具包而且工具包要放在目前打代码的模块下才能使用，出了这个模块就使用不了了；

工具包就是这个： ：

操作步骤：

IO流总结：