Java开发从入门到精通（二十）：Java的面向对象编程OOP：IO流文件操作的读取和写入

（一）Java的IO流文件读写

1.1 IO流前置知识

• 字符集、UTF-8、GBK、ASCII、乱码问题、编码和解码等

1.1.1 ASCII字符集

美国人发明了计算机以后就把自己的字符录入到系统中，也就是英文、数字、标点、特殊符号，但是计算机只能识别0、1，所以为了能使用这些字符，美国人发明了ASCII 将所用到字符编写为特定的编号，从0-127 ，这些被称为码点 也叫ASCII，然后把ASCII通过编码的方式写进计算机，也就是将编号0-127转换成二进制数表示，但是这些字符的二进制不够八位，不够的补0，使用了一个字节来存储。

• 标准ASCII字符集 ASCll(American standard Code for Information Interchange):美国信息交换标准代码，包括了英文、符号等
• 标准ASCII使用1个字节存储一个字符，首尾是0，总共可表示128个字符

1.1.2 GBK字符集

随着计算机的普及，计算机进入中国，中国人将自己的字符编写成GBK汉字编码字符集，包含了2万多个汉字等字符，GBK中一个中文字符编码成两个字节的形式存储。这就是人们常说的GBK编码 专业名称是(汉字内码扩展规范，国标)
注意:GBK兼容了ASCII字符集。

为了区分ASCII和GBK编码 规定ASCII首字节是0 GBK首字节是1

1.1.3 Unicode字符集

随着越来越多的国家使用计算机，编码方式也越来越多，为了能够统一全世界的编码格式，国际组织制定了Unicode字符集，可以容纳世界上所有文字、符号的字符集。其中有很多编码方法比如UTF-32 ，使用4个字节表示一个字符，不被使用的原因是比较奢侈！占存储空间，通信效率变低

1.1.4 UTF-8字符集

• 由于UTF-32 的设计不符合大家的要求，国际组织制定重新制定了UTF-8，是Unicode字符集的另一种编码方案，采取可变长编码方案，共分四个长度区:1个字节，2个字节，3个字节，4个字节
• 英文字符、数字等只占1个字节(兼容标准ASCII编码)，汉字字符占用3个字节
  

UTF-8编码规则：

• 字符如果是一个字节 应该以0开头
• 字符如果是两个字节 应该以110 10 开头
• 字符如果是三个字节 应该以110 10 10 开头
• 字符如果是四个个字节 应该以110 10 10 10开头

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

要点记忆部分：

• ASCII字符集:只有英文、数字、符号等，占1个字节
• GBK字符集:汉字占2个字节，英文、数字占1个字节
• UTF-8字符集:汉字占3个字节，英文、数字占1个字节

注意1:字符编码时使用的字符集，和解码时使用的字符集必须一致，否则会出现乱码
注意2:英文，数字一般不会乱码，因为很多字符集都兼容了ASCII编码

1.1.4 Java的编码解码

• 编码:把字符按照指定字符集编码成字节。

• 解码:把字节按照指定字符集解码成字符。

import java.util.Arrays;

public class ZiFu {
    public static void main(String[] args) throws Exception {
        // 1、编码
        String data ="a我b";
        byte[] bytes = data.getBytes(); // 默认是按照平台字符集(UTF-8)进行编码的。
        System.out.println(Arrays.toString(bytes));

        // 按照指定字符集进行编码。
        byte[] bytes1 = data.getBytes(  "GBK");
        System.out.println(Arrays.toString(bytes1));
        
        
        // 2、解码
        String s1= new String(bytes);// 按照平台默认编码(UTF-8)解码
        System.out.println(s1);
        
		// 按照指定字符集进行解码。
        String s2 =new String(bytes1,"GBK");
        System.out.println(s2);
    }
}

1.2 IO流的基础知识

1.2.1 认识I0流

IO流概述

• I指Input，称为输入流:负责把数据读到内存中去
• 0指Output，称为输出流:负责写数据出去
  

1.2.2 应用场景

1.2.3 如何学I0流

1.2.3.1 先搞清楚I0流的分类、体系：

• I0流的分类

总结流的四大类：

• 字节输入流:以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流
• 字节输出流:以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流。
• 字符输入流:以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流。
• 字符输出流:以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流。

Java.io包下

• I0流的体系
  
  

1.2.3.1 再挨个学习每个I0流的作用、用法。

1.2.3.1 字节流的用法

1.2.3.1.1 FilelnputStream文件字节输入流:每次读取一个字节

FilelnputStream(文件字节输入流)
作用:以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去

