前言：

在前面我们为大家介绍了FILE类和IO类。这篇文章我们来练习一些综合使用的例子以此来巩固我们自己的所学知识。

1.拷贝文件（含子文件）

思路：

建立一个读文件的流来读取文件，一个写文件的流来创建文件，整体建立框架为：如果是文件夹就建立一个文件夹，并且继续向内访问，如果是文件就进行拷贝复制。

import java.io.*;

public class file3 {
    public static void main(String[] args) throws IOException {
        //1.创建对象表示数据源
        File src = new File("D:\\aaa\\bbb");

        //2.创建对象表示目的地
        File dest = new File("D:\\aaa\\dest");

        //3.开始拷贝
        copydir(src,dest);
    }

    private static void copydir(File src, File dest) throws IOException {
        dest.mkdirs();
            //递归
        //1.进入数据源
        File[] files = src.listFiles();
        //依次便利数组
        for (File file : files) {
            if(file.isFile())
            {
                //如果是文件就拷贝
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));
                byte[]bytes = new byte[1024];
               int len;
                while((len=fis.read(bytes))!=-1)
                {
                    fos.write(bytes,0,len);
                }
                fos.close();
                fis.close();
            }
            else {
                //如果是文件夹就递归
                copydir(file,new File(dest,file.getName()));
            }
        }
    }
}

2.文件加密

思路：

加密原理：对原始文件中的每一个字节数据进行更改，然后将已经更改后的数据存储到一个新的文件之中。

解密原理：读取解密之后的文件，按照加密的规则反向操作，变成原始文件。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class file4 {
    public static void main(String[] args) throws IOException {
        //1.创建对象关联原始文件
        FileInputStream fis = new FileInputStream("c.txt");

        //创建对象关联加密文件
        FileOutputStream fos = new FileOutputStream("jiami.txt");

        //进行加密
        int b;
        while((b=fis.read())!=-1);
        {
            fos.write(b^2);
        }
        fos.close();
        fis.close();


        //进行解密
        //1.创建对象关联原始文件
        FileInputStream fis1 = new FileInputStream("jiami.txt");

        //创建对象关联加密文件
        FileOutputStream fos1 = new FileOutputStream("jiemi.txt");

        //进行解密
        int b1;
        while((b1=fis1.read())!=-1);
        {
            fos1.write(b1^2);
        }
        fos1.close();
        fis1.close();
    }
}

需要注意的是：这种更改字节数据的加密方式我们一般使用位运算进行更改，这样可以避免我们因为对字节数据进行算数运算而导致的溢出现象报错。

3.修改文件中的数据：

文本文件中有以下数据：

2-1-9-4-7-8

将文本中的数据进行排序输出，变为以下数据：

1-2-4-7-8-9

思路：

先切割字符串，然后得到数字再排序，最后再创建新文件录入。

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

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

        //1.读取数据并拼接成为一个字符串进行操作
        FileReader fr = new FileReader("c.txt");

        StringBuilder sb = new StringBuilder();

        int ch;
        while((ch=fr.read())!=-1)
        {
            sb.append((char) ch);
        }

        fr.close();

        //2.排序

          String s= sb.toString();
        String[] arrstr = s.split("-");

        ArrayList<Integer> list = new ArrayList<>();
        for (String s1 : arrstr) {
            int i = Integer.parseInt(s1);
            list.add(i);

        }

        Collections.sort(list);

        //向新文件写入数据
        FileWriter fw = new FileWriter("b.txt");

        for(int i=0;i<list.size();i++)
        {
            if(i==list.size()-1)
            {
                fw.write(list.get(i)+"");
            }
            else {
                fw.write(list.get(i)+"-");
            }
        }
        fw.close();
    }
}

其实我们可以在排序阶段进行优化，使用我们之前学习的Stream流的知识。

   Integer[] array = Arrays.stream(sb.toString()
                            .split("-"))
                            .map(Integer::parseInt)
                            .sorted()
                            .toArray(Integer[]::new);