批量转换文件字符集

操作步骤

• 先设置输入路径与输出路径

1. 输入路径：需要被转换的文件路径
2. 输出路径：转换后的文件储存路径
3. 我没有写这个属性的交互操作，只是在第一行用字面量进行设置

• 如果输出路径的目录不存在，则就会进行交互，是否创建该目录，如果不创建就退出程序
• 再是选择字符集转换的类型,是全部文件默认使用同一套字符集转换，还是一个一个文件的设置字符集类型转换
• 接着运行即可
  

代码如下

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

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

        //输入路径
        String inputPath = "C:\\Users\\hhhhh\\Desktop\\data";
        //输出路径
        String outputPath = "C:\\Users\\hhhhh\\Desktop\\data_out";

        File output = new File(outputPath);
        if (!output.exists()){
            System.out.println("指定的目录不存在是否要创建它？ y/n:");
            Scanner scanner = new Scanner(System.in);
            String YN = scanner.next();
            //如果输入y或Y九创建，否则不创建并退出程序
            if (YN.equalsIgnoreCase("y")){
                output.mkdir();
            }else {
                System.exit(-1);
            }
        }

        String charset1=null;
        String charset2=null;
        System.out.println("要指定默认字符集吗？ y/n");
        Scanner yn = new Scanner(System.in);
        String YN = yn.next();
        //如果输入y或Y九创建，否则不创建并退出程序
        if (YN.equalsIgnoreCase("y")){
            System.out.print("原字符集：");
            Scanner scanner1 = new Scanner(System.in);
            charset1 = scanner1.nextLine();
            System.out.print("\n要转换为：");
            Scanner scanner2 = new Scanner(System.in);
            charset2 = scanner2.nextLine();
        }

        //创建输入路径的File对象作为ergodic()方法的参数，用于遍历输入路径中要复制的文件。
        File input = new File(inputPath);
        //List，用于储存输入路径中的所有File对象。
        List<File> list = new ArrayList<>();
        ergodic(input,list);
        //将输入路径中的File对象，安装相应的路径复制到输出路径中，例如（A\a1\a2\a.txt --> B\a1\a2\a.txt）
        for (File f:list){
            if (charset1!=null && charset2!=null){
                createFile(f,inputPath,outputPath,charset1,charset2);
            }else {
                createFile(f,inputPath,outputPath);
            }
        }
    }
    /**
    用来判断当前File（文件或目录）是否存在，如果不存在就创建它，如果是文件则在创建后写入转换后的内容
    */
    public static void createFile(File file,String inputPath,String outputPath,String... charset) throws IOException {

        //对输入路径的文件路径做处理 例如输入路径为：input\a1\a2\a.txt
        //获取输入路径文件与指定目录的相对路径，  获取：a1\a2\a.txt
        String output = file.getPath().substring(inputPath.length()+1);
        //用于拼接输出路径
        StringBuilder sb = new StringBuilder();
        //切割 例如：上一步获取到 a1\a2\a.txt ，就需要对目录a1、a2进行判断是否存在，然后创建目录，否则会报错：找不到指定系统位置
        String[] str = output.split("\\\\");

        //拼接路径并判断是否存在，然后创建目录与文件
        for (int i=0;i<str.length;i++){
            //output\a1 是否存在，不存在就创建该目录；output\a1\a2是否存在，不存在就创建......
            sb.append("\\").append(str[i]);
            File dir = new File(outputPath+sb);
            System.out.println(dir.getPath());

            if (dir.exists()){
                System.out.println("existed");
            }else {
                //如果是有后缀名的文件，就创建文件并写进内容
                if (str[i].contains(".")){
                    dir.createNewFile();
                    //写出内容
                    if (charset.length==2){
                        //如果传入了字符集参数就默认全部以此为标准
                        outputWriterByte(file,dir,charset[0],charset[1]);
                    }else {
                        //如果没有，就挨个输入字符集
                        outputWriterByte(file,dir);
                    }

                    System.out.println("Create a file"+dir.getPath());
                }else {
                    dir.mkdir();
                    System.out.println("Create a directory"+dir.getPath());
                }
            }

        }
    }

/**
遍历输入路径中，需要被转换的文件，并将它们（File对象）储存在由用户提供的Liset<File>对象的ergodicResult里。
*/
    public static List<File> ergodic(File file, List<File> ergodicResult) {
        File[] files = file.listFiles();
        if (files == null){
            return ergodicResult;
        }

        for (File f : files) {
            if (f.isDirectory()) {
                ergodic(f, ergodicResult);
            } else
                ergodicResult.add(f);
        }
        return ergodicResult;
    }

/**
普通的转换流，添加了缓冲流优化。
*/
    public static void outputWriterByte(File input,File output,String... charset){

        FileInputStream fis;
        FileOutputStream fos;

        InputStreamReader isr = null;
        OutputStreamWriter osw = null;

        BufferedOutputStream bufferedOutputStream;
        BufferedInputStream bufferedInputStream;
        try {

            fis = new FileInputStream(input);
            fos = new FileOutputStream(output);


            bufferedInputStream = new BufferedInputStream(fis);
            bufferedOutputStream = new BufferedOutputStream(fos);

            String charsetName1;
            String charsetName2;

            if (charset.length==2){
                charsetName1=charset[0];
                charsetName2=charset[1];
            }else {
                System.out.print("转换之前的字符集:");
                Scanner scanner1 = new Scanner(System.in);
                charsetName1 = scanner1.nextLine();
                System.out.print("\n转换之后的字符集:");
                Scanner scanner2 = new Scanner(System.in);
                charsetName2 = scanner2.nextLine();
                System.out.println("---------------------------");
            }

            isr = new InputStreamReader(bufferedInputStream, charsetName1);
            osw = new OutputStreamWriter(bufferedOutputStream,charsetName2);
            
            //读多少写多少
            char[] cbuf = new char[20];
            int len;
            while ((len = isr.read(cbuf)) != -1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {

            try {
                if (isr!=null){
                    isr.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            try {
                if (osw!=null){
                    osw.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

其中的判断是否要创建的步骤如下：