Java生产环境通用的文件处理工具类

已于 2024-06-03 14:58:44 修改
阅读量352 收藏 4
点赞数 3
文章标签： java 开发语言
于 2024-05-09 21:08:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Geralt_of_theone/article/details/138631605
版权

保持更新ing…

package com.unitechs.rest.util;

import com.unitechs.framework.logger.Logger;
import com.unitechs.framework.logger.LoggerFactory;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Map;
import java.util.zip.CRC32;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * 通用的文件操作工具类
 */
public class FileUtil {

    private static final int BUFFER_SIZE = 1024;

    /**
     * 递归zip
     *
     * @param zipOut
     * @param fileName
     * @throws IOException
     */
    public static void zip(ZipOutputStream zipOut, String fileName)
            throws IOException {
        File srcFileName = new File(fileName);
        if (srcFileName.isDirectory()) {
            // 如果是文件夹，遍历下面的文件
            File[] files = srcFileName.listFiles();
            for (File file : files) {
                zip(zipOut, file.getAbsolutePath());
            }
        } else {
            // 创建文件输入流对象
            String encode = "ISO8859_1";
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    new FileInputStream(srcFileName), encode));
            // 创建指向压缩原始文件的入口
            ZipEntry entry = new ZipEntry(srcFileName.getName());
            zipOut.putNextEntry(entry);
            // 向压缩文件中输出数据
            int nNumber;
            while ((nNumber = in.read()) != -1) {
                zipOut.write(nNumber);
            }
            in.close();
        }
    }

    /**
     * 由于java.util.zip.ZipOutputStream有中文乱码问题，
     * 所以采用org.apache.tools.zip.ZipOutputStream。
     */
    public static void zip(String zipFileName, String srcFileName) throws IOException {
        ZipOutputStream zipOut = null;
        try {
            // 创建文件输出流对象
            FileOutputStream f = new FileOutputStream(new File(zipFileName));

            CheckedOutputStream ch = new CheckedOutputStream(f, new CRC32());
            // 创建ZIP数据输出流对象
            zipOut = new ZipOutputStream(new BufferedOutputStream(ch));
            // 调用打包的方法
            zip(zipOut, srcFileName);
        } finally {
            if (zipOut != null) zipOut.close();
        }
    }

    /**
     * 获取文件内容
     *
     * @param path 文件路径
     * @return 文件内容
     */
    public static String getFileContent(String path) {
        StringBuilder sb =  new StringBuilder();
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader(path));
            String line;
            String lineSeparator = System.lineSeparator();
            while ((line = br.readLine()) != null) {
                sb.append(line).append(lineSeparator);
            }
        } catch (IOException e) {
            log.error("获取" + path + "文件内容失败:", e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {

                }
            }
        }
        return sb.toString();
    }

    /**
     * 创建文件
     *
     * @param fileName    文件名
     * @param fileContent 文件内容
     */
    public static void createFile(String fileName, String fileContent) {
        RandomAccessFile mneRaf = null;
        FileChannel mneChannel = null;
        ByteBuffer byteBuffer = null;
        try {
            mneRaf = new RandomAccessFile(fileName, "rw");
            mneChannel = mneRaf.getChannel();
            byteBuffer = ByteBuffer.allocate(fileContent.getBytes().length);
            byteBuffer.put(fileContent.getBytes());
            byteBuffer.flip();
            while (byteBuffer.hasRemaining()) {
                mneChannel.write(byteBuffer);
            }
        } catch (IOException e) {
            log.error(e);
        } finally {
            if (byteBuffer != null) {
                byteBuffer.clear();
            }
            try {
                if (mneRaf != null) {
                    mneRaf.close();
                }
            } catch (IOException e) {
                log.error(e);
            }
            try {
                if (mneChannel != null) {
                    mneChannel.close();
                }
            } catch (IOException e) {
                log.error(e);
            }
        }
    }

    /**
     * 修改tar包中的文件名，需要传入 源文件名及对应的目标文件名map
     * 会破坏原有的目录结构，不会保留子文件夹目录，只会提取其中文件
     * @param sourcedir
     * @param targetdir
     * @param nameMap
     * @throws IOException
     */
    public static void modifyTarGzFileName(String sourcedir, String targetdir, Map<String, String> nameMap) throws IOException {
        Path sourcePath = Paths.get(sourcedir);
        Path targetPath = Paths.get(targetdir);
        if (!Files.exists(sourcePath)) {
            throw new IllegalArgumentException("源文件不存在");
        }
        if (!Files.isRegularFile(sourcePath)) {
            throw new IllegalArgumentException("源路径不是一个文件");
        }
        if (!Files.exists(targetPath)) {
            Files.createFile(targetPath);
        }

        // 处理 .tar.gz 文件流
        try (InputStream fi = Files.newInputStream(sourcePath);
             BufferedInputStream bi = new BufferedInputStream(fi);
             TarArchiveInputStream tarIs = new TarArchiveInputStream(bi);
             OutputStream fo = Files.newOutputStream(targetPath);
             BufferedOutputStream bo = new BufferedOutputStream(fo);
             TarArchiveOutputStream tarOs = new TarArchiveOutputStream(bo)) {

            TarArchiveEntry entry;
            while ((entry = tarIs.getNextTarEntry()) != null) {
                if (entry.isDirectory()){
                    continue;
                }
                // 修改文件名称，如果映射存在
                String entryName = entry.getName();
                String[] split = StringUtils.split(entryName, "/");
                entryName = split[split.length - 1];
                String newName = nameMap.getOrDefault(entryName, entryName);

                TarArchiveEntry newEntry = new TarArchiveEntry(newName);
                newEntry.setSize(entry.getSize());
                tarOs.putArchiveEntry(newEntry);

                // 复制数据
                IOUtils.copy(tarIs, tarOs);

                tarOs.closeArchiveEntry();
            }
        }
    }

    /**
     * tar文件转zip
     * @param sourceTarGzPath
     * @param targetZipPath
     * @throws IOException
     */
    public static void tarGzToZip(String sourceTarGzPath, String targetZipPath) throws IOException {
        if (!Files.exists(Paths.get(sourceTarGzPath))) {
            throw new IllegalArgumentException("源文件不存在");
        }
        if (!Files.isRegularFile(Paths.get(sourceTarGzPath))) {
            throw new IllegalArgumentException("源路径不是一个文件");
        }
        if (!Files.exists(Paths.get(targetZipPath))) {
            Files.createFile(Paths.get(targetZipPath));
        }
        // 通过InputStream读取文件
        FileInputStream fis = new FileInputStream(sourceTarGzPath);
        BufferedInputStream bis = new BufferedInputStream(fis);
        TarArchiveInputStream tarIs = new TarArchiveInputStream(bis);
        // 创建一个ZipOutputStream来写入zip文件
        FileOutputStream fos = new FileOutputStream(targetZipPath);
        ZipOutputStream zipOs = new ZipOutputStream(fos);

        TarArchiveEntry tarEntry;
        byte[] buffer = new byte[1024];
        int count;
        // 遍历tar.gz文件中的每个条目，并将它们添加到zip文件中
        while ((tarEntry = tarIs.getNextTarEntry()) != null) {
            // 如果是文件，添加到zip文件
            if (!tarEntry.isDirectory()) {
                // 以数字为名称创建文件，您也可以选择其他命名方案
                String entryName = tarEntry.getName();
                ZipEntry zipEntry = new ZipEntry(entryName);
                zipOs.putNextEntry(zipEntry);

                // 读取tar条目数据并写入zip条目
                while ((count = tarIs.read(buffer)) != -1) {
                    zipOs.write(buffer, 0, count);
                }
                // 关闭当前zip条目
                zipOs.closeEntry();
            }
        }
        // 关闭流
        zipOs.close();
        tarIs.close();
        bis.close();
        fis.close();
    }

    /**
     * 解压tar包到指定目录 目录名称不能包含特殊字符
     * @param tarFilePath
     * @param outputDirPath
     * @throws Exception
     */
    public static void extractTarFile(String tarFilePath, String outputDirPath) throws Exception {
        File tarFile = new File(tarFilePath);
        File outputDir = new File(outputDirPath);
        if (!tarFile.exists()) {
            throw new IllegalArgumentException("Tar file does not exist: " + tarFilePath);
        }
        // 确保输出目录存在
        if (!outputDir.exists()) {
            outputDir.mkdirs();
        }
        try (TarArchiveInputStream tarIn = new TarArchiveInputStream(new FileInputStream(tarFile))) {
            TarArchiveEntry entry;
            // 遍历tar包中的每个条目
            while ((entry = tarIn.getNextTarEntry()) != null) {
                // 处理文件和目录
                if (entry.isDirectory()) {
                    // 创建目录
                    new File(outputDir, entry.getName()).mkdirs();
                } else {
                    // 写出文件到指定目录
                    File outputFile = new File(outputDir, entry.getName());
                    // 如果文件额上级目录不存在，则创建该目录
                    outputFile.getParentFile().mkdirs();
                    // 写出文件内容
                    try (OutputStream outputFileStream = new FileOutputStream(outputFile)) {
                        IOUtils.copy(tarIn, outputFileStream);
                    }
                }
            }
        }
    }
    
	/**
     * 将Byte数组转换成文件
     * @param bytes byte数组
     * @param file  文件
     */
    public static void fileToBytes(byte[] bytes, File file) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        try {
            if (!file.getParentFile().exists()) {
                //文件夹不存在 生成
                file.getParentFile().mkdirs();
            }
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

	/**
	*  创建一个文件, 将字符串写入文件
	*/
	public static void createFileWriteIn(String fileName, String fileContent) {
        RandomAccessFile mneRaf = null;
        FileChannel mneChannel = null;
        ByteBuffer byteBuffer = null;
        try {
            mneRaf = new RandomAccessFile(fileName, "rw");
            mneChannel = mneRaf.getChannel();
            byteBuffer = ByteBuffer.allocate(fileContent.getBytes().length);
            byteBuffer.put(fileContent.getBytes());
            byteBuffer.flip();
            while (byteBuffer.hasRemaining()) {
                mneChannel.write(byteBuffer);
            }
        } catch (IOException e) {
            logger.error(e);
        } finally {
            if (byteBuffer != null) {
                byteBuffer.clear();
            }
            try {
                if (mneRaf != null) {
                    mneRaf.close();
                }
            } catch (IOException e) {
                logger.error(e);
            }
            try {
                if (mneChannel != null) {
                    mneChannel.close();
                }
            } catch (IOException e) {
                logger.error(e);
            }
        }
    }
	
	/**
	* 监听一个文件夹 ， 在创建一个新的文件夹后就停止该监听器 返回文件夹的路径（可扩展 包括新建一个文件/删除一个文件之类的操作）
	*/
	public static String monitorPathCreateDir(String absPath) throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        FileListener fileListener = new FileListener(){
            @Override
            public void onDirectoryCreate(File directory) {
                super.onDirectoryCreate(directory);
                latch.countDown();
            }
        };
        FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(new File(absPath));
        FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(1000);
        fileAlterationObserver.addListener(fileListener);
        fileAlterationMonitor.addObserver(fileAlterationObserver);
        fileAlterationMonitor.start();
        latch.await();
        fileAlterationMonitor.stop();
        return fileListener.getLatestDirectory();
    }
}

