文件太大导致jvm内存溢出，针对业务实现简易的大文件（txt）拆分执行功能

在日常完成业务过程中，出现了要在内存中操作很大的txt的需求，文件每行作为一条数据，但是由于数据量很大，不能一次性拉入内存中操作，但是又需要使用hashmap进行去重，于是借鉴hashmap的源码，编写了简易的大txt分桶执行操作。

BufferedFactory（写入、写出流工厂类）

/**
 * @author cliang.griffin
 * @description buffered工厂类
 * @date 2021/12/2
 */
@Slf4j
public class BufferedFactory {
    /**
     * 桶的全部文件写出流
     */
    private static HashMap<Integer,BufferedWriter> bufferedWriterHashMap = new HashMap<>();
    /**
     * 桶的全部文件写入流
     */
    private static HashMap<Integer, BufferedReader> bufferedReaderHashMap = new HashMap<>();
    /**
     * 桶路径设置
     */
    private static String filePath;

    /**
     * 设置文件路径
     * @param filePath 文件路径
     */
    public static void setFilePath(String filePath){
        BufferedFactory.filePath = "D:\\临时统计\\"+filePath;
    }
    /**
     * 获取该桶绑定的写出流
     * @param n 桶
     * @return 写出流
     */
    public static BufferedWriter getBufferedWriter(int n,String fileName){
        new File(filePath).mkdir();
        if (!bufferedWriterHashMap.containsKey(n)){
            try {
                bufferedWriterHashMap.put(n,new BufferedWriter(new FileWriter(filePath+"\\"+fileName+n+".txt")));
            } catch (IOException e) {
                log.error("创建写出流失败："+filePath+n);
            }
        }
        return bufferedWriterHashMap.get(n);
    }

    /**
     * 操作结束后关闭所有写出流
     */
    public static void closeBufferedWriter(){
        bufferedWriterHashMap.forEach((key,value)->{
            try {
                value.close();
            } catch (IOException e) {
                log.error("第"+key+"个桶绑定的写出流关闭异常");
            }
        });
    }
    /**
     * 获取该桶绑定的写出流
     * @param n 桶
     * @param filename 桶中的文件名称
     * @return 写出流
     */
    public static BufferedReader getBufferedReader(int n,String filename){
        if (!bufferedReaderHashMap.containsKey(n)){
            try {
                bufferedReaderHashMap.put(n,new BufferedReader(new FileReader(filePath+"\\"+filename+n+".txt")));
            } catch (IOException e) {
                log.error("创建写出流失败："+filePath+"\\"+filename+n+".txt");
            }
        }
        return bufferedReaderHashMap.get(n);
    }

    /**
     * 操作结束后关闭所有读取流
     */
    public static void closeBufferedReader(){
        bufferedReaderHashMap.forEach((key,value)->{
            try {
                value.close();
            } catch (IOException e) {
                log.error("第"+key+"个桶绑定的写入流关闭异常");
            }
        });
    }
}

大文件分隔、批量执行桶中文件操作工具类

/**
 * @author cliang.griffin
 * @description 大文件拆分工具
 * @date 2021/12/17
 */
@Slf4j
public class BigFileSplitUtil {
    /**
     * 大文件拆分方法
     * @param filename 文件名
     * @param n 需要拆分到多少个桶中
     * @param bucketName 桶名
     * @param bucketFilename 每个桶中生成的文件叫什么
     * @param index 按照那个字段做hash
     */
    public static void splitBigTxt(String filename,String bucketName,String bucketFilename,int n,int index){
        try(BufferedReader bufferedReader = new BufferedReader(new FileReader(filename))) {
            String zzqData;
            int i = 0;
            while (!StringUtils.isEmpty(zzqData = bufferedReader.readLine())){
                final String[] split = zzqData.split("~\\$");
                //放入哪个桶中
                BufferedFactory.setFilePath(bucketName);
                final BufferedWriter bufferedWriter = BufferedFactory.getBufferedWriter((n - 1) & (split[index].hashCode()),bucketFilename);
                bufferedWriter.write(zzqData+"\n");
                System.out.println("第"+ i++ +"条数据分桶成功");
            }
        }catch (IOException e){
            log.error("分桶失败",e);
        }finally {
            BufferedFactory.closeBufferedWriter();
        }
    }

    /**
     * 遍历桶中文件并进行相关操作。
     * @param bucketName 桶名
     * @param bucketFilename 桶中文件名
     */
    public static void bucketExecute(String bucketName,String bucketFilename,int n,BucketFileForExecute bucketFileForExecute){
        try {
            BufferedFactory.setFilePath(bucketName);
            for (int i = 0; i < n; i++) {
                bucketFileForExecute.execute(BufferedFactory.getBufferedReader(i, bucketFilename));
            }
        } finally {
            BufferedFactory.closeBufferedReader();
        }
    }

}

批量执行桶中代码的函数式接口（不喜欢使用函数式接口的也可以不封装这个方法）

/**
 * @author cliang.griffin
 * @description 桶中文件要如何操作函数式接口
 * @date 2021/12/17
 */
public interface BucketFileForExecute {
    /**
     * 桶中文件要如何操作函数式接口
     * @param bufferedReader 桶中文件写出流
     */
    void execute(BufferedReader bufferedReader);
}