文件操作工具类

文件操作工具类

import cn.hutool.core.collection.CollectionUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
 
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
 
/**
 * @description
 **/
public class FileUtil {
    
    /***
     * @Description：将文件路径统一转换成”C:/Users/Daasan/Desktop“格式
     * @data：[filePath]
     * @return： java.lang.String
     */
    public static String formatPath(String filePath) {
        if (StringUtils.isEmpty(filePath)){
            return "";
        }
        // 将反斜杠转为正斜杠
        filePath = filePath.replaceAll("\\\\", "/");
        // 将连续的斜杠替换为单个斜杠
        filePath = filePath.replaceAll("/{2,}", "/");
        // 如果路径以斜杠结尾，则去掉结尾的斜杠
        if (filePath.endsWith("/")) {
            filePath = filePath.substring(0, filePath.length() - 1);
        }
        return filePath;
    }
 
    /**
     **获取文件路径中的最后一级(目录或文件名称)
     * \aa\bb\cc\dd  -->  dd
     * \aa\bb\cc\dd.txt  -->  dd.txt
     * @param filePath
     * @return java.lang.String
     **/
    public static String getPathLastLevel(String filePath) {
        //判空
        if (StringUtils.isEmpty(filePath)){
            return "";
        }
        // 格式化文件路径
        filePath = formatPath(filePath);
 
        int index = filePath.lastIndexOf("/");
        if (index != -1) {
            return filePath.substring(index + 1);
        }
        return filePath;
    }
 
    /**
     **获取文件的后缀:  test.ppt  -->  ppt
     * @param fileName 文件名称
     * @return java.lang.String
     **/
    public static String getFileSuffix(String fileName) {
        if (fileName == null) {
            return null;
        }
        int index = fileName.lastIndexOf(".");
        if (index == -1) {
            return "";
        }
        return fileName.substring(index + 1);//不包含”.“
    }
 
    /**
     **获取文件的名称（去掉后缀）
     * @param fileName
     * @return java.lang.String
     **/
    public static String getFileNameWithoutSuffix(String fileName) {
        if (fileName == null) {
            return null;
        }
        int index = fileName.lastIndexOf(".");
        if (index == -1) {
            return fileName;
        }
        return fileName.substring(0, index);
    }
 
    /**
     **创建空文件
     * @param file 需创建的文件
     * @return void
     **/
    public static void createEmptyFile(File file) throws IOException {
        if (file.exists()) {
            return;
        }
        File parent = file.getParentFile();
        if (parent != null && !parent.exists()) {
            parent.mkdirs();
        }
        file.createNewFile();
    }
 
    /**
     **批量移动磁盘中的文件
     * @param rootPath 根目录
     * @param absolutePathList 存放源文件和目标文件的绝对路径
     * @return void
     **/
    public static void moveFiles(String rootPath, List<Map<String, String>> absolutePathList) throws IOException {
        for (Map<String, String> pathMap : absolutePathList) {
            String oldFilePath = pathMap.get("oldFilePath");
            String newFilePath = pathMap.get("newFilePath");
            Path sourcePath = Paths.get(formatPath(rootPath + oldFilePath));
            Path targetPath = Paths.get(formatPath(rootPath + newFilePath));
            Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
        }
    }
 