import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"))
        // 简化写法:推荐使用。
        InputStream is = new FileInputStream(("file-io-app\\src\\itheima1.txt"));

        //2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b1 = is.read();
        System.out.println((char)b1);

        int b2 = is.read();
        System.out.println((char)b2);

        int b3 = is.read();
        System.out.println(b3);

        // 3、使用循环改造上述代码
        int b;
        // 用于记住读取的字节。
        while((b=is.read())!= -1) {
            System.out.print((char) b);
        }
        // 读取数据的性能很差!
        // 读取汉字输出会乱码!!无法避免的!!
        // 流使用完毕之后，必须关闭!释放系统资源!2
        is.close();
    }
}

1.2.3.1.2 FilelnputStream文件字节输入流:每次读取多个字节

import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        InputStream is =new FileInputStream("/1.txt");

        // 2、开始读取文件中的字节数据:每次读取多个字节。
        // public int read(byte b[])throws IOException
        // 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
        byte[] buffer = new byte[3];
        int len = is.read(buffer);
        String rs=new String(buffer);
        System.out.println(rs);
        System.out.println("当次读取的字节数量:"+ len);
        // buffer = [abc]
        // buffer = [66c]
        int len2 = is.read(buffer);
        // 注意:读取多少，倒出多少。
        String rs2 = new String(buffer,0,len2);
        System.out.println(rs2);
        System.out.println("当次读取的字节数量:"+ len2);
        
        int len3 = is.read(buffer);
        System.out.println(len3);//-1
    }
}

优化代码

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        InputStream is =new FileInputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");
        
        // 2、开始读取文件中的字节数据:每次读取多个字节。
        // public int read(byte b[])throws IOException
        // 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len;// 记住每次读取了多少个字节。abc 66
        while((len=is.read(buffer))!=-1) {
            // 注意:读取多少，倒出多少。
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }
        is.close();// 关闭流
        // 性能得到了明显的提升!!
        // 这种方案也不能避免读取汉字输出乱码的问题!!
    }
}

• 使用FilelnputStream每次读取多个字节，读取性能得到了提升，但读取汉字输出还是会乱码

1.2.3.1.3 FilelnputStream文件字节输入流:一次读取完全部字节

方式一:自己定义一个字节数组与被读取的文件大小一样大，然后使用该字节数组，一次读完文件的全部字节。

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
        InputStream is =new FileInputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");

        // 2、准备一个字节数组，大小与文件的大小正好一样大。
        File f = new File("lianxi\\src\\com\\qianxin\\file\\1.txt");
        long size = f.length();
        byte[] buffer =new byte[(int) size];

        int len = is.read(buffer);
        System.out.println(new String(buffer));

        System.out.println(size);
        System.out.println(len);
    }
}

lianxi\src\com\qianxin\file\1.txt 内容

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
1163
1163

方式二:Java官方为InputStream提供了如下方法，可以直接把文件的全部字节读取到一个字节数组中返回。

import java.io.FileInputStream;
import java.io.InputStream;


public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
        InputStream is =new FileInputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");
        byte[] buffer = is.readAllBytes();
        System.out.println(new String(buffer));
        is.close();
    }
}

1、直接把文件数据全部读取到一个字节数组可以避免乱码，是否存在问题?

• 如果文件过大，创建的字节数组也会过大，可能引起内存溢出，
• 字符流：读写文本内容更适合用
• 字节流：适合做数据的转移，如:文件复制等

1.2.3.1.4 FileOutputstream文件字节输出流:写字节出去

FileOutputstream(文件字节输出流)
作用:以内存为基准，把内存中的数据以字节的形式写出到文件中去。

import java.io.FileOutputStream;
import java.io.OutputStream;

public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
        OutputStream os = new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");

        // 2、开始写字节数据出去了
        os.write(97); //97就是一个字节，代表a
        os.write('b'); //'b'也是一个字节
        os.write('磊');// [ooo]默认只能写出去一个字节

        byte[] bytes ="我爱你中国abc".getBytes();
        os.write(bytes);
        os.write(bytes,0,15);
        os.close();//关闭流
    }
}

写入文件不覆盖之前的内容 FileOutputStream(“lianxi\src\com\qianxin\file\1.txt”,true);

import java.io.FileOutputStream;
import java.io.OutputStream;


public class FileInputTest {
    public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。// 创建一个字节输入流管道与源文件接通
        OutputStream os = new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\1.txt",true);

        // 2、开始写字节数据出去了
        os.write(97); //97就是一个字节，代表a
        os.write('b'); //'b'也是一个字节
        os.write('磊');// [ooo]默认只能写出去一个字节

        byte[] bytes ="我爱你中国abc".getBytes();
        os.write(bytes);
        os.write(bytes,0,15);

        // 换行符
        os.write("\r\n".getBytes());

