IO流概念以及文件拷贝_io流复制-CSDN博客

本文链接：https://blog.csdn.net/d_drj123/article/details/129028809

2. IO流

对于任何程序设计语言而言，输入输出( I/O )系统都是比较复杂的而且是比较核心的。程序运行需要数据，数据的获取往往需要跟外部系统进行通信，外部系统可能是==文件、数据库、其他程序、网络、IO 设备等等==。我们可以发现，外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异。我们希望通过某种技术实现对所有外部系统的输入输出操作， java.io 包为我们提供了相关的API，这就是我们这章所要学习的技术。

2.1. 数据源

datasource, ==提供原始数据==的原始媒介。常见的:==数据库、文件、其他程序、内存、网络连

接、IO设备==。

数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象、动态的概念，是一连串连续动态的数据集合。

2.2. 流的概念

Stream:名词，水流，趋势。动词:流出，流动

数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象、动态的概念，是一连串连续动态的数据集合。

2.3. IO流的种类

由此可见，IO流很庞大,从不同角度进行分类。

2.3.1. 处理的数据单元分类

按处理数据单位分为:字节流和字符流。

处理数据是音频，视频，doc,文本等一切字节流，仅能处理文本的字符流。

字节流和字符流的用法几乎完全一致，区别在于它们所操作的数据单元不同，字节流(8

位)、字符流(16 位)，字节流主要由inputstream 和outputstream 作为基类，字符流主要由 reader和writer 作为基类。

字节流:按照字节读取数据(InputStream、OutputStream)

字符流:按照字符读取数据(Reader、Writer)

2.3.2. 流向分类

输入流和输出流。从节点到 java 内存叫输入流，从 java 内存到节点叫输出流。Java 的输入流主要由 InputStream 和 Reader 作为基类，输出流主要由 OutputStream 和 Writer 作为基类。 (一切以程序为中心)

输入流:数据源到程序(InputStream、Reader读进来)

输出流:程序到目的地(OutPutStream、Writer写出去)

2.3.3. 功能分类

**节点流**和**处理流**。`直接从/向一个特定的I/0设备(磁盘、网络等)读写数据`的流称为节点流，也常被称为低级流。处理流则`对于一个已存在的节点流进行连接或封装`，常被称为高级流(装饰器设计模式)。处理流为增强、提升性能的，本身不具备直接操作节点的能力。如扩音器，就是放大声音的。节点流处于io操作的第一线，所有操作必须通过他们进行;处理流可以对其他流进行处理(提高效率或操作灵活性)。

节点流:可以直接从数据源或目的地读写数据。

处理流:不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。

2.4. 架构图

FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。

使用流抽象的概念，屏蔽了实际的 I/O设备中处理数据的细节。

2.5. IO操作步骤

在进行任何操作之前，首先要明确目的(读还是写)，找准源头(读取)，找准目的地(写出)。

1. 建立联系 :这一步骤是为了获取流，如果此时是文件，则需要将文件抽象到内存形成对象。后期也可以是其他的数据源

2. 选择流:从读写、数据单元和功能方面考虑。输入|输出，字节|字符，结点流|处理流。
3. 执行操作:该读就读，该写就写。考虑是一次性完成还行需要循环。
4. 释放资源:程序中打开的文件 IO 资源不属于内存中的资源，垃圾回收无法回收，需要显示关闭。

3. 字符集和编码格式

3.1. 字符集

字符

计算机科学和信息科学中字符(character，或译为字元)是一个信息单位，通常来说就是一个字母、一个汉字、一个数字、一个标点符号。另外，还存在着一些控制字符，通常是不可打印的(不可见的，或称为是功能性的)，有特定用途，以及emoji(绘文字)之类特殊的符号。

字符集

字符集(character set)指的是指定若干字符组成的一个集合，通常这个集合具有一定的规模和合理性，比如囊括一个国家或地区日常使用的文字字符、数字、标点符号和控制字符等。不同的国家和地区由于历史和文化的原因，使用不同的语言文字，因此存在各种不同的字符集。

字符编码

字符编码(character encoding)是把字符集中的字符映射为指定集合中某一对象(例如数字系统中表示为某个特定的二进制数)，以便文本在计算机中存储和在通信网络传递。

乱码