    /**
     **从网络路径中获取文件的字节数组
     * @param urlStr 文件的网络路径
     * @return byte[] 文件的字节数组
     **/
    public static byte[] getByteFromUrl(String urlStr) throws IOException {
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpGet httpGet = new HttpGet(urlStr);
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                return EntityUtils.toByteArray(response.getEntity());
            }
        }
    }
 
    /**
     **递归获取文件夹下的所有文件和文件夹
     * @param folder
     * @return java.util.List<java.io.File>
     **/
    public static List<File> getFilesRecursively(File folder) {
        List<File> fileList = new ArrayList<>();
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                fileList.add(file);
                if (file.isDirectory()) {
                    fileList.addAll(getFilesRecursively(file));
                }
            }
        }
        return fileList;
    }
 
    /**
     **去掉路径中的特殊字符
     * @param path
     * @return java.nio.file.Path
     **/
    public static Path sanitizePath(Path path) {
 
        String fileName = path.getFileName().toString();
        String parentPathString = path.getParent().toString();
 
        // 定义特殊字符的正则表达式
        Pattern pattern = Pattern.compile("[\\\\/:*?\"<>|&'+-=]");
 
        // 使用空字符串替换特殊字符
        String sanitizedFileName = pattern.matcher(fileName).replaceAll("");
 
        Path path1 = Paths.get(parentPathString, sanitizedFileName);
 
        // 返回路径的父路径与处理后的文件名拼接成的完整路径
        return path1;
    }
 
    /**
     **判断文件名称中是否包含特殊字符
     * @param fileName
     * @return boolean
     **/
    public static boolean hasSpecialCharacters(String fileName) {
        String SPECIAL_CHARACTERS_REGEX = "[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,<>\\/?]";
        Pattern pattern = Pattern.compile(SPECIAL_CHARACTERS_REGEX);
        return pattern.matcher(fileName).find();
    }
 
    /**
     **去掉文件名称中包含的特殊字符
     * @param fileName
     * @return java.lang.String
     **/
    public static String removeSpecialCharacters(String fileName) {
        String SPECIAL_CHARACTERS_REGEX = "[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,<>\\/?]";
        return fileName.replaceAll(SPECIAL_CHARACTERS_REGEX, "");
    }
 
    /**
     * 获取文件的绝对路径
     * 
     * @param filePath 文件路径
     * @return 文件的绝对路径
     */
    public static String getAbsolutePath(String filePath) {
        File file = new File(filePath);
        return file.getAbsolutePath();
    }
 
 
    /**
     * 复制文件
     * 
     * @param sourceFilePath      源文件路径
     * @param destinationFilePath 目标文件路径
     * @throws IOException 如果复制过程中出现错误，抛出 IOException
     */
    public static void copyFile(String sourceFilePath, String destinationFilePath) throws IOException {
        File sourceFile = new File(sourceFilePath);
        File destinationFile = new File(destinationFilePath);
        
        if (!sourceFile.exists()) {
            throw new FileNotFoundException("Source file does not exist: " + sourceFilePath);
        }
        
        try (InputStream inputStream = new FileInputStream(sourceFile);
             OutputStream outputStream = new FileOutputStream(destinationFile)) {
            byte[] buffer = new byte[4096];
            int length;
            while ((length = inputStream.read(buffer)) > 0) {
                outputStream.write(buffer, 0, length);
            }
        }
    }
 
    /**
     **修改文件的名称
     * @param filePath
     * @param newFileName
     * @return void
     **/
    public static void renameFile(String filePath, String newFileName) {
        File file = new File(filePath);
        if (file.exists()) {
            String parentPath = file.getParent();
            String newFilePath = parentPath + File.separator + newFileName;
            File newFile = new File(newFilePath);
            if (file.renameTo(newFile)) {
                System.out.println("文件重命名成功！");
            } else {
                System.out.println("文件重命名失败！");
            }
        } else {
            System.out.println("文件不存在！");
        }
    }
 
    /**
     **递归获取文件夹下所有文件的路径后，将路径放到filePaths中
     * @param folderPath 文件夹路径
     * @param filePaths 存放文件路径的集合
     * @return void
     **/
    public static void getAllFilePaths(String folderPath, List<String> filePaths) {
        File folder = new File(folderPath);
        // 获取文件夹下所有文件和子文件夹
        File[] files = folder.listFiles();
 
        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    // 如果是文件，将文件路径添加到列表中
                    filePaths.add(file.getAbsolutePath());
                } else if (file.isDirectory()) {
                    // 如果是文件夹，则递归调用该方法获取文件夹下所有文件路径
                    getAllFilePaths(file.getPath(), filePaths);
                }
            }
        }
    }
 
    /**
     **将源文件夹下的所有文件复制到目标文件夹下
     * @param sourceFolderPath
     * @param targetFolderPath
     * @return void
     * @author yinqi
     * @create 2024/3/25 11:41
     **/
    public static void copyFolder(String sourceFolderPath, String targetFolderPath) throws IOException {
        File sourceFolder = new File(sourceFolderPath);
        File targetFolder = new File(targetFolderPath);
 
        // 检查源文件夹是否存在
        if (!sourceFolder.exists()) {
            throw new IllegalArgumentException("源文件夹不存在");
        }
 
        // 检查目标文件夹是否存在，如果不存在则创建
        if (!targetFolder.exists()) {
            targetFolder.mkdirs();
        }
 
        // 获取源文件夹下的所有文件和文件夹
        File[] files = sourceFolder.listFiles();
 
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    // 如果是文件夹，则递归调用copyFolder方法复制文件夹
                    copyFolder(file.getAbsolutePath(), targetFolderPath + File.separator + file.getName());
                } else {
                    // 如果是文件，则使用Files.copy方法复制文件
                    Path sourcePath = file.toPath();
                    Path targetPath = new File(targetFolderPath + File.separator + file.getName()).toPath();
 
                    Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
                }
            }
        }
    }
}