文件监听类

public class FileListener extends FileAlterationListenerAdaptor {

    private String latestDirectory;

    public String getLatestDirectory() {
        return latestDirectory;
    }

    @Override
    public void onStart(FileAlterationObserver observer) {
        super.onStart(observer);
    }

    @Override
    public void onDirectoryCreate(File directory) {
        latestDirectory = directory.getAbsolutePath();
    }

    @Override
    public void onDirectoryChange(File directory) {

    }

    @Override
    public void onDirectoryDelete(File directory) {

    }

    @Override
    public void onFileCreate(File file) {

    }

    @Override
    public void onFileChange(File file) {

    }

    @Override
    public void onFileDelete(File file) {

    }

    @Override
    public void onStop(FileAlterationObserver observer) {
        super.onStop(observer);
    }
}
9453#
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java导出导入工具类
jah
09-27 8758
poi导出导入
java文件操作工具类
09-02
这里我们详细探讨一个名为`FileTools`的Java文件操作工具类，它提供了一系列方法来简化这些操作。 首先，我们看到`formatPath`方法，其作用是将路径字符串中的反斜杠（\）转换为正斜杠（/）。这是因为正斜杠在路径...
java 读取properties文件通用工具类
qq_32403351的博客
03-27 2025
1.创建 PropertiesUtil.java文件：package com.demo.util; import java.util.ResourceBundle; /** * 对系统中的config.properties文件内容读取工具类 * * Created by zhanghb on 2018/3/26. */ public class PropertiesUtil { ...
Minio工具类 - Java
流氓兔的博客
12-02 3万+
依赖 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>${minio.version}</version> </dependency> 项目启动，创建bean package com.mgmiot.dlp.file.filev2.config; import com.mg
Java之——导出Excel通用工具类
热门推荐
冰河的专栏
03-22 5万+
转载请注明出处：https://blog.csdn.net/l1028386804/article/details/79659605 新版地址 https://blog.csdn.net/l1028386804/article/details/103791256 一、概述 相信大家在工作过程中，都会遇到这样一个需求，就是将相关的数据列表导出成excel，那么，有没有通用的导出方式呢，这里，...
java日常工具类之Excel工具类
qq_42946963的博客
07-28 1万+
import java.io.ByteArrayOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.text.DecimalFormat; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java
java操作minio文件服务的通用工具类
08-19
java操作minio文件服务的通用工具类,可以实现使用指定方法就能控制文件的上传下载删除以及更多操作
JAVA通用文件下载工具类
09-05
JAVA通用文件下载工具类
Java文件通用工具类
03-28
Java文件通用工具类
16 个超级实用的 Java 工具类
01-06
在Java中，工具类定义了一组公共方法，这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名，参考数据来源于Github上随机选取的5万个开源项目源码。 一. org.apache.commons.io....
Java内存模型
weixin_44267758的博客
07-19 562
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 479
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 983
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 130
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1037
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 532
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 793
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 452
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值