Java-JFileUtil-文件类操作-创建多级目录-创建临时文件-查找临时文件夹路径-删除指定关键字的文件

注意：相对项目有新增，下次不可以直接全部复制

《Java-文档处理-zipUtil-压缩工具-解压-文件流下载》
《Java-文档处理-html转成pdf-itextpdf》、
《Java-JFileUtil-文件类操作-创建多级目录-创建临时文件-查找临时文件夹路径-删除指定关键字的文件》
以上综合应用示例见《Java-文档处理-zipUtil-压缩工具-解压-文件流下载》

package cn.jiangjiesheng.edu.utils; 


import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import sun.security.action.GetPropertyAction;

import java.io.*;
import java.security.AccessController;
import java.util.Properties;

/**
 * 文件类操作
 * java-文件类操作-创建多级目录-创建临时文件-查找临时文件夹路径-删除指定关键字的文件
 *
 * 注意：所以关于路径拼接的，斜杠一定使用 File.separatorChar
 *
 * 更多工具可以查看hutool 中的 FileUtil类
 * dev@jiangjiesheng.cn
 */
@Slf4j
public class JFileUtil {

    //创建多级文件夹 来自hutool
    public static void createFileHolder(String holder){
        if (!cn.hutool.core.io.FileUtil.isDirectory(holder)) {
            cn.hutool.core.io.FileUtil.mkdir(holder);
        }
    }

    //创建单个文件，父级文件夹路径一定要存在
    public static void createFile(String filePath) throws IOException {
        if(filePath !=null){
            File file = new File(filePath);
            if(!file.exists()){
                file.setWritable(true);
                file.createNewFile();
            }
        }
    }


    /**
     *  创建临时文件（自动在/tmp/下创建）,windows是去temp下自动创建
     * @param fileNamePrefix 临时文件名前缀
     * @param ext 临时文件名扩展名，需要带.
     * @throws IOException
     */
    public static File createTempFile(String fileNamePrefix,String ext) throws IOException {
        if(!ext.startsWith(".")){
           throw new IllegalArgumentException("ext不正确");
        }
        File tmpFile = File.createTempFile(fileNamePrefix, ext);
        return tmpFile;
    }


    //获取jar包所在的上一级目录，并自建tmp文件夹
    public static String getTempPathInJarWorkV1() {
        String tmpdir = System.getProperty("user.dir") + File.separatorChar + "tmp" + File.separatorChar;
        createFileHolder(tmpdir);
        return tmpdir;
    }

    //获取linux/windows下的tmp路径,windows 支持
    public static String getTempPathInSystemTempV2() {
        String tmpdir = AccessController.doPrivileged(new GetPropertyAction("java.io.tmpdir"));
        return tmpdir;
    }

    // 删除指定文件夹下的所有文件,不包括当前自身第一级的文件夹
    public static boolean delAllFile(String path) {
        if (StringUtils.isBlank(path)) {
            return true;
        }
        boolean flag = false;
        File file = new File(path);

        if (!file.exists()) {
            return flag;
        }

        if (!file.isDirectory()) {
            return flag;
        }
         //有多级文件夹，但是文件夹都没有文件的情况，先执行下删除，这个只会删除掉最后一级的文件夹
//如果文件别占用似乎不会提示，可以通过  deleteFileByWalkFileTree(folderPath); 临时检测一下
file.delete();

String[] tempList = file.list();
File temp = null;
if(tempList != null){
    for (String p : tempList) {
        if (path.endsWith(File.separator)) {
            temp = new File(path + p);
        } else {
            temp = new File(path + File.separator + p);
        }
        if (temp.isFile()) {
            temp.delete();
        }
        if (temp.isDirectory()) {
            delAllFile(path + "/" + p);//先删除文件夹里面的文件
            delFolder(path + "/" + p);//再删除空文件夹
            flag = true;
        }
    }
}
        return flag;
    }

//TODO 后期研究 https://blog.csdn.net/dxjren/article/details/131939357
//删除文件夹 ,包括当前自身第一级的文件假
    public static void delFolder(String folderPath) {
// deleteFileByWalkFileTree(folderPath);
        try {
            if (StringUtils.isBlank(folderPath)) {
                return;
            }
            delAllFile(folderPath); //删除完里面所有内容
            File myFilePath = new File(folderPath);
            myFilePath.delete(); //删除空文件夹
        } catch (Exception e) {
            log.error("delFolder 删除文件夹出现异常，路径：{},异常：{}", folderPath ,e);
        }
    }

  /**
     * 判断指定目录下是否有某个文件（注意目录使用File.separatorChar处理过）
     * 来自《Java-执行sh文件脚本-cmd命令-查找并复制so库文件到jdk库文件夹-
     * 复制sh脚本文件到当前jar包路径-判断指定目录下是否有某个文件》
     * @param path
     * @param fileName
     * @return
     */
    public boolean hasFile(String path, String fileName) {
        log.info("hasFile入参：path：{}，fileName:{}", path, fileName);
        try {
            if (isLinuxOS()) {
//                String[] split = path.split("/");
//                String filePath = File.separator;
//                for (String folder : split) {
//                    filePath = folder + File.separator;
//                }
                String filePath = path + fileName;
                File tmpdir = new File(filePath);
                return tmpdir.exists();
            } else {
                //window ，其实还有mac
                File tmpdir = new File(path);
                //listFiles还有其他的方法，比如listFiles(FilenameFilter filter)根据名字模糊查询
                File[] listFiles = tmpdir.listFiles((dir, name) -> name.equals(fileName));
                return listFiles != null && listFiles.length > 0;
            }
        } catch (Exception e) {
            log.warn("FstStatusCheckService#hasFile出现异常，默认为false，异常：{}", e);
            return false;
        }
}

private boolean isLinuxOS() {
    Properties properties = System.getProperties();
    //判断是否是linux
    String os = properties.getProperty("os.name");
    log.info("isLinuxOS:{}",os);
    return os != null && os.toLowerCase().contains("linux");
}
    //////////////////////////////////////////

    public static void delTempFile(String keyword) {
        delTempFile(null, keyword);
    }

    //删除tmp目录下指定关键字文件或文件夹(命中文件夹会把文件夹内都清空)
    //tempPath可以指定，默认系统tmp下的文件夹，支持windows
    //如果是自己拼接的要使用 File.separatorChar ,否则linux中会有文件不存在
    //这里name.contains(keyword) 是like 的逻辑 ，其他逻辑到时再改造 可以参数作为枚举，
    like equal startWith endWith 等
    public static void delTempFile(String tempPath, String keyword) {
        File tmpdir = null;
        try {
            //来自 File.TempDirectory
            if(StringUtils.isBlank(tempPath)){
                tempPath = getTempPathInSystemTempV2();
            }
            tmpdir = new File(tempPath);
            File[] listFiles = tmpdir.listFiles((dir, name) -> name.contains(keyword));

            if (listFiles != null && listFiles.length > 0) {
                for (File file : listFiles) {
                    //file.setExecutable(true);
                    file.setWritable(true);

                    //【这个不适合删除含有子目录的整个目录】
                    // boolean delete = file.delete();
                    // log.info("delTempFile 删除临时文件{}，路径：{}", delete ? "成功" : "失败",
                    file.getAbsolutePath());

                    //【这个可以删除含有子目录的整个目录】
                    delFolder(file.getAbsolutePath());
                   log.info("delTempFile 删除临时文件(夹)完成，路径：{}", file.getAbsolutePath());
                }
            } else {
                log.info("delTempFile没有需要删除的临时文件，路径：{}", tmpdir.getAbsolutePath());
            }
        } catch (Exception e) {
            log.info("delTempFile 删除临时文件出现异常：{}", e);
        }
    }

    /**
     *  返回Spring 下的resource下的文件路径
     *  注意：所以关于路径拼接的，斜杠一定使用 File.separatorChar
     * @param clazz
     * @param relativePathWithNoResource 前面不要/,也不要resources
     * @return
     */
    public static String getSpringResourceFilePath(Class clazz, String relativePathWithNoResource) {
        String path = clazz.getClassLoader().getResource("").getPath();//注意getResource("")里面是空字符串
        String filePath = path + relativePathWithNoResource;

        try {
            filePath = java.net.URLDecoder.decode(filePath, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

//        版权声明：本文为CSDN博主「滕青山YYDS」的原创文章，遵循CC 4.0 BY-SA版权协议，
转载请附上原文出处链接及本声明。
//        原文链接：https://blog.csdn.net/qq_34626094/article/details/122605252
//       https://blog.csdn.net/qq_34626094/article/details/122605252
        //https://www.jianshu.com/p/e06534f307a4

        return filePath;
    }

public static void writeByte2File(File file, byte[] datas) {
    OutputStream os = null;
    try {
        os = new FileOutputStream(file, false);//true代表可以在dest文件中追加内容，
        //若为false，则意味着将原来的文件内容删除，重新写入
        //3,操作（写出）
        os.write(datas, 0, datas.length);
        os.flush();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4，释放资源
        try {
            if (null != os) {
                os.close();
            }
        } catch (Exception e) {
        }
    }
}