java-文件分割

最新推荐文章于 2024-09-29 13:17:17 发布
最新推荐文章于 2024-09-29 13:17:17 发布
阅读量1.8k 收藏 9
点赞数 1
分类专栏： springmvc 文章标签： java
原文链接：https://editor.csdn.net/md?not_checkout=1&articleId=131114711
版权

java-文件分割

在进行 minio 大文件上传时，需要用到文件分割，找了一圈没有合适的，于是造了一个轮子

原理

运用 RandomAccessFile 操作文件

文件分割

采用多线程方式

FileSplitRunnable

线程处理文件分割

@Slf4j
public class FileSplitRunnable implements Runnable {
    private static final int READ_BYES = 2*1024;

    /**
     * 要分割的文件
     */
    private File originFile;
    /**
     * 文件分割起始位置
     */
    private long startPosition;
    /**
     * 每个分割文件大小
     */
    private long totalSize;
    /**
     * 分割文件名称
     */
    private String filePartName;
    /**
     * 文件分割同步器
     */
    private FileTask task;


    public FileSplitRunnable(File originFile, long startPosition, long totalSize, String filePartName, FileTask task) {
        this.originFile = originFile;
        this.startPosition = startPosition;
        this.totalSize = totalSize;
        this.filePartName = filePartName;
        this.task = task;
    }

    @Override
    public void run() {
        log.info("{} split file {} start at position {}", Thread.currentThread().getName(), filePartName, startPosition);
        RandomAccessFile accessFile = null;
        FileOutputStream fos = null;
        long remian = totalSize;
        byte[] b = new byte[READ_BYES];
        int read = 0;
        try {
            //采用追加模式
            accessFile = new RandomAccessFile(originFile, "r");
            accessFile.seek(startPosition);
            fos = new FileOutputStream(filePartName, true);
            while (remian > 0 && read!=-1) {
                log.info("{} read size {} remain {}", Thread.currentThread().getName(), read, remian);
                if (remian < READ_BYES) {
                    b = new byte[(int) remian];
                    read = accessFile.read(b);
                    if (read!=-1){
                        fos.write(b, 0, read);
                        remian = 0;
                    }
                }
                read = accessFile.read(b);
                if (read!=-1){
                    fos.write(b, 0, read);
                    remian -= READ_BYES;
                }
            }
            fos.flush();
            //增加成功
            task.taskDoneIncr();
        } catch (IOException e) {
            throw new RuntimeException("file split error" + filePartName);
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
                if (accessFile != null) {
                    accessFile.close();
                }
            } catch (IOException e) {
                log.error("###### FileSplitRunnable file close error", e);
            }
            task.countDown();
        }
    }
}
FileTask 文件同步器
public class FileTask {
    private CountDownLatch latch;
    private int task;
    private AtomicInteger cnt = new AtomicInteger(0);

    public FileTask(int tasks) {
        this.task = tasks;
        this.latch = new CountDownLatch(tasks);
    }

    /**
     * 带超时时间的等待任务超时
     * @param timeOut 超时时间
     * @param timeUnit
     * @return
     * @throws InterruptedException
     */
    public boolean await(long timeOut, TimeUnit timeUnit) throws InterruptedException {
        return latch.await(timeOut, timeUnit);
    }

    /**
     * 等待任务直到完成
     * @throws InterruptedException
     */
    public void await() throws InterruptedException {
        latch.await();
    }