        os.close();//关闭流
    }
}

1.2.3.1.5 案例:文件复制

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class FileCopyTest {
    public static void main(String[] args) throws Exception {
        // 需求:复制照片。
        // 1、创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream( "D:/resource/meinv.png");
        // 2、创建一个字节输出流管道与目标文件接通。
        OutputStream os = new FileOutputStream("c:/data/meinv.png");
        //1024+1024 +6
        // 3、创建一个字节数组，负责转移字节数据。
        byte[] buffer =new byte[1024];//1KB
        // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
        int len;// 记住每次读取了多少个字节。
        while((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        os.close();
        is.close();
        System.out.println("复制完成!!");
    }
}

字节流非常适合做一切文件的复制操作

• 任何文件的底层都是字节，字节流做复制，是一字不漏的转移完全部字节，只要复制后的文件格式一致就没问题!

1.2.3.2 释放资源的方式

如果文件操作中间的代码出现异常，那么最后的释放文件读写资源的close将不会被执行，导致长时间占用资源，所以需要使用一些释放资源的方法，保证即使前面的代码有问题也能将资源释放，提高性能

1.2.3.2.1 try-catch-finally

finaly代码区的特点:无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非IVM终止。

• 作用:一般用于在程序执行完成后进行资源的释放操作(专业级做法）

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args){
        InputStream is= null;
        OutputStream os = null;
        try {
            // 需求:复制照片。
            // 1、创建一个字节输入流管道与源文件接通
            is = new FileInputStream("D:/resource/meinv.png");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("c:/data/meinv.png");
            //1024+1024 +6
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024];//1KB
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len;// 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }

            System.out.println("复制完成!!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源的操作
            try {
                if (is != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.2.3.2.2 try-with-resource

JDK 7开始提供了更简单的资源释放方案:try-with-resource,try-catch-finally提供的资源释放代码过于臃肿

• 完成对资源的释放！该资源使用完毕后，会自动调用其close()方法

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        // 需求:复制照片
        try (
                // 1、创建一个字节输入流管道与源文件接通
                InputStream is = new FileInputStream("D:\\resource\\ab.txt");
                // 2、创建一个字节输出流管道与目标文件接通。
                OutputStream os = new FileOutputStream("F:\\1");
        ) {
            // 1024 + 1024 + 6
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024];//1KB
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            // 记住每次读取了多少个字节。
            int len;
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成!!");

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

try ()中只能放置资源，否则报错
什么是资源呢?
资源一般指的是最终实现了AutoCloseable接口，InputStream OutputStream 都继承了自动关闭的接口方法

1.2.3.3 字符流的用法

字节流:适合复制文件等，不适合读写文本文件
字符流:适合读写文本文件

1.2.3.3.1 FileReader文件字符输入流-读字符数据进来

FileReader(文件字符输入流)
作用:以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。


每次读取一个字符

public class FileCopyTest {
    public static void main(String[] args) {
        try (
                //1 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
        ) {
            // 2、读取文本文件的内容了。
            int c;// 记住每次读取的字符编号。
            while ((c = fr.read()) != -1) {
                System.out.print((char) c);
            }
            // 每次读取一个字符的形式，性能肯定是比较差的。

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

每次读取多个字符

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        try (
                //1 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
        ) {
            // 3、每次读取多个字符。
            char[] buffer = new char[3];
            int len;// 记住每次读取了多少个字符。
            while ((len = fr.read(buffer)) != -1) {
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
                // 性能是比较不错的!
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.2.3.3.2 FileWriter文件字符输出流-写字符数据出去

FileWriter(文件字符输出流)
作用:以内存为基准，把内存中的数据以字符的形式写出到文件中去。

字符输出流使用时的注意事项:
必须刷新流，或者关闭流，写出去的数据才能生效字符输出流写出数据后

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        try(
                //覆盖管道
                Writer fw = new FileWriter("D:\\resource\\ab.txt");
                //追加管道
                Writer fw = new FileWriter("D:\\resource\\ab.txt",true);
        ){
            // 1、public void write(int c):写一个字符出去
            fw.write("a");
            fw.write( 97);
            fw.write('磊');// 写一个字符出去
            fw.write("\r\n");

            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            // 3、public void write(string c ,int pos ,int len):写字符串的一部分出去
            fw.write( "我爱你中国abc" ,0,5);
            fw.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer ={'黑','马','a','b','c'};
            fw.write(buffer);
            fw.write("\r\n");

            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer,0,2);
            fw.write("\r\n");

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

flush刷新流close关闭流

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) throws IOException {

        Writer fw = new FileWriter("D:\\resource\\ab.txt", true);

        // 1、public void write(int c):写一个字符出去
        fw.write("a");
        fw.write(97);
        fw.write('磊');// 写一个字符出去
        fw.write("\r\n");

        fw.flush();// 刷新流。
        fw.write("张三");
        fw.flush();

        fw.close();// 刷新流，关闭流包含刷新作!
        
    }
}

1.2.3.3 缓冲流的用法

• 对原始流进行包装，以提高原始流读写数据的性能

• 原始流/低级流

• 包装流/处理流

1.2.3.3.1 字节缓冲流的用法

• 以文件复制为例

使用缓冲流32次变成了4次，提高了效率

• 原理:字节缓冲输入流自带了8KB缓冲池;字节缓冲输出流也自带了8KB缓冲池

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) throws Exception {
        try (
            // 需求:复制照片。
            // 1、创建一个字节输入流管道与源文件接通
            InputStream is = new FileInputStream( "D:/resource/meinv.png");
            // 创建一个字节缓冲输入流包装原始的字节输入流
            InputStream bis =new BufferedInputStream(is);
            // 2、创建一个字节输出流管道与目标文件接通。
            OutputStream os = new FileOutputStream("c:/data/meinv.png");
            // 创建一个字节缓冲输出流包装原始的字节输出流
            OutputStream bos =new BufferedOutputStream(os);
            ){

            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer =new byte[1024];//1KB
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len;// 记住每次读取了多少个字节。
            while((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
            System.out.println("复制完成!!");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1.2.3.3.2 字符缓冲流的用法

• 对原始流进行包装，以提高原始流读写数据的性能

BufferedReader(字符缓冲输入流)

• 作用:自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能

• 字符缓冲输入流新增的功能:按照行读取字符

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        try (
                //1 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("D:\\\\resource\\\\ab.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ) {
            // 3、每次读取多个字符。
            char[] buffer = new char[3];
            int len;// 记住每次读取了多少个字符。
            while ((len = br.read(buffer)) != -1) {
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
                // 性能是比较不错的!
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

readLine读取一行数据

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("D:\\\\resource\\\\ab.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ) {

            String line;// 记住每次读取的一行数据
            while((line =br.readLine())!= null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

BufferedWriter(字符缓冲输出流)

• 作用:自带8K的字符缓冲池，可以提高字符输出流写字符数据的性能
  
  

• 字符缓冲输出流新增的功能:换行

package com.qianxin.file;

import java.io.*;

public class FileCopyTest {
    public static void main(String[] args) {
        try(
                //追加管道
                Writer fw = new FileWriter("D:\\resource\\ab.txt",true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw)
        ){
            // 1、public void write(int c):写一个字符出去
            bw.write("a");
            bw.write( 97);
            bw.write('磊');// 写一个字符出去
            bw.newLine();

            // 2、public void write(String c)写一个字符串出去
            bw.write("我爱你中国abc");
            bw.newLine();;

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

1.2.3.3.3 缓冲流使用案例

• 拷贝出师表到另一个文件，并恢复顺序

   3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
   8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎;陛下亦宜自谋，以咨诹善道，察纳雅言，深追先
   4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
   2.宫中府中、但为一体，陇罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
   1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣!
   9.今当远离，临表涕零，不知所言。
   6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，狠自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆
   7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶。
   5.亲贤臣，远小人，此先汉所以兴隆也;亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞
  

package com.qianxin.file;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class FileCopyTest {
    public static void main(String[] args) {
        // 目标:恢复出师表的顺序到新文件中。
        try(
                // 2、创建缓冲字符输入输出流管道与源文件接通
                BufferedReader br = new BufferedReader(new FileReader("lianxi\\src\\com\\qianxin\\file\\1.txt"));
                BufferedWriter  bw = new BufferedWriter(new FileWriter("lianxi\\src\\com\\qianxin\\file\\2.txt"));

        ){
        
            //1、定义一个ArrayList集合存储每段内容
            List<String> list = new ArrayList<>();
            
            //3、按照行读取每段，存入到集合中去
            String line;
            while ((line = br.readLine()) != null){
                list.add(line);
            }
            
            //4、对List集合中的每段文章进行排序
            Collections.sort(list);
            
            // 5、遍历List集合的每段内容，依次写出去到新文件中。
            for (String ln : list) {
                bw.write(ln);
                bw.newLine();//换行
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

• 回复顺序并写入新的文件

   1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣!
   2.宫中府中、但为一体，陇罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
   3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
   4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
   5.亲贤臣，远小人，此先汉所以兴隆也;亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞
   6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，狠自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆
   7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶。
   8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎;陛下亦宜自谋，以咨诹善道，察纳雅言，深追先
   9.今当远离，临表涕零，不知所言。