针对IDE开发工具中所有文件出现乱码的解决方案

解决IDE或AndroidStudio中代码乱码的问题
如果IDE或者AndroidStudio中出现很多代码如java，xml文件出现了乱码的问题，虽然运行起来没问题，但是一定会感觉很不爽。所以我总结了具体的解决方案如下。
具体三步走，稳妥妥的搞定！

1.备份现有的项目：
先把当前的项目打包成zip文件，自己做好数据备份这应该不用多说吧。这样有后悔药可以吃。作为一名程序员，操作一定要谨慎。做到胆大心细，谨慎行事。因为数据无价嘛。

2.设置IDE，设置全局的编码格式：
有两种办法可以修改 IntelliJ IDEA或者android studio 的文件编码。

2.1 方案1：
File->Settings->Editor->File Encodings 这种方式修改的文件编码方式只对当前 project 起作用，每次新建了一个工程后还需要重新设置编码方式。
2.2 方案2：
File->Other Settings->Default Settings->Editor->File Encodings ，这儿设置的是默认的文件编码方式，所有新建的工程使用的都是默认的文件编码方式。

3.执行以下代码，让你的项目中所有代码恢复正常，代码我已独立开发完毕并开源分享给大家，有需求者自取 ：

import java.io.*;
import java.util.HashMap;
import java.util.Scanner;

import static com.yunzent.utils.ArrangeCodes.killCodeChaos;

public class CodeChaosKiller {
    public static void main(String[] args) {
        killCodeChaos();
    }
}

class ArrangeCodes {
    //  gradle vm option :   -Dfile.encoding=UTF-8
    private static final String WANT_ENCODING = "UTF-8";
    static HashMap<String, Boolean> suffix_map = null;
    static String append_str = "\n";
    static String[] suffix_list = {".java", ".xml", ".gradle", ".properties", ".pro", ".html"};

    public static void killCodeChaos() {
        ptl("本软件免责申明:不完全保证修复成功,请预先备份好原来的代码，然后开始操作!\n" +
                "在本界面输入要修复乱码的代码目录: ");
        Scanner scan = new Scanner(System.in);
        String code_dir = scan.next();

        ptl("请输入修复文件的 后缀名，如  \".java\"  ，如果是多个，需要用英文的 \",\"连接  。\n如果要忽略本步骤，输入 \"ignore\" , 然后回车");
        String suffix_str_list = scan.next();
        suffix_str_list = suffix_str_list.trim();

        if (!ifNullOrEmpty(suffix_str_list) && ("ignore".equalsIgnoreCase(suffix_str_list) || "".equals(suffix_str_list))) {
            //pass
            exec(code_dir, suffix_list);
        } else {
            if (!ifNullOrEmpty(suffix_str_list) && suffix_str_list.contains(".")) {
                if (suffix_str_list.contains(",")) {
                    suffix_list = suffix_str_list.split(",");
                } else {
                    suffix_list = new String[1];
                    suffix_list[0] = suffix_str_list;
                }
                exec(code_dir, suffix_list);
            } else {
                ptl("非文件后缀名！操作结束！");
                return;
            }
        }
    }

    public static void main(String[] args) {
        killCodeChaos();
    }


    public static void exec(String code_dir, String... suffix_list) {
        suffix_map = prepareSuffixMap(suffix_list);
        if (!ifNullOrEmpty(code_dir)) {
            File codeDir = new File(code_dir);
            recursionCheckExecEachInnerDir(codeDir);
        }
    }

    private static void recursionCheckExecEachInnerDir(File chkDirOrFile) {
        if (isDir(chkDirOrFile)) {
            ptl(chkDirOrFile.getAbsolutePath() + "  :目录");
            String[] file_list = chkDirOrFile.list();
            for (String file_path : file_list) {
                File f = new File(chkDirOrFile.getPath() + File.separator + file_path);
                recursionCheckExecEachInnerDir(f);
            }
        } else if (isFile(chkDirOrFile)) {
            if (ifThisFileNeedFix(chkDirOrFile.getPath(), suffix_map)) {
                ptl(chkDirOrFile.getAbsolutePath() + "  :文件   操作:修复");
                execFileFix(chkDirOrFile);
//                execFileFix(chkDirOrFile, append_str);
            } else {
                ptl(chkDirOrFile.getAbsolutePath() + "  :文件   操作:忽略");
            }
        } else {
            ptl(chkDirOrFile.getAbsolutePath() + "  :非有效目录，非文件");
        }
    }

    private static void execFileFix(File chkDirOrFile) { // , String append_str
        //执行 针对单个文件的修复操作
//        fileAppend( chkDirOrFile ,append_str ) ;
        fileReplaceWithNewFormat(chkDirOrFile, WANT_ENCODING);
    }