    /**
     * 查询任务是否结束
     * @return
     */
    public boolean isDone() {
        try {
            boolean await = await(0, TimeUnit.MILLISECONDS);
            return await && (cnt.get() == task);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 任务减一
     */
    public void countDown() {
        latch.countDown();
    }

    /**
     * 当任务完成没有异常时+1
     * 即完成成功的任务
     */
    public void taskDoneIncr() {
        cnt.getAndIncrement();
    }

}

文件合并

FileMergeRunnable
public class FileMergeRunnable implements Runnable {

    private static final int READ_BYES = 2 * 1024;
    /**
     * 合并后的新文件名称
     */
    private String finalFileName;
    /**
     * 每个文件开始合并的位置
     */
    private long startPosition;
    /**
     * 分片文件
     */
    private File partFile;

    /**
     * 文件同步器
     */
    private FileTask task;

    public FileMergeRunnable(String finalFileName, long startPosition, File partFile, FileTask task) {
        this.finalFileName = finalFileName;
        this.startPosition = startPosition;
        this.partFile = partFile;
        this.task = task;
    }

    @Override
    public void run() {
        log.info("{} merge file {} at position {}", Thread.currentThread().getName(), partFile.getName(), startPosition);
        RandomAccessFile accessFile = null;
        FileInputStream fis = null;
        try {
            accessFile = new RandomAccessFile(finalFileName, "rw");
            accessFile.seek(startPosition);
            byte[] b = new byte[READ_BYES];
            int len = 0;
            fis = new FileInputStream(partFile);
            while ((len = fis.read(b)) != -1) {
                accessFile.write(b, 0, len);
            }
            task.taskDoneIncr();
        } catch (IOException e) {
            log.error("######### FileMergeRunnable merge error", e);
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
                if (accessFile != null) {
                    accessFile.close();
                }
            } catch (IOException e) {
                log.error("######### FileMergeRunnable merge close error", e);
            }
            task.countDown();
        }
    }
}

FileSpliter

文件分割，合并工具类

@Slf4j
public class FileSpliter {

    /**
     * 文件分割
     *
     * @param fileName     原始文件
     * @param perPartBytes 每个文件大小: byte
     * @param executor
     * @return
     */
    public static List<String> split(String fileName, int perPartBytes, ThreadPoolExecutor executor) {
        Assert.notNull(executor, "executor must not null!!");
        File inputFile = new File(fileName);
        List<String> list = new ArrayList<>();
        String filePartNameSuffix = fileName.concat(".part");
        //向上取整, 如果不使用double类型的话，计算出来是整数，
        int count = (int) Math.ceil(inputFile.length() / (double)perPartBytes);
        FileTask task = new FileTask(count);
        for (int i = 0; i <= count; i++) {
            String filePartName = filePartNameSuffix.concat(i + "");
            FileSplitRunnable runnable = new FileSplitRunnable(inputFile, i * perPartBytes, perPartBytes, filePartName, task);
            if (executor != null) {
                executor.execute(runnable);
                list.add(filePartName);
            }
        }
        try {
            task.await();
        } catch (InterruptedException e) {
            throw new RuntimeException("File Split error", e);
        }
        log.info("file split is done:  " + task.isDone());
        return list;
    }

    /**
     * 文件分片合并
     *
     * @param finalFileName      最终合并文件名称
     * @param path:              分片文件所在目录
     * @param partFileNamePrefix 分片文件前缀
     * @param executor
     * @return
     */
    public static String merge(String finalFileName, String path, String partFileNamePrefix, ThreadPoolExecutor executor) {
        Assert.notNull(executor, "executor must not null!!");
        File tmp = new File(finalFileName);
        try {
            tmp.createNewFile();
        } catch (IOException e) {
            log.error("create merge file error", e);
            throw new RuntimeException(e);
        }
        //搜索该路径下partFileNamePrefix前缀文件，即分片文件
        List<File> partFiles = getPartFiles(path, partFileNamePrefix);
        merge(finalFileName, partFiles, executor);
        return finalFileName;
    }

