java-文件分割

最新推荐文章于 2024-04-24 22:51:49 发布
最新推荐文章于 2024-04-24 22:51:49 发布
阅读量1.4k 收藏 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!

重生之我是一名程序员
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java实现文件分割(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 305
java实现文件分割(附完整源码)
Java实现文件分割和文件合并实例
01-21
文件切割和文件合并这个问题困扰了我有一段时间了（超过一天没做粗来）。 找了好多博客，本来想转载一个来的 结果找不到了。很无奈。 只好自己贴代码上了。 当然我会尽力好好写注释的。 文件切割器: import java.io...
JAVA编程-分割合并文件-jar包中含源码
12-28
此资源是为了将存储空间较大的文件分割成多个较小的文件。可以将分割后的多个较小的文件合并成一个较大的文件。 可以帮助我们采用分而治之的思想，将大文件上传到网盘上。
用Java将一个文件拆分成多个文件
cxzos8i17的博客
07-11 2171
今天看视频，学到了一个新的操作，就是用Java将一个文件进行拆分成多个文件，我觉得很神奇，通过这篇博客我将记录一下如何一步步进行拆分，也希望以后做项目时候可以用到这一次操作。总结：拆分文件需要循序渐进一步步来，代码逻辑是不能乱的，对于初学者的我来说，拆分文件如果不一步步捋清楚代码逻辑，画好流程图，自己是很难一步步写出来的。下面我用蛋糕的例子举例，将一个文件名为蛋糕.txt，大小为若干kb的文件拆分为若干个小蛋糕，每个蛋糕为的大小可自定义。运行后，可见文件刚好被拆分为6个小蛋糕文件。
Java中split()分割拆分字符串的方法
weixin_42098295的博客
02-17 1073
split()方法是String类的一个方法，用于根据给定的正则表达式将字符串分割成子字符串数组。类的一个方法，用于根据给定的正则表达式将字符串分割成子字符串数组。参数是正则达式，一般情况下，分割字符串参考字符串就行，不用考虑正则表达式。//输出[b, , :and:f, , ]//输出[b, , :and:f, , ]//输出[boo, and, foo]//输出[boo, and, foo]//输出[boo, and:foo]//输出[b, , :and:f]//保留在前面子字符串中。
Java调用linux脚本实现文件分割合并上传
codeLife1993的博客
05-06 287
优化前：因项目部署在内网环境，只有部分服务可以外网访问。之前部署项目，需要在本地打包，上传到运维机连vpn上传到内网服务器，通过脚本启动。
使用Java分割PDF文件
一起coding，一起嗨。
11-06 1612
在Java中，我们可以使用iText库来处理PDF文件。iText是一个流行的Java库，用于创建和处理PDF文件。在本篇博客中，我们将介绍如何使用Java分割一个PDF文件为多个小的PDF文件。
java 拆分文件
wei_feng__的博客
02-26 1858
场景：某个文件数据比较多，但是需要拆分成多份，手动拆有点太浪费时间，所以写了一个小脚本。 思路： 1. 拿到文件，最做一些简单的检验，在拿到要拆分的数量 2. 得到文件的总行数，除以要拆分的个数，得到每个文件应该存多少行，不能整除多余出来的数据放到最后一个文件中 3. 一行一行读取，先写第一个文件，写到了应该写入的行数，结束 写下一个
使用Java分割大文件
博客
10-24 2661
在window系统中有一个大文件需要查看，但是没有像Linux那样的工具命令，所以自己写了一个，目前只能按行切割。
JAVA实现文件拆分与合并
qq_45663499的博客
09-14 1162
将大文件拆分成多个小文件，每个小文件的大小可以自定义，这样可以方便传输，也可以方便存储。将多个小文件合并成一个大文件，这样可以方便存储，也可以方便传输。读取数据源文件，将读取到的字节写入到目的地文件。读取数据源文件，将读取到的字节写入到子文件。创建一个文件输入流对象，关联数据源文件。创建一个文件输出流对象，关联目的地文件。创建一个文件输入流对象，关联数据源文件。创建一个文件输出流对象，关联子文件。会有多个子文件，所以需要使用循环。会有多个子文件，所以需要使用循环。
java实现大文件的拆分与合并
abments的博客
06-09 4663
java实现大文件的分割与合并
java实现把一个大文件切割成N个固定大小的文件
weixin_34405557的博客
03-21 269
这个好像是我一年前去面试时的一道面试题，分享一下！考 java I/O 的！ //java实现把一个大文件切割成N个固定大小的文件packagecom.johnny.test;importjava.io.BufferedReader;importjava.io.File;importjava.io.FileInputStream;importjava.i...
Java实现文件分割与合并
08-19
主要介绍了Java实现文件分割与合并，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java文件分割压缩
03-08
java 版的文件分割压缩 可以对大文件进行拆分。 文件大小可定义
string模拟实现
m0_73969414的博客
04-23 1388
c++中string的模拟实现，面试必会知识点
javaweb-SpringBoot基础
kussm_的博客
04-20 1288
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
Java | 冒泡排序算法实现
最新发布
yingzix688的博客
04-24 689
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
JUC(java.util.concurrent) 的常见类
weixin_43497876的博客
04-20 1326
Callable 是一个 interface（类似之前的 Runnable，用来描述一个任务，但是没有返回值）也是描述一个任务的，有返回值。方便程序猿借助多线程的方式计算结果.创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable。
Java中如何实现minio文件上传
Keep__Me的博客
04-19 1292
前面已经在docker中部署了minio服务，那么该如何在Java代码中使用？这篇说下minio在Java中的配置跟使用。
java实现文件分割_java 实现文件分割
06-07
Java中可以使用RandomAccessFile类来实现文件分割。具体步骤如下： 1. 创建一个RandomAccessFile对象，指定要分割的文件和读写模式。 2. 获取文件总长度，计算出每个分割文件的长度。 3. 循环读取原文件，每读取到一个分割文件长度的数据就将其写入一个新文件中。 4. 关闭所有文件流。 下面是一个简单的Java文件分割示例代码： ```java import java.io.*; public class FileSplitter { public static void main(String[] args) { String sourceFile = "D:/sample.txt"; // 原文件名 String targetFolder = "D:/split/"; // 分割文件存放目录 int fileSize = 1024 * 1024; // 分割文件大小，这里为1MB try { // 创建RandomAccessFile对象 RandomAccessFile raf = new RandomAccessFile(sourceFile, "r"); // 获取文件总长度 long totalSize = raf.length(); // 计算分割文件数 int fileCount = (int) Math.ceil((double) totalSize / fileSize); // 循环读取原文件并写入分割文件 byte[] buffer = new byte[fileSize]; int len; for (int i = 0; i < fileCount; i++) { // 创建分割文件 File targetFile = new File(targetFolder + "part" + i); RandomAccessFile targetRaf = new RandomAccessFile(targetFile, "rw"); // 读取并写入分割文件 while ((len = raf.read(buffer)) != -1) { targetRaf.write(buffer, 0, len); if (targetRaf.length() >= fileSize) { break; } } // 关闭分割文件流 targetRaf.close(); } // 关闭原文件流 raf.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 以上代码将一个名为sample.txt的文件分割成1MB大小的多个文件，并存放在D:/split目录下。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值