java实现基于关键字的文件夹(文件)的搜索、文件夹(文件)的复制、删除

最近在做一个项目,需要实现这几项功能,上网查了很多资料,自己研究了好几天终于实现了,现在与大家分享一下。

一、JAVA实现文件夹的搜索

  在百度搜索N个技术文章,从哪些大牛们共享的资料中终于写出了我想要的代码。成功实现了对文件夹的搜索。

  其原理是新定义个FileListener类使其实现ActionListener和Runnable接口。将其绑定在JButton上。在向FileListener的对象传入要搜索的文件夹名称时,会先列出系统所有盘符,并开启多个线程依次搜索各个盘符,其实现原理是先列出各个盘符的列表,用递归方式列出所有文件夹中的文件,当定位到文件绝对路径中含有该关键字时,会调用analysisPath解析路径,得到文件夹绝对路径。判断无误后停止所有线程,结束搜索。下面请看代码:

import java.awt.event.ActionEvent;
import java.io.File;

public class FileListener implements java.awt.event.ActionListener, Runnable {

    private static String content;//确保一变化线程中即可调用
    private String root = "C:\\";
    private static File[] listFile;//确保一变化线程中即可调用
    private String fileName;     //所需搜索问关键字
    private static String item = "";//通过item来判定执行run中的哪一个方法
    private Thread t;//统一设定线
    private static int count = 0;//统计出现的文件个数
    private FileListener fl;//控制线程的启动
    private static String s = "";//标识是否停止寻找
    private int threadNum = 0;
    private File[] rootlist;
    private int success = 0; //标识是否成功得到文件夹绝对路径

    public FileListener() {

    }

    public FileListener(String fileName, String root) {  
        this.root = root;
        this.fileName = fileName;
        File file1 = new File("");
        rootlist = file1.listRoots();  //获取所有盘符
    }

    public void actionPerformed(ActionEvent e) {
   //     System.out.println("响应事件");
        content = fileName;  //所需搜索的关键字
        if (e.getActionCommand().equals("Search")) {
            // 指定盘
            if (root == null || root.equals("")) {
                System.out.println("该路径不存在!");
                File file = new File("");
                listFile = file.listRoots();

            } else {
                if (content == null || content.length() == 0) {

                    File file = new File(root);
                    listFile = file.listFiles();
                    //启动线程
                    item = "search";
                    s = "";
                    fl = new FileListener(fileName, root);

                    t = new Thread(fl);
                    t.start();

                } else {

                    //   String[] list;
                    int number = rootlist.length;
		//list = new String[number];

                    //list[i] = rootlist[i].getAbsolutePath();
                    System.out.println("-------------------->" + rootlist[threadNum].getAbsolutePath());
                    File file = new File(rootlist[threadNum].getAbsolutePath());
                    listFile = file.listFiles();
                    //启动线程
                    item = "searchCount";
                    s = "";//每次线程启动前都要将s清空
                    fl = new FileListener(fileName, rootlist[threadNum].getAbsolutePath());
//
                    t = new Thread(fl);
                    t.start();

                }
            }

        }
    }


    private int search(File[] file) {

        //每次使用之前都将count清0,否则会叠加
        int count = 0;
        if (file == null || file.length == 0) {
            return 0;
        }
        for (int i = 0; i < file.length; i++) {
            File filenew = file[i];
            if (filenew.isDirectory()) {
                File[] tempFile = filenew.listFiles();
                count += search(tempFile);
                this.count = count;
            }
            if (s.equals("stop")) {
             
                break;
            } else {
                if (filenew.isFile()) {
                    count++;
     
                    s = "stop";
              
                }
            }
        }

        return count;
    }

    private int searchContent(File[] file) {
        int count = 0;
        if (file == null || file.length == 0) {
            return 0;
        }
        for (int i = 0; i < file.length; i++) {
            File filenew = file[i];
            // 包含字符
            if (filenew.isDirectory()) {
                File[] tempFile = filenew.listFiles();
                count += searchContent(tempFile);
                this.count = count;
            }

            if (filenew.isFile()) {
                String path = filenew.getAbsolutePath();
                //找到与内容相符的路径

                if (s.equals("stop")) {
                   
                    break;
                } else {

                    if (path.indexOf(content) != -1) {
                        count++;
                      
                        s = "stop";

                     //   LeftPanel.ReturnPath = analysisPath(filenew.getAbsolutePath());     //此处为将搜索时检索的路径显示在JLabel上,用户体验更好。
                        if (analysisPath(filenew.getAbsolutePath())) {  
                            break;
                        }
                    }
                }
            }
        }

        return count;
    }

    //重写run方法
    @Override
    public void run() {
//		

        searchContent(listFile);
        System.out.println("searchContent函数结束");
        if (success == 0) {
            if (threadNum++ < rootlist.length) {
                System.out.println("-------------------->" + rootlist[threadNum].getAbsolutePath());
                File file = new File(rootlist[threadNum].getAbsolutePath());
                listFile = file.listFiles();
                //启动线程
                item = "searchCount";
                s = "";//每次线程启动前都要将s清空
                fl = new FileListener(fileName, rootlist[threadNum].getAbsolutePath());
//
                t = new Thread(fl);
                t.start();
            }
        }

    }

    /**
     * 解析搜索到的文件路径 得出目录文件绝对路径
     *
     * @param absolutePath
     * @return
     */
    private String analysisPath(String absolutePath) {//此处传入的absolutePath时定位到的路径中含有关键字的文件,,也就是目标文件夹中的文件。
        File f = new File(absolutePath);

        try {
            while (!f.getName().equals(fileName)) {  //此处是为了得到目标文件夹的绝对路径
                f = f.getParentFile();   //得到父文件路径
            }

        } catch (Exception e) {
           System.out.println("未能成功检索到文件夹")
            s = "";
            return null;
        }
        System.out.println("成功检索到文件夹");
        success = 1;   //成功检索到文件夹 ,修改该变量值  使进程停止//fun(f.getAbsolutePath();)  //此处为您所需要处理该路径的方法,也可以把该值付给调用方的类成员变量得到该值        return f.getAbsolutePath();    }

}

二、JAVA实现文件夹的复制、删除

 在实现了文件夹搜索后,文件夹/文件的复制,删除相对简单些。下面我们来看代码:

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import static qqbackup.BackUpProgress.currentNum;
//import static qqbackup.BackUpProgress.currentSize;

class CopyFile {

    /**
     * 复制文件到目录 <功能详细描述>
     *
     * @param srcPath 文件绝对路径
     * @param destDirPath 目标文件夹绝对路径
     * @throws Exception
     * @see [类、类#方法、类#成员]
     */
    public static void copyFile(String srcPath, String destDirPath) throws Exception {
        File srcfile = new File(srcPath);
        File destDir = new File(destDirPath);

        InputStream is = null;
        OutputStream os = null;
        int ret = 0;

        // 源文件存在
        if (srcfile.exists() && destDir.exists() && destDir.isDirectory()) {
            try {
                is = new FileInputStream(srcfile);

                String destFile = destDirPath + File.separator + srcfile.getName();

                os = new FileOutputStream(new File(destFile));

                byte[] buffer = new byte[1024];

                while ((ret = is.read(buffer)) != -1) {
                    os.write(buffer, 0, ret); // 此处不能用os.write(buffer),当读取最后的字节小于1024时,会多写;
                    // ret是读取的字节数
                }
                os.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
                throw new Exception("");
            } catch (IOException e) {
                e.printStackTrace();
                throw new Exception("");
            } finally {
                try {
                    if (os != null) {
                        os.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }

                try {
                    if (is != null) {
                        is.close();
                    }
                } catch (Exception e) {
                }
            }
        } else {
            throw new Exception("源文件不存在或目标路径不存在");
        }

    }

    /**
     * 列出文件夹下的所有文件,使用递归。 <功能详细描述>
     *
     * @param dirPath 文件夹绝对路径
     * @see [类、类#方法、类#成员]
     */
    public static void getFileList(String dirPath) {
        File rootDir = new File(dirPath);
        if (rootDir.exists()) {
            File[] files = rootDir.listFiles();

            for (File file : files) {
                if (file.isDirectory()) {
                    System.out.println("目录" + file.getName());
                    // 递归调用
                    getFileList(file.getPath());
                } else {
                    System.out.println("文件" + file.getName());
                }
            }
        }
    }

    /**
     * <一句话功能简述>复制文件夹 <功能详细描述>
     *
     * @param srcDir 文件夹的绝对路径
     * @param destDir 目标绝对路径
     * @throws Exception
     * @see [类、类#方法、类#成员]
     */
    public static void copyFolder(String srcDir, String destDir) throws Exception {
        File srcFile = new File(srcDir);

        // 在目标路径建立文件夹
        String name = srcFile.getName();
        File destDirFile = new File(destDir);
            if (!destDirFile.exists()) {
                destDirFile.mkdirs();   //如果路径不存在则创建文件夹

            }
        File destFile = new File(destDir + File.separator + name);  //目的文件夹内的元文件夹名称路径
        if (!destFile.exists()) {
            destFile.mkdir();             //如果路径不存在则创建文件夹
        }
        if (srcFile.exists() && destFile.isDirectory()) {
            File[] files = srcFile.listFiles();

            String src = srcDir;
            String dest = destFile.getAbsolutePath();

            for (File temp : files) {
                // 复制目录
                if (temp.isDirectory()) {
                    String tempSrc = src + File.separator + temp.getName();
                    String tempDest = dest + File.separator + temp.getName();
                    File tempFile = new File(tempDest);
                    if(!tempFile.exists()){
                    tempFile.mkdir();
                    }
                    // 当子目录不为空时
                    if (temp.listFiles().length != 0) {
                        // 递归调用
                        copyFolder(tempSrc, dest);
                    }
                } else // 复制文件
                {
                    String tempPath = src + File.separator + temp.getName();
                    copyFile(tempPath, dest);
                }
            }
        }
        //  System.out.println("拷贝完成");
    }

    /**
     * 删除文件夹 <功能详细描述>
     * 要先删除子内容,再删除父内容
     *
     * @param dirPath 要删除的文件夹
     * @see [类、类#方法、类#成员]
     */
    public static void deleteFolder(String dirPath) {
        File folder = new File(dirPath);
        File[] files = folder.listFiles();

        for (File file : files) {
            if (file.isDirectory()) {
                String tempFilePath = dirPath + File.separator + file.getName();
                deleteFolder(tempFilePath);
            } else {
                file.delete();
            }

        }

        folder.delete();
    }

}

希望这些代码能给大家带来些帮助,欢迎留言交流。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏蓝天

Redis基于eval的多字段原子增量计算

一些应用场景需要对多个值进行原子计数,Redis的eval+hincrby可以达到目标,但如果计算的字段比较多时,效率会是个问题,它的时间复杂度为O(N),而...

752
来自专栏MasiMaro 的技术博文

PE文件详解(六)

这篇文章转载自小甲鱼的PE文件详解系列原文传送门 之前简单提了一下节表和数据目录表,那么他们有什么区别? 其实这些东西都是人为规定的,一个数据在文件中或...

2252
来自专栏Java 技术分享

JavaWeb 之文件的上传下载

5025
来自专栏浪淘沙

Hive学习

         Hive是基于Hadoop的一个数据仓库工具(离线),可以将结构化的数据文件映射为一张数据库表,并提供类SQL查询功能。

2462
来自专栏坚毅的PHP

my php & mysql FAQ

php中文字符串长度及定长截取问题使用str_len("中国") 结果为6,php系统默认一个中文字符长度为3,可改用mb_strlen函数获得长度,mb_su...

3806
来自专栏恰同学骚年

Entity Framework 基础知识走马观花

  (1)通过选择以XML方式打开edmx文件,我们可以可以清楚地看到,edmx模型文件本质就是一个XML文件;

1092
来自专栏MasiMaro 的技术博文

Windows平台下的内存泄漏检测

在C/C++中内存泄漏是一个不可避免的问题,很多新手甚至有许多老手也会犯这样的错误,下面说明一下在windows平台下如何检测内存泄漏。 在windows平...

2042
来自专栏哲学驱动设计

优化OEA中的聚合SQL

    之前写过几篇关于聚合对象SQL的文章,讲的是如果设计框架,使用一句SQL语句来加载整个聚合对象树中的所有数据。相关内容,参见:《性能优化总结(二):聚合...

2427
来自专栏运维咖啡吧

Django model select的各种用法详解

Q对象可以对关键字参数进行封装,从而更好的应用多个查询,可以组合&(and)、|(or)、~(not)操作符。

1003
来自专栏Java帮帮-微信公众号-技术文章全总结

Mybatis_day01

Mybatis_day01 前言 Jdbc演变到mybatis jdbc jdbc编程 publicstaticvoid main(String[] args)...

4207

扫码关注云+社区

领取腾讯云代金券