    /**
     * 分片文件合并
     *
     * @param finalFileName 合并后的新文件
     * @param partFiles     分片文件
     * @param executor
     * @return
     */
    public static String merge(String finalFileName, List<File> partFiles, ThreadPoolExecutor executor) {
        if (CollectionUtil.isEmpty(partFiles)) {
            throw new RuntimeException("合并文件不能为空");
        }
        Assert.notNull(executor, "executor must not null!!");
        File tmp = new File(finalFileName);
        try {
            if (!tmp.exists()) {
                tmp.createNewFile();
            }
        } catch (IOException e) {
            log.error("create merge file error", e);
            throw new RuntimeException(e);
        }
        //排序,按照分割的顺序
        Collections.sort(partFiles, (o1, o2) -> {
            if (o1.getName().compareTo(o1.getName()) < 0) {
                return -1;
            }
            return 1;
        });
        partFiles.stream().forEach(a -> System.out.println(a.getName()));
        int count = partFiles.size();
        FileTask task = new FileTask(count);
        long perPartFileSize = partFiles.get(0).length();
        for (int i = 0; i < count; i++) {
            FileMergeRunnable mergeRunnable = new FileMergeRunnable(finalFileName, i * perPartFileSize, partFiles.get(i), task);
            executor.execute(mergeRunnable);
        }
        try {
            task.await();
        } catch (InterruptedException e) {
            throw new RuntimeException("File merge error", e);
        }
        log.info("file merge is done:  " + task.isDone());
        //合并完成后删除
        partFiles.stream().forEach(f -> f.delete());
        return finalFileName;
    }


    /**
     * 查找该路径下前缀是 partFileNamePrefix 的文件
     *
     * @param path
     * @param partFileNamePrefix
     * @return
     */
    private static List<File> getPartFiles(String path, String partFileNamePrefix) {
        File dir = new File(path);
        File[] files = dir.listFiles((dir1, name) -> {
            String prefix = partFileNamePrefix.toLowerCase();
            return name.toLowerCase().startsWith(prefix);
        });
        return Arrays.stream(files).filter(f -> f.isFile()).collect(Collectors.toList());
    }

}

测试

public class FileTest {

    //文件分割
    @Test
    public void splitFileTest() {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        String fileName = "F:\\test\\Java核心技术卷.pdf";
        List<String> split = FileSpliter.split(fileName, 30 * 1024 * 1024, executor);
        System.out.println(split);
        executor.shutdown();
    }

    @Test
    public void mergeFileTest() {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        String finalFileName = "F:\\test\\Java核心技术卷-NEW.pdf";
        String path = "F:\\test";
        String prefix = "Java核心技术卷.pdf.part";
        FileSpliter.merge(finalFileName, path, prefix, executor);
        executor.shutdown();
    }


    //视频分割
    @Test
    public void splitVideoTest() {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        String fileName = "F:\\test\\测试.mp4";
        List<String> split = FileSpliter.split(fileName, 30 * 1024 * 1024, executor);
        System.out.println(split);
        executor.shutdown();
    }