有字符的编码，就有相应的解码，解码出错就会导致乱码问题。乱码指的是由于使用不同的字符集或字符编码方式，导致显示的部分或全部字符无法被正常的阅读，如常见的文本、网页、邮件乱码。

3.2. 编码格式
计算机中存储信息的最小单元是一个字节即 8 个 bit，所以能表示的字符范围是 0~255 个。人类要表示的符号太多，无法用一个字节来完全表示。

3.2.1. ASCII 码

学过计算机的人都知道 ASCII 码，总共有 128 个，用一个字节的低 7 位表示，0~31 是控制字符如换行回车删除等;32~126 是打印字符，可以通过键盘输入并且能够显示出来。

3.2.2. ISO-8859-1

128 个字符显然是不够用的，于是 ISO 组织在 ASCII 码基础上又制定了一些列标准用来扩展 ASCII 编码，它们是 ISO-8859-1~ISO-8859-15，其中 ISO-8859-1 涵盖了大多数西欧语言字符，所有应用的最广泛。ISO-8859-1 仍然是单字节编码，它总共能表示 256 个字符。

3.2.3. GB2312

它的全称是《信息交换用汉字编码字符集基本集》，它是双字节编码，总的编码范围是 A1-F7，其中从 A1-A9 是符号区，总共包含 682 个符号，从 B0-F7 是汉字区，包含 6763 个汉字。

3.2.4. GBK

全称叫《汉字内码扩展规范》，是国家技术监督局为 windows95 所制定的新的汉字内码规范，它的出现是为了扩展 GB2312，加入更多的汉字，它的编码范围是 8140~FEFE(去掉 XX7F)总共有 23940 个码位，它能表示 21003 个汉字，它的编码是和 GB2312 兼容的，也就是说用 GB2312 编码的汉字可以用 GBK 来解码，并且不会有乱码。

3.2.5. GB18030

全称是《信息交换用汉字编码字符集》，是我国的强制标准，它可能是单字节、双字节或者四字节编码，它的编码与 GB2312 编码兼容，这个虽然是国家标准，但是实际应用系统中使用的并不广泛。

3.2.6. UTF-16

说到 UTF 必须要提到 Unicode(Universal Code 统一码)，ISO 试图想创建一个全新的超语言字典，世界上所有的语言都可以通过这本字典来相互翻译。可想而知这个字典是多么的复杂，关于 Unicode 的详细规范可以参考相应文档。Unicode 是 Java 和 XML 的基础，下面详细介绍 Unicode 在计算机中的存储形式。

UTF-16 具体定义了 Unicode 字符在计算机中存取方法。UTF-16 用两个字节来表示 Unicode 转化格式，这个是定长的表示方法，不论什么字符都可以用两个字节表示，两个字节是 16 个 bit，所以叫 UTF- 16。UTF-16 表示字符非常方便，每两个字节表示一个字符，这个在字符串操作时就大大简化了操作，这也是 Java UTF-16 的一个很重要的原因。

3.2.7. UTF-8

UTF-16 统一采用两个字节表示一个字符，虽然在表示上非常简单方便，但是也有其缺点，有很大一部分字符用一个字节就可以表示的现在要两个字节表示，存储空间放大了一倍，在现在的网络带宽还非常有限的今天，这样会增大网络传输的流量，而且也没必要。而 UTF-8采用了一种变长技术，每个编码区域有不同的的字码长度，不同类型的字符可以是由1~6个字节组成。

字符集和字符编码的关系

字符集是书写系统字母与符号的集合，而字符编码则是将字符映射为一特定的字节或字节序列，是一种规则。通常特定的字符集采用特定的编码方式(即一种字符集对应一种字符编码，但Unicode 不是，它采用现代的模型)，因此基本上可以将两者视为同义词。

4. 基本输入流

4.1. 抽象类:InputStream 和 Reader

InputStream和Reader是所有输入流的基类，它们是两个抽象类，是所有输入流的模版，其中定义的方法在所有输入流中都可以使用。

在InputStream种常用如下几个方法:

在Reader中常用如下几个方法:

对比InputStream和Reader 所提供的方法，可以看出这两个基类的功能基本相似。在读取文件时返回结果为 -1 时表明到了输入流的结束点。 InputStream 和 Reade 都是抽象的，不能直接创建它们的实例，可以使用它们的子类。

4.2. 文件节点类: FileInputStream 和 FileReader

FileInputStream 和 FileReader，它们都是节点流，直接和指定文件关联。操作方式基本一致。而且都使用父类种的方法即可。

4.2.1. 单个字节读取

以FileInputStream为例

public class SingleFileRead {
    public static void main(String[] args) {
        // 1、建立联系 File对象
        File file = new File("f:/IO/test.txt"); 
        // 2、选择流
        InputStream in = null;// 提升作用域
        try {
        in = new FileInputStream(file);
        // 3、操作 单个字节读取
        long fileLength = file.length(); // 接收实际读取的字节数 
        // 计数器
        System.out.println(fileLength);
        long num = 0;
        // 循环读取
        while (num < fileLength) {
                char ch = (char) in.read();
                System.out.println(ch);
                num++;
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件不存在,不能进行下一步操作"); 
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("读取文件失败"); 
       } finally {
        try {
           // 4、释放资料
            if (in != null) {
                in.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        System.out.println("关闭文件输入流失败");
 }}}}

4.2.2. 批量读取

public class ReadFile {
    public static void main(String[] args) {
//1、字节读取:建立联系 File对象
File file=new File("f:/IO/test.txt"); 
//2、选择流
InputStream in=null;//提升作用域
try {
in=new FileInputStream(file); 
//3、操作 不断读取 缓冲数组 
byte[]car=new byte[1024];
int len=0; //接收实际读取的大小 
//循环读取 while(-1!=(len=in.read(car))){
//输出，字节数组转成字符串
String info=new String(car,0,len); 
System.out.println(info);
    }
} catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
System.out.println("文件不存在"); } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
System.out.println("读取文件失败"); }finally{
try { //4、释放资料
    if(in!=null){
        in.close();
    }
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
System.out.println("关闭文件输入流失败"); }}}}
//字符读取1、创建源
File src=new File("f:/char.txt"); //2、选择流
Reader reader=new FileReader(src); //3、读取操作
char[] flush=new char[1024];
int len=0; while(-1!=(len=reader.read(flush))){
//字符数组转换为字符串
String str=new String(flush,0,len); System.out.println(str);
}
//4、释放资源 reader.close();

5. 基本输出流

5.1. 抽象类:OutputStream 和 Writer 用于将数据从Java内存输出到其他的防的流，称为输出流，有字符也有字节。也都类似，有两个抽象类OutputStream，Writer。OutputStream和Writer也非常相似。

在OutputStream 中常用如下方法:

在 Writer 中, 因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来代替字符数组，即以 String对象来作为参数。常用如下方法:

5.2. 文件节点类: FileOutputStream 和 FileWriter

在抽象类下面，真正可以创建对象的是FileOutputStream 和 FileWriter，它们都是节点流，直接和指定文件关联。

public class WriteFile {
        public static void main(String[] args) {
//1、建立联系 File对象 源头 目的地
File dest=new File("c:/IO/print.txt");
//2、选择流 文件输出流 OutputStream FileOutputStream
OutputStream out=null; //以追加形式写出文件 必须为true 否则会覆盖 try {
out=new FileOutputStream(dest,true);
//3、操作
String str="you're a good person\r\n good good good person"; //字符串转成字节数组
byte[] data=str.getBytes();
out.write(data,0,data.length);
out.flush();//强制刷新出去
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block e.printStackTrace(); System.out.println("文件未找到");
} catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace(); System.out.println("文件写出失败");
}finally{
    try {
    if(out!=null){
        out.close();
    }
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
System.out.println("关闭输出流失败"); }}}}
//1、创建源
File dest=new File("f:/IO/char.txt");
//2、选择流
Writer wr=new FileWriter(dest,true);
//3、写出
String str="锄禾日当午\r\n码农真辛苦\r\n一本小破书\r\n一读一上午"; wr.write(str);
//追加内容
wr.append("我就是追加进去的");
wr.flush();//强制刷出
//4、关闭资源
wr.close();

6. 文件拷贝

结合输入输出流，可以实现文件拷贝。
以下以字节流实现文件拷贝案例:

public static void copyFile(String srcPath, String destPath) throws
FileNotFoundException,IOException{
// 1、建立联系 源(存在且为文件) 目的地(文件可以不存在) File src = new File(srcPath);
File dest = new File(destPath); if(!src.isFile()){//不是文件或者为null时抛出异常
System.out.println("只能拷贝文件");
throw new IOException("只能拷贝文件"); }
// 2、选择流
InputStream in = new FileInputStream(src); OutputStream out = new FileOutputStream(dest); // 3、操作
byte[] flush = new byte[1024];
int len = 0;
// 读取
while (-1 != (len = in.read(flush))) {
// 写出
        out.write(flush, 0, len);
    }
out.flush();// 强制刷出 // 关闭流 先打开的后关闭 out.close(); in.close();
}

7. 缓冲处理类:BufferedInputStream，BufferedReader 缓冲提高性能: 字节流缓冲流直接套在节点流上即可使用;字符缓冲流 +新增方法(不能使用多态)。

7.1. BufferedInputStream

构造器

常用方法

//1、创建源，建立联系
File src =new File("test.txt");
//2、选择缓冲流
InputStream is =new BufferedInputStream(new FileInputStream(src)); //3、操作 : 多个读取
byte[] car =new byte[2];
int len =0;
while(-1!=(len=is.read(car))){
//获取数组的内容 字节数组转字符串 new String(字节数组,0,length)
    System.out.println(new String(car,0,len));
}
//4、释放资源 is.close();

7.2. BufferedReader

构造器

方法

注意:父类引用指向子类对象时，不能使用子类新增方法 readLine

//创建源:
File src =new File("test.txt");
//使用字符缓冲流 提高性能读取文件 +新增方法(不能使用多态) BufferedReader br =new BufferedReader(new FileReader(src)); //操作 行读取
String line=null;
while(null!=(line=br.readLine())){
    System.out.println(line);
}
//释放资源 br.close();

8. 转换处理流: InputStreamReader， IOutputStreamWriter

处理的都是字符(字节、字符)
字符流: 方便，可能不出乱码，但是一旦别人有乱码，你这个流就一定乱码

字节流:麻烦，但是只要你能够有机会不乱码，我都可以做到

转换流:将字节流转为字符流处理乱码(编码集、解码集)。

//读取文件
File src =new File("test.txt"); //转换流
BufferedReader br =new BufferedReader(
new InputStreamReader(new BufferedInputStream(new FileInputStream(src)),"utf-8" ));
//行读取
String msg =null;
while(null!=(msg =br.readLine())){
    System.out.println(msg);
}
br.close();

9. 数据处理流:DataInputStream，DataOutputStream

必须先写，再读。读的顺序必须和写的顺序保持一致可以处理基本类型+String，保留数据的类型。前提是读取顺序与写出顺序一致，否则读取数据不正确

/**
* 数据+类型 输出到文件
* @param destPath
* @throws IOException
*/
public static void write(String destPath) throws IOException{
    int point = 2;
long num = 100L;
String str = "数据类型";
//创建源
File dest = new File(destPath);
//选择流
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new
FileOutputStream(dest)));
//操作 写出的顺序 为读取作准备 dos.writeInt(point); dos.writeLong(num); dos.writeUTF(str); dos.flush();
//释放资源
dos.close();
}

10. 对象流ObjectOutputStream，ObjectInputStream

以前我们学过的流都只能读写字节，字符形式的数据，而java中非常重要并且常见的对象类型的数据,如果想要存储到文件中应该怎么操作呢?这个时候就使用到了对象流。

序列化:是一个用于将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序

反序列化:从字节流创建对象的相反的过程称为反序列化

10.1. ObjectOutputStream(序列化)

首先在使用ObjectInputStream和ObjectOutputStream的时候，放置在此IO中的对象，必须要实现

Serializable接口!序列化接口(实现了此接口，代表我们的对象支持序列化) 但是实现了Serializable接口之后，其中并没有实现任何方法，对于这种接口，我们称之为标记接口。
注意: 要先序列化后反序列化

//创建源
File dest=new File(destPath);
//选择流 OjbectOutputStream ObjectOutputStream dos=new ObjectOutputStream(
    new BufferedOutputStream(new FileOutputStream(dest))
);
//操作 读取的顺序与写出的顺序一致 必须存在才能读取 Employee obj=new Employee ("yinwei",1500); dos.writeObject(obj);
//刷出
dos.flush(); //释放资源 dos.close();

10.2. 对象处理流(反序列化):ObjectInputStream

ObjectInputStream能够让你从输入流中读取Java对象，而不需要每次读取一个字节。你可以把

InputStream包装到ObjectInputStream中，然后就可以从中读取对象了。
transient 瞬时的，属性被该关键字修饰，则不会序列化。反序列化的时候，则使用属性默认值

package com.shsxt.myio;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/*
序列化一个对象到文件
*/
public class Demo005 {
    public static void main(String[] args) throws Exception {
// 确定目的地
File file = new File("a.txt");
// 选择流
ObjectOutputStream oos = new ObjectOutputStream(new
FileOutputStream(file)); // 写数据
} }
Student stu = new Student("zas",18,false);
/*stu.setAge(20);
stu.setGender(true);
stu.setName("zs");*/
oos.writeObject(stu);
oos.flush(); // 释放资源 oos.close();
/**
* 反序列化:
* 1、先写入再读取
* 2、读取对象需要知道具体类型，依次读取
* 注意:
* 1)不是所有的对象都可以序列化 Serializable
* 2)不是所有的属性都需要序列化 transient
*/
public static void read(String srcPath) throws FileNotFoundException, IOException, ClassNotFoundException{
//创建源
File src=new File(srcPath);
//选择流 OjbectInputStream ObjectInputStream dis=new ObjectInputStream(
        new BufferedInputStream(
            new FileInputStream(src)
) );
//操作 读取的顺序与写出的顺序一致 必须存在才能读取 Object obj=dis.readObject();
if(obj instanceof Employee){
        Employee emp=(Employee)obj;
        System.out.println(emp.getName());
        System.out.println(emp.getSalary());
}
obj=dis.readObject(); int[]arr=(int[])obj; System.out.println(Arrays.toString(arr)); //释放资源
dis.close();
}

10.3. serialVersionUID

serialVersionUID 用来表明类的不同版本间的兼容性。简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的 serialVersionUID与本地相应实体(类)的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

serialVersionUid在序列化类中的代码示例

import java.io.Serializable;
public class Test implements Serializable{
    private static final long serialVersioinUid=1234567890L;
.... }

当实现java.io.Serializable接口的实体(类)没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，只有同一次编译生成的 class才会生成相同的serialVersionUID 。

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

自动在实体类中提供序列号:

1. 类实现Serializable接口

public class Student implements Serializable {}

2. 在idea设置Settings中进行配置

3. 光标在类名上,alt+enter快捷键自动生成serialVersionUID

class Student implements Serializable {
    private static final long serialVersionUID = 6764938041110249040L;
    private String name;
}

11. ByteArrayInutStream和 ByteArrayOutputStream(了解)

(经常用在需要流和数组之间转化的情况!)

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

说白了，FileInputStream是把文件当做数据源。ByteArrayInputStream则是把内存中的某个数组当做数据源。

ByteArrayOutputStream类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。 ByteArrayOutputStream将一个输出流指向一个Byte数组，但这个Byte数组是ByteArrayOutputStream内部内置的，不需要我们来定义。

注:不需要关闭流的，但是调用close也没有问题，close不做任何事情。因为ByteArrayOutputStream 本身操作的是数组，并没有打开文件描述符之类的，所以不需要关闭。

//简单测试ByteArrayInputStream: ByteArrayInputStream bais = null; StringBuilder sb = new StringBuilder(); int temp = 0;
int num = 0;
long date1 = System.currentTimeMillis();
try {
    byte[] b = "abcdefghijklmnopqrstuvwxyz".getBytes();
    //bais = new ByteArrayInputStream(b);
    bais = new ByteArrayInputStream(b,2,10);
    while((temp = bais.read())!=-1){
        sb.append((char)temp);
        num++;
}
    System.out.println(sb);
System.out.println("读取的字节数:"+num); }finally{
    try {
        bais.close();
    } catch (IOException e) {
        e.printStackTrace();
}
    new File("d:"+File.separator+"a.txt");
}
long date2 = System.currentTimeMillis(); System.out.println("耗时:"+(date2-date1));
//将输入流的内容读入到一个数组中返回:
byte[] getBytesFromIS(FileInputStream fis){
        ByteArrayOutputStream baos = null;
        int temp = 0;
 try {
        baos = new ByteArrayOutputStream();
        while((temp=fis.read())!=-1){
            baos.write(temp);
}
return baos.toByteArray(); //从而返回一个包含输入流所有内容的数组 } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

Commons-io

commonsio 就是别人写好的一些工具类，我们就是用而已。
CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写

文件,url源代码等。commons-IO 需要加入classpath 的第三方 jar 包内的 class 文件才能在项目中使用

IOUtils 包含一些工具,用于处理读,写和拷贝,这些方法基于 InputStream , OutputStream , Reader 和 Writer 工作。
FileUtils 包含一些工具,它们基于File对象工作，包括读，写，拷贝和比较文件 FilenameUtils 包含一些工具,它们基于文件名工作而不是File对象。这个类旨在在Unix和

Windows环境下保持一致,帮助在两个环境下过渡(如从开发环境到生成环境)
FileSystemUtils 包含一些工具类，基于文件系统访问功能不被JDK支持。目前，只有一个方法就

是得到驱动器空余空间。注意这使用命令行而不是 native code。

1. 使用步骤 1.1. 下载资源

从某个地方以合法合理的方式获取都行。

commons-io-2.11.0.jar 就是需要导入到项目中的 jar 包，里面存放的是class文件

commons-io-2.11.0-sources.jar 工具类中原代码

docs 是帮助文档

1.2. 导入 commons-io

Eclipse的方式:build path->add to build path

IDEA的方式:拷贝 ->add as library

1.3. commons-io 的使用

1.3.1. IO工具类IOUtils

IOUtils.copy(InputStream input, OutputStream output) // 此方法有多个重载方法，满足不同的输入输出流

// 这个方法适合拷贝较大的数据流，比如2G以上
IOUtils.copyLarge(Reader input, Writer output) // 默认会用1024*4的buffer来读取

IOUtils.toInputStream(String input, String encoding)// 通过文本获取输入流 ， 可以指定编码格式

IOUtils.toBufferedInputStream(InputStream input)// 获取一个缓冲输入流，默认缓冲大小1KB，也可以指定缓冲大小

IOUtils.toBufferedReader(Reader reader)//获取一个字符缓冲流，可指定缓冲大小

1.3.2. IO 工具类 FilenameUtils 这个工具类是用来处理文件名(文件路径)的，可以轻松解决不同操作系统文件名称规范不同的问

题，里面的方法都是静态的，直接用类进行调用

FilenameUtils.getBaseName(String filename)// 去除目录和后缀后的文件名

FilenameUtils.getExtension(String filename) // 获取文件的后缀
FilenameUtils.getName(String filename)// 获取文件名
FilenameUtils.getPath(String filename)// 去除盘符后的路径
FilenameUtils.getPrefix(String filename)// 盘符
isExtension(String fileName, String text)// 判断fileName是否是text后缀名

1.3.3. IO 工具类 FileUtils

提供文件操作，如移动文件、读取文件、检查文件是否存在等的方法

复制文件夹

FileUtils.copyDirectory(File srcDir, File destDir)//复制文件夹(文件夹里面的文件内容也会复制)

FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)// 复制文件夹，带有文件过滤功能

FileUtils.copyDirectoryToDirectory(File srcDir, File destDir)// 以子目录的形式将文件夹复制到到另一个文件夹下

复制文件

FileUtils.copyFile(File srcFile, File destFile)// 复制文件
FileUtils.copyFileToDirectory(File srcFile, File destDir)// 复制文件到一个指定的目录

把字符串写入文件

FileUtils.writeStringToFile(File file, String data, String encoding)// 字符串以指定的编码写到文件

FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)//指定知否追加z字节数组写入文件

FileUtils.writeByteArrayToFile(File file, byte[] data)// 系列方法，可以指定追加，偏移量等

文件移动

FileUtils.moveFile(File srcFile, File destFile)// 移动文件

删除文件夹

FileUtils.deleteDirectory(File directory) // 删除文件夹，包括文件夹和文件夹里面所有的文件

1.3.4. FileSystemUtils的使用仅有这一个方法，及其重载方法

FileSystemUtils.freeSpaceKb() throws IOException

作为一个工具，第一步就是学会使用!!!