Java（8）I/O

目录

• 一、File类
  • 1、File类概述
  • 2、File类实例化
  • 3、File类常用方法
• 二、IO流的原理
  • 1、IO流的原理
  • 2、input和output的理解
• 三、IO流的分类
  • 1、分类
  • 2、图示
  • 3、四个抽象基类
  • 4、IO流体系
• 四、FileReader和FileWriter
  • 1、IDEA中单元测试方法和main()下相对路径对比
  • 2、使用FileReader读入数据
  • 3、使用FileWriter写出数据
  • 4、使用FileReader和FileWriter复制文本文件
  • 5、使用FileReader和FileWriter不能处理图片的复制的测试
• 五、FileInputStream和FileOutputStream
  • 1、用FileInputStream和FileOutputStream处理文本文件会怎样？
  • 2、确定使用字符流还是字节流
  • 3、用FileInputStream和FileOutputStream复制图片
• 六、缓冲流
  • 1、缓冲流有哪些
  • 2、作用
  • 3、原因
  • 4、使用缓冲流复制图片
  • 5、使用缓冲流复制文本文件
  • 6、练习：统计文本每个字符出现次数
• 七、转换流
  • 1、什么是转换流
  • 2、编码与解码
  • 3、字符集
  • 4、转换流的作用示意图
  • 5、练习题
• 八、标准输入输出流（了解）
  • 1、简介
  • 2.练习
• 九、打印流（了解）
  • 1、打印流简介
  • 2、代码演示
• 十、数据流（了解）
  • 1、简介
  • 2、练习
• 十一、对象流
  • 1、简介
  • 2、对象的序列化★★★★★
  • 3、代码实现String类的对象的序列化和反序列化
  • 4、自定义类的序列化
  • 5、面试题
• 十二、RandomAccessFile
  • 1、简介
  • 2、用RandomAccessFile类实现文本文件的复制
  • 3、用 RandomAccessFile作为输出流时的特点
  • 4、如何使用 RandomAccessFile对文本文件实现插入效果
• 十三、第三方jar包的使用
  • 1、为什么使用
  • 2、IDEA中导入第三方jar包
  • 3、用第三方jar包实现文件复制

一、File类

1、File类概述

• java.io.File类：一个java.io.File类的对象，表示文件和文件目录路径（就是文件夹）
• File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
• 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

• 经典应用场景：File对象可以作为参数传递给流的构造器。

2、File类实例化

• 构造器

构造器	描述
File(String pathname)	由路径名称来创建
File(String parent, String child)	由上层目录路径+文件名来创建
File(File parent, String child)	由上层文件名+文件名来创建
File(URI uri)	由uri来创建

• 路径

  • 绝对路径：是一个固定的路径,从盘符开始
  • 相对路径：是相对于某个位置开始。在IDEA中是相对于当前的module

• 路径分隔符

  • windows和DOS系统默认使用“\”来表示
  • UNIX和URL使用“/”来表示
  • Java程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个隐患，File类提供了一个常量：public static final String separator，根据操作系统，动态的提供分隔符。
  • 举例

  File file1 = new File("d:\\atguigu\\info.txt");
  
  File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
  
  File file3 = new File("d:/atguigu");
  

3、File类常用方法

• **获取

方法	描述
getAbsolutePath()	获取绝对路径
getPath()	获取路径
getName()	获取名
getParent()	获取上层文件目录路径。若无，返回null
length()	获取文件长度（即：字节数）。不能获取目录的长度。
lastModified()	获取最后一次的修改时间，毫秒值
下面两个是针对目录的
public String[] list()	获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles()	获取指定目录下的所有文件或者文件目录的File数组

• 重命名

public boolean renameTo(File dest)：把文件重命名为指定的文件路径。（实际上就是把file1的内容复制到file2，并把file1删除）

对于 file1.renameTo(file2)要求：file1存在，file2不存在

• 判断