    @Test
    public void mergeVideoTest() {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        String finalFileName = "F:\\test\\测试-NEW.mp4";
        String path = "F:\\test";
        String prefix = "测试.mp4.part";
        FileSpliter.merge(finalFileName, path, prefix, executor);
        executor.shutdown();
    }
}

分割测试:

在这里插入图片描述

合并测试：

在这里插入图片描述

也可以正常打开

good luck!

重生之我是一名程序员
关注
专栏目录
14-Java操作Linux命令分割合并文本文件1
08-08
5、合并文件使用的Linux命令是：cat /home/leo/sd_000.txt /home/leo/sd_001.txt /home/leo/sd_002
java：大数据文件写入，读取，分割，排序，合并
qiaolevip的专栏
05-17 2937
package arrays.file;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;im
java分片工具类（ShardingUtils）
最新发布
Flying_Fish_roe的博客
09-29 979
是一个通用的分片工具类，支持多种分片方式，包括取模分片、范围分片和哈希分片。它能够帮助开发者在分布式系统中对任务、数据、请求等进行均衡分配，从而提高系统的并发能力和可扩展性。通过自定义分片策略，开发者可以根据业务需求灵活调整分片逻辑。
用Java将一个文件拆分成多个文件
cxzos8i17的博客
07-11 3317
今天看视频，学到了一个新的操作，就是用Java将一个文件进行拆分成多个文件，我觉得很神奇，通过这篇博客我将记录一下如何一步步进行拆分，也希望以后做项目时候可以用到这一次操作。总结：拆分文件需要循序渐进一步步来，代码逻辑是不能乱的，对于初学者的我来说，拆分文件如果不一步步捋清楚代码逻辑，画好流程图，自己是很难一步步写出来的。下面我用蛋糕的例子举例，将一个文件名为蛋糕.txt，大小为若干kb的文件拆分为若干个小蛋糕，每个蛋糕为的大小可自定义。运行后，可见文件刚好被拆分为6个小蛋糕文件。
使用JAVA分割文本文件
qq_37141819的博客
12-30 660
static void splitFile(int fileCount){ try (FileReader read = new FileReader("D:\\新建文件夹\\learn_emp.sql"); BufferedReader br = new BufferedReader(read)) { List&lt;File...
用Java实现大文件的分割与合并
Swift's Blog
05-07 1473
我们平时在发送文件或上传文件的时候会遇到文件大小的限制。如果文件过大，那么我们就可以将其分割，由接收方来将这些文件合并。其本质不过就是文件的读写操作。文件的分割public static void Split(String SrcFilePath,int SingleGoalFileSize,String GoalFileDirectory){//SingleGoalFileSize单位：M
java 分割文件 将大文件分割成小文件
10-21
Java 对现有的大文件按文件大小或是按生成日期进行分割
用java实现任意文件分割
04-13
此文件分割合并工具小于10KB，比一般此类工具小很多，速度也很快。支持分割任意文件类型。
java 把大文件分割为小文件
08-04
java 把大文件分割为小文件
java 拆分文件
wei_feng__的博客
02-26 2323
场景：某个文件数据比较多，但是需要拆分成多份，手动拆有点太浪费时间，所以写了一个小脚本。 思路： 1. 拿到文件，最做一些简单的检验，在拿到要拆分的数量 2. 得到文件的总行数，除以要拆分的个数，得到每个文件应该存多少行，不能整除多余出来的数据放到最后一个文件中 3. 一行一行读取，先写第一个文件，写到了应该写入的行数，结束 写下一个
java分割文件
qq_51216500的博客
08-03 273
package com.xpdf.demo.controller; import com.itextpdf.text.Document; import com.itextpdf.text.pdf.PdfContentByte; import com.itextpdf.text.pdf.PdfImportedPage; import com.itextpdf.text.pdf.PdfReader; import com.itextpdf.text.pdf.PdfWriter; import org.apach
java将大文件分成若干个小文件
05-03
把一个大的文本文件按文件大小分成若干个小文件
用JAVA实现文件的分割
03-23
用JAVA来实现文件的分割，还有一些例子供参考。
JAVA编程-分割合并文件-jar包中含源码
12-28
在Java编程中，有时我们需要处理大文件，例如为了节省存储空间、提高传输效率或适应某些系统限制，可能需要将大文件分割成多个小文件。这个资源包提供了实现这一功能的代码，同时也支持将这些小文件合并回原始的大...
java-ipfs-http-client-master_ipfs_java-ipfs_java_
09-29
这意味着文件被分割成小块，并用其内容的哈希值标识，这样即使原始存储位置发生变化，只要数据块的内容不变，文件仍然可以被找到。这种设计提高了数据的持久性和可用性，同时也为P2P文件共享提供了基础。 使用Java ...
Java实现按行分割大文件
08-19
Java实现按行分割大文件 Java实现按行分割大文件是指将一个大的文本文件按行分割成几个小文件的过程。这个过程可以使用Java语言来实现，本文将详细介绍Java实现按行分割大文件的方法。 知识点1: Java中读取大文件...
Java实现文件分割与合并
08-19
在Java编程中，文件分割与合并是常见的文件处理任务，特别是在大数据处理、文件传输或存储优化等场景。本文将详细讲解如何使用Java实现文件的分割与合并，通过提供的示例代码进行深入解析。 首先，文件操作是Java I...
使用Java分割大文件
博客
10-24 2756
在window系统中有一个大文件需要查看，但是没有像Linux那样的工具命令，所以自己写了一个，目前只能按行切割。
Java_文件分割
weixin_42701392的博客
12-28 369
** Java_文件分割 ** 这里运用RandomAccessFile随机流以及面向对象的封装思想 import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.util.ArrayList; import java.util.List; /** * 面向对象思想分装...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值