    private static void fileReplaceWithNewFormat(File chkDirOrFile, String format) {
//        FileReader fr = null;
        try {

            String str = FileUtil.readFile(chkDirOrFile);

//            fr = new FileReader(chkDirOrFile);
//            char[] buff = new char[10240000];
//            StringBuilder sb = new StringBuilder();
//            int len = 0;
//            while ((len = fr.read(buff)) != -1) {
//                char[] buff2 = diguiRemoveBom(buff,len) ;
//                sb.append(new String(buff2, 0, buff2.length ));
//            }
            ptl(sb.toString());
//            try {
//                fr.close();
//            } catch (Exception e) {
//            }

            FileUtil.writeFile(str, chkDirOrFile, false, format);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }

    private static char[] diguiRemoveBom(char[] buff, int readLen) {
        if (buff[0] == '\uFEFF') {
            char[] c2 = new char[readLen - 1];
            for (int i = 1; i <= readLen - 1; i++) {
                c2[i - 1] = buff[i];
            }
            return diguiRemoveBom(c2, readLen - 1);
        } else {
            return buff;
        }
    }

    private static void fileAppend(File chkDirOrFile, String append_str) {
        FileWriter fw = null;
        try {
            fw = new FileWriter(chkDirOrFile, true);
            fw.write(append_str);
            ptl(chkDirOrFile.getAbsolutePath() + " :修复完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.flush();
            } catch (Exception e) {
            }
            try {
                fw.close();
            } catch (Exception e) {
            }
        }
    }

    static void ptl(String msg) {
        System.out.println(msg);
    }

    static void pt(String msg) {
        System.out.print(msg);
    }

    static boolean isDir(File codeDir) {
        return (codeDir != null && codeDir.exists() && codeDir.isDirectory());
    }

    static boolean isFile(File codeFile) {
        return (codeFile != null && codeFile.exists() && codeFile.isFile());
    }

    static boolean ifNullOrEmpty(String str) {
        return (str == null || "".equals(str));
    }

    private static HashMap<String, Boolean> prepareSuffixMap(String[] suffix_list) {
        suffix_map = new HashMap<>();
        for (int i = 0; i <= suffix_list.length - 1; i++) {
            suffix_map.put(suffix_list[i], true);
        }
        return suffix_map;
    }

    static boolean ifThisFileNeedFix(String file_name, HashMap<String, Boolean> suffix_map) {
        String suffix = "";
        if (!ifNullOrEmpty(file_name) && file_name.contains(".")) {
            suffix = file_name.substring(file_name.lastIndexOf("."));
            if (suffix_map != null && suffix_map.size() >= 1 &&
                    suffix != null && suffix_map.get(suffix) != null &&
                    (suffix_map.get(suffix) == true)
            ) {
                return true;
            }
        }
        return false;
    }

}

工具类:

import org.mozilla.universalchardet.UniversalDetector;
import java.io.*;
public class FileUtil {
    public static void writeFile(String save_str, File save_file, boolean ifAppend, String format) throws Exception {
        try {
            if (save_file == null || !save_file.getParentFile().exists()) {
                save_file.getParentFile().mkdirs();
            }
//            BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(save_file ,ifAppend )) ;
//            bos.write(save_str.getBytes("UTF-8")   );
//            bos.flush();
//            bos.close();

            if (!ifAppend) {
                save_file.delete();
            }

            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(save_file.getAbsolutePath(), ifAppend), format));
//            \uFEFF              EF BB BF     有bom
            bw.write(save_str);
            try {
                bw.flush();
            } catch (Exception e) {
            }
            try {
                bw.close();
            } catch (Exception e) {
            }
            System.out.println("文件写入成功 : " + save_file);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
    }

    public static String readFile(File file) {
        try {
            String encode = getFileEncode(file);
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file), encode));
            StringBuffer sb = new StringBuffer();
            String tmp = "";
            while ((tmp = br.readLine()) != null) {
                sb.append(tmp).append("\n");
            }
            String res = sb.toString();
            System.out.println("文件读取成功 : " + res);
            return res;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 获得文件编码格式
     *
     * @param file
     * @return
     * @throws IOException
     */
    public static String getFileEncode(File file) throws IOException {
        FileInputStream in = new FileInputStream(file);
        String code = "utf-8";
        byte[] buf = new byte[4096];
        UniversalDetector detector = new UniversalDetector(null);

        int nread;
        while ((nread = in.read(buf)) > 0 && !detector.isDone()) {
            detector.handleData(buf, 0, nread);
        }
        detector.dataEnd();

        String encoding = detector.getDetectedCharset();
        if (encoding != null && !"".equals(encoding)) {
            code = encoding;
        }

        return code;
    }


//    public static String readFile(  File  file   ){
//        try {
//            BufferedInputStream bis = new BufferedInputStream( new FileInputStream( file   )   ) ;
//            byte[] buf = new byte[bis.available()];
//            int i; int cnt = 0 ;
//            while ((i = bis.read( )) != -1) {
//                buf[cnt++] = (byte) i;
//            }
//            String res = new String(buf , "UTF-8") ;
//            System.out.println("文件读取成功 : " + res);
//            return res ;
//        } catch (  Exception e) {
//            e.printStackTrace();
//            return "" ;
//        }
//    }

} 

感觉有用的伙伴点下关注或者赞嘛，谢谢了。有什么不足也欢迎大家指出。