方法	描述
isDirectory()	判断是否是文件目录
isFile()	判断是否是文件
exists()	判断是否存在
canRead()	判断是否可读
canWrite()	判断是否可写
isHidden()	判断是否隐藏

• 创建和删除

方法	描述	注意事项
public boolean createNewFile()	创建文件	若文件存在，则不创建，返回false
public boolean mkdir()	创建文件目录	如果此文件目录存在，就不创建； 如果此文件目录的上层目录不存在，也不创建
public boolean mkdirs()	创建文件目录	如果上层文件目录不存在，一并创建
public boolean delete()	删除文件或者文件夹	Java中的删除不走回收站 要删除的文件目录内不能包含文件或文件目录

如果你创建文件或者 文件 目录没有写盘符路径 ， 那么 ，默认在项目路径下。

二、IO流的原理

1、IO流的原理

• I/O是input/output的缩写，IO技术用于设备之间的数据传输。（如。读/写文件、网络通讯）
• Java程序中，数据的输入/输出操作以“流(stream)” 的方式进行。
• java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

2、input和output的理解

• 首先对于入和出，我们是站在程序的角度来说的，想象自己身处程序内部。
• input：磁盘、光盘等存储设备的数据----->程序、内存
• output：程序、内存中的数据----->磁盘、光盘等存储设备

三、IO流的分类

1、分类

• √√√按操作的数据单位不同分为：字节流（8bit）、字符流（16bit）。字节流适合操作图片、视频等文件，字符流适合操作文本文件。

• 按数据流的流向不同分为：输入流、输出流。

• 按流的角色不同分为：**节点流、处理流。

  • 节点流：直接从数据源或目的地读写数据。也叫文件流

    

  • 处理流：不直接连接到数据源或目的地，而是“连接”在已存 在的流（节点流或处理流）之上，通过对数据的处理为程序提 供更为强大的读写功能

    

2、图示

3、四个抽象基类

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

4、IO流体系

四、FileReader和FileWriter

1、IDEA中单元测试方法和main()下相对路径对比

• 单元测试方法下的相对路径是：相较于当前module而言
• main()下的相对路径：相较于当前工程而言

2、使用FileReader读入数据

• 最初的代码实现

public void test1() throws IOException {
        //1.实例化File类,指明要操作的对象.这一步的目的是建立硬盘中的文件和Java中类的对应关系.
        File file = new File("hello1.txt");

        //2.提供具体的流.参数的作用就是帮助我们并连接上文件这个"大水库"
        FileReader fileReader = new FileReader(file);

        //3.用流读取到内存
        //read():返回读入的字符,是int需要转换为char.到了文件结尾返回-1
        int read = fileReader.read();
        while (read != -1) {
            System.out.print((char) read);
            read = fileReader.read();
        }

        //4.关闭流
        fileReader.close();
    }
    //整个过程结合图示去理解很合理

• 改进后的代码实现

	/*
    优化:
        1.第三部可以在语法上的优化,但是效率其实是一样的
        2.为了保证关闭操作一定执行,使用try-catch-finally
        3.读入的文件一定要存在,否则会出现:FileNotFoundException
    */
public void test2() {

        FileReader fileReader = null;
        try {
            File file = new File("hello1.txt");

            fileReader = new FileReader(file);

            //改进1
            int read;
            while ((read = fileReader.read()) != -1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null)
                    fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

• 使用缓冲流改进（这个是用的最多的★★★★★）

//使用数组
char[] charBuffer = new char[5];
int len;//记录每次读入到charBuffer数组中的字符个数
while ((len = fileReader.read(charBuffer)) != -1){
    for (int i = 0; i < len; i++) {//这里要用len(读取的字符数)二不是数组的长度
        System.out.print(charBuffer[i]);
    }
}

//当然for循环也可以换位String的构造器来把字符串数组转换为String
String string = new String(charBuffer, 0, len);
System.out.print(string);

3、使用FileWriter写出数据

• 代码实现

File file = new File("hello2.txt");
FileWriter fw = new FileWriter(file);
fw.write("i have a dream!");
fw.close();
//最后用try-catch处理一下异常，上面的步骤更清晰一些

• 说明
  • 输出时，File可以不存在，不会报异常。
  • File对应的硬盘的文件如果不存在，自动创建
  • File对应的硬盘的文件如果存在
    • 如果流使用的构造器是FileWriter(file, false)/FileWriter(file)，对原有的文件进行覆盖
    • 如果流使用的构造器是FileWriter(file, true)，对原有的文件进行追加

4、使用FileReader和FileWriter复制文本文件

• 代码实现

public void test5() throws IOException {
        File srcFile = new File("hello2.txt");
        File destFile = new File("hello3.txt");

        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

        char[] charBuffer = new char[5];
        int len;
        while ((len = fr.read(charBuffer)) != -1) {
            fw.write(charBuffer, 0, len);//和用String来取是类似的★★★★★
        }

        fw.close();
        fr.close();
}
//最后用try-catch处理一下异常，上面的步骤更清晰一些

5、使用FileReader和FileWriter不能处理图片的复制的测试

• 当把hello.txt文本文件改为图片文件时，发现代码是可以正常运行，但是复制结果并不对，新图片打不开。
• 这是因为，图片是用字节来存储的。用字符流来处理显然不行。

五、FileInputStream和FileOutputStream

1、用FileInputStream和FileOutputStream处理文本文件会怎样？

• 结论
  • 输出到控制台时：英文不乱码，中文可能会乱码
  • 单纯复制，而不在内存层面查看：不会乱码，是可以的。
• 解释
  • 对于英文，utf-8和gbk都是用一个字节（4bit位）来存一个字母，因此每个字母都是完完整整的存入byte数组，从而能完整的复制过去。
  • 对于中文，utf-8中用的是三个字节来存一个汉字，那么字节数组中的数据在输出时，不确定在哪里截断，就会出现一部分字的乱码。

2、确定使用字符流还是字节流

• 对于文本文件（.txt, .java, .cpp），使用字符流
• 对于非文本文件（.jpg, .mp3, .mp4, .avi, .doc, .ppt...），使用字节流

3、用FileInputStream和FileOutputStream复制图片

• 同“使用FileReader和FileWriter复制文本文件”，只要
  • 使用FileInputStream和FileOutputStream
  • 把数组改为byte数组

六、缓冲流

1、缓冲流有哪些

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

2、作用

• 提高读写速度

3、原因

• 在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
• 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。
• 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
• 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
• 使用方法 flush()可以强制将缓冲区的内容全部写入输出流。
• 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷 新缓冲区，关闭后不能再写出。
  • 填坑：自己写代码的时候忘记关闭流操作，导致复制的图片打不开的原因就是，没有关闭流，缓冲区内还有一部分数据没能复制过去。

4、使用缓冲流复制图片

public void test() throws IOException {
        //1.创建File
        File srcFile = new File("img1.png");
        File destFile = new File("img2.png");

        //2.创建流
        //2.1创建文件流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //2.2创建字节流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //3.复制
        byte[] bytes = new byte[10];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //4.关闭流
        bis.close();
        bos.close();
}

• 关闭外层的流的同时，会自动关闭内层的流。所以只写外层的关闭操作就可以。

5、使用缓冲流复制文本文件

public void test1() throws IOException {
        //1.创建文件和流
        BufferedReader br = new BufferedReader(new FileReader(new File("hello1.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));

//        //2.复制
//        char[] chars = new char[10];
//        int len;
//        while ((len = br.read(chars)) != -1) {
//            bw.write(chars, 0, len);
//        }

        // 复制:用String来实现★★★★★★★★★★★
        String data;//但是是不带换行的,可以用一以下两种方法实现
        while ((data = br.readLine()) != null) {
//          //方法一★★★★★★★★
//            bw.write(data + "\n");
            //方法二★★★★★★★★
            bw.write(data);
            bw.newLine();
        }

        //3.关闭
        br.close();
        bw.close();
    }

6、练习：统计文本每个字符出现次数

七、转换流

1、什么是转换流

• 转换流提供了在字节流和字符流之间的转换
• 转换流属于字符流
• Java API提供了两个转换流
  • InputStreamReader：将InputStream转换为Reader
    • 构造器一：public InputStreamReader(InputStream in)默认使用utf-8字符集
    • 构造器二：public InputSreamReader(InputStream in,String charsetName)可以自己选择字符集。
  • OutputStreamWriter：将Writer转换为OutputStream
    • 构造器和上面类似
• 字节流中的数据都是字符时，转成字符流操作更高效。
• 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

2、编码与解码

• 编码：字节、字节数组--->字符数组、字符串
• 解码：字符数组、字符串--->字节、字节数组

3、字符集

• 什么是编码表：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识 别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。 这就是编码表。
• 常见编码表

按照地区辅助记忆	编码表	描述
美国	ASCII	用一个字节的7位来表示所有英文和符号
欧洲	ISO8859-1	用一个字节的8位表示所有欧洲语言的字母
中国	GB2312 GBK	最多两个字节编码所有汉字 升级版，加入了更多的汉字
国际通用	Unicode UTF-8	Unicode编码是对UTF-8/16的统称 用1-4个字节表示人类所有文字

4、转换流的作用示意图

5、练习题

• 综合使用：将文本文件从utf-8转换为gbk编码
• 代码实现

@Test
    public void test2() throws Exception {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();
    }

八、标准输入输出流（了解）

1、简介

• 标准输入流：System.in。默认输入设备是键盘。类型是InputStream。
• 标准输出流：System.out。默认输出设备是控制台。类型是PrintStream，是OutputStream的子类。

2.练习

• 题目：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续 进行输入操作，直至当输入“e”或者“exit”时，退出程序。
• 代码实现

public class Exercise {
    public static void main(String[] args) {//idea不支持在单元测试中输入内容,所以改用main()来测试
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while (true) {
                System.out.println("请输入字符串: ");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

九、打印流（了解）

1、打印流简介

• 实现将基本数据类型的数据格式转化为字符串来输出
• 包含两个：PrintStream和PrintWriter
  • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
  • System.out返回的是PrintStream的实例

2、代码演示

• 把标准输出流(控制台输出)改成文件

PrintStream ps = null;
try {
	FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt")); // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    ps = new PrintStream(fos, true);
    if (ps != null) {// 把标准输出流(控制台输出)改成文件
        System.setOut(ps);
    }

	for (int i = 0; i <= 255; i++) { // 输出ASCII字符
		System.out.print((char) i);
        if (i % 50 == 0) { // 每50个数据一行
            System.out.println(); // 换行
        }
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    if (ps != null) {
        ps.close();
    }
}

十、数据流（了解）

1、简介

• 引入：为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流

• 数据流有两个类：(用于读取和写出基本数据类型、String类的数据，方便持久化）

  • DataInputStream 和 DataOutputStream

  • DataInputStream中的方法

    boolean readBoolean()

    char readChar()

    double readDouble()

    long readLong()

    String readUTF()

    byte readByte()

    float readFloat()

    short readShort()

    int readInt() void

    readFully(byte[] b)

  • DataOutputStream中的方法

    将上述的方法的read改为相应的write即可

2、练习

练习：将内存中的字符串、基本数据类型的变量写出到文件中。

    注意：处理异常的话，仍然应该使用try-catch-finally.
     */
    @Test
    public void test3() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("刘建辰");
        dos.flush();//刷新操作，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        //3.
        dos.close();

    }
    /*
    将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

    注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！

     */
    @Test
    public void test4() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

        //3.
        dis.close();

    }

十一、对象流

1、简介

• 包含：两个类ObjectInputStream和ObjectOutputStream
• 是：用于存储和读取基本数据类型数据或对象的处理流
• 强大之处：可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

2、对象的序列化★★★★★

• 什么是对象的序列化机制（面试题）

  • 一方面，对象的序列化机制允许内存中的Java对象转换为平台无关的二进制流。从而允许吧二进制流持久化到磁盘，或，通过网络传给另一个网络节点；
  • 另一方面，其他程序获取了二进制流，就可以恢复成原来的Java对象。

• 序列化的好处：可将任何实现了Serializable接 使其在保存和传输时可被还原。

3、代码实现String类的对象的序列化和反序列化

public class ObjectInputOutputStream {
    /*
    代码实现String类的对象的序列化和反序列化
     */

    @Test//序列化
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            //1.造流和文件
            oos = new ObjectOutputStream(new FileOutputStream(new File("objectString.dat")));
            //2.写出
            oos.writeObject(new String("我爱你中国"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭流
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(new File("objectString.dat")));

            Object readObject = ois.readObject();
            System.out.println(readObject);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4、自定义类的序列化

• 要求
  • 实现Serializable接口（这是一个标识接口，内部没有方法）
  • 提供一个全局常量public static final long serialVersionUID = xxxxxxxxL;
    • 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自 动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议， 显式声明。
  • 还要保证类的所以属性也是可序列化的。
    • 基本数据类型是可序列化的
• 注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
  • 因为static修饰的变量是类所有的
  • 不想序列化的就可以用transient

5、面试题

• 谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化， 是空方法接口，还有其它认识吗？
  • 实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后 完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机 制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创 建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里 准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必 关心字节的顺序或者其他任何细节。
  • 由于大部分作为参数的类如String、Integer等都实现了 java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更 灵活。

十二、RandomAccessFile

1、简介

• RandomAccessFile，随机存取文件流，直接继承于java.lang.Object类。
• 随机：RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。 RandomAccessFile 类对象可以自由移动记录指针
  • long getFilePointer()：获取文件记录指针的当前位置
  • void seek(long pos)：将文件记录指针定位到 pos 位置（这是他的灵魂所在）
    • 应用场景：可以多线程断点下载同一文件再拼接起来；下载不完，下次接着下载。
• 存取：实现了DataInput、DataOutput两个接口，所以这个类既可以读也可以写**。
  • 可以用构造器里的参数决定是输出流还是输入流。
    • public RandomAccessFile(File file, String mode)
    • public RandomAccessFile(String name, String mode)
  • mode参数指定了访问模式
    • r: 以只读方式打开 （常用）
    • rw：打开以便读取和写入 （常用）
    • rwd:打开以便读取和写入；同步文件内容的更新
    • rws:打开以便读取和写入；同步文件内容和元数据的更新

2、用RandomAccessFile类实现文本文件的复制

@Test
public void test1() throws IOException {
    //用参数mode标识,让类代表输入
    RandomAccessFile r = new RandomAccessFile(new File("hello1.txt"), "r");
    //用参数mode标识,让类代表输出
    RandomAccessFile rw = new RandomAccessFile(new File("hello5.txt"), "rw");

    byte[] bytes = new byte[1024];
    int len;
    while ((len=r.read(bytes)) != -1){
        rw.write(bytes,0,len);
    }

    r.close();
    rw.close();
}

3、用 RandomAccessFile作为输出流时的特点

• 如果写出到的文件不存在，就创建
• 如果写出到的文件存在，会对原文从头开始进行覆盖，能覆盖多少算多少。

4、如何使用 RandomAccessFile对文本文件实现插入效果

/*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }

十三、第三方jar包的使用

1、为什么使用

• 第三方jar包提供了很多方便高效的API，方便我们开发中使用，实际开发中也是用这些jar包来提高工作效率，而不只是根据JDK提供的API，因为有些不够简练。

2、IDEA中导入第三方jar包

• 当前module下创建名为lib或libs的directory
• 复制第三方jar包到lib目录
• 右键jar包，选择 add as library
• 搞定

3、用第三方jar包实现文件复制

public class JarTest {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("s6_IO/hello1.txt");
        File destFile = new File("s6_IO/hello6.txt");

        FileUtils.copyFile(srcFile,destFile);

    }
}