Java实现U盘的插入和移除检测程序

更新时间：2025年12月03日 08:22:19 作者：牛肉胡辣汤

在现代计算机系统中,U盘的使用非常普遍,那么如何在Java程序中实现对U盘的插入和移除进行检测,并对U盘中的文件进行递归处理呢,下面我们就来简单介绍一下吧

1. 环境准备

首先，确保你的开发环境已经安装了JDK（Java Development Kit），并配置好环境变量。此外，本示例将在Windows环境下运行，但代码可以很容易地移植到其他操作系统上。

2. U盘检测

2.1 监听U盘事件

Java本身并没有直接提供U盘插入或移除的监听接口，但我们可以通过轮询的方式来实现这一功能。下面是一个简单的示例，展示如何通过定时检查驱动器列表来判断U盘是否被插入或移除。

获取当前所有驱动器

import java.io.File;
 
public class DriveDetector {
    public static List<String> getCurrentDrives() {
        List<String> drives = new ArrayList<>();
        File[] roots = File.listRoots();
        for (File root : roots) {
            drives.add(root.getAbsolutePath());
        }
        return drives;
    }
}

检测U盘插入和移除

import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;

public class USBMonitor {
    private Set<String> currentDrives = new HashSet<>(DriveDetector.getCurrentDrives());

    public void checkUSBChanges() {
        List<String> newDrives = DriveDetector.getCurrentDrives();
        Set<String> addedDrives = new HashSet<>(newDrives);
        addedDrives.removeAll(currentDrives);

        Set<String> removedDrives = new HashSet<>(currentDrives);
        removedDrives.removeAll(newDrives);

        if (!addedDrives.isEmpty()) {
            System.out.println("Detected new USB drives: " + addedDrives);
            // 这里可以添加处理新插入U盘的逻辑
        }

        if (!removedDrives.isEmpty()) {
            System.out.println("Detected removed USB drives: " + removedDrives);
            // 这里可以添加处理U盘拔出的逻辑
        }

        currentDrives = new HashSet<>(newDrives);
    }
}

2.2 定时任务

为了定期检查U盘状态，我们可以使用ScheduledExecutorService来创建一个定时任务。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        USBMonitor usbMonitor = new USBMonitor();

        executor.scheduleAtFixedRate(() -> usbMonitor.checkUSBChanges(), 0, 5, TimeUnit.SECONDS);
    }
}

3. 文件递归处理

当检测到U盘插入后，我们可能需要遍历U盘中的文件，进行某些操作，如复制、删除等。下面是一个简单的文件递归遍历示例。

import java.io.File;

public class FileProcessor {
    public void processFiles(File directory) {
        if (directory.isDirectory()) {
            File[] files = directory.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        processFiles(file); // 递归调用
                    } else {
                        // 处理文件
                        System.out.println("Processing file: " + file.getAbsolutePath());
                    }
                }
            }
        }
    }
}

调用文件处理

在USBMonitor类中，当检测到新的U盘插入时，可以调用FileProcessor来处理U盘中的文件。

public class USBMonitor {
    // ... 其他代码 ...

    public void checkUSBChanges() {
        List<String> newDrives = DriveDetector.getCurrentDrives();
        Set<String> addedDrives = new HashSet<>(newDrives);
        addedDrives.removeAll(currentDrives);

        if (!addedDrives.isEmpty()) {
            System.out.println("Detected new USB drives: " + addedDrives);
            for (String drive : addedDrives) {
                FileProcessor processor = new FileProcessor();
                processor.processFiles(new File(drive));
            }
        }

        // ... 其他代码 ...
    }
}

4.方法补充

下面我将提供一个简单的Java程序示例，该程序能够检测U盘的插入和移除，并在U盘插入时递归地遍历U盘中的所有文件和目录。

1. U盘检测

首先，我们需要一个方法来检测U盘的插入和移除。这可以通过监听文件系统的变更来实现。Java 7 引入了 WatchService API，可以用来监控文件系统的变化。

2. 文件递归遍历

接下来，我们需要一个方法来递归地遍历U盘中的所有文件和目录。

示例代码

import java.io.File;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import static java.nio.file.StandardWatchEventKinds.*;

public class USBDriveMonitor {

    public static void main(String[] args) {
        try {
            // 创建WatchService实例
            WatchService watchService = FileSystems.getDefault().newWatchService();

            // 注册根目录以监视U盘的插入和移除
            Path rootPath = Paths.get("/");
            rootPath.register(watchService, ENTRY_CREATE, ENTRY_DELETE);

            System.out.println("USB Drive Monitor started. Waiting for events...");

            while (true) {
                // 等待事件
                WatchKey key = watchService.take();

                for (WatchEvent<?> event : key.pollEvents()) {
                    WatchEvent.Kind<?> kind = event.kind();

                    if (kind == OVERFLOW) {
                        continue;
                    }

                    // 获取事件类型和路径
                    Path name = (Path) event.context();
                    Path child = rootPath.resolve(name);

                    if (kind == ENTRY_CREATE) {
                        System.out.println("USB Drive inserted: " + child);
                        // 检查是否为U盘
                        if (isUSBDrive(child)) {
                            // 递归遍历U盘中的文件
                            traverseDirectory(child);
                        }
                    } else if (kind == ENTRY_DELETE) {
                        System.out.println("USB Drive removed: " + child);
                    }
                }

                // 重置WatchKey
                boolean valid = key.reset();
                if (!valid) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static boolean isUSBDrive(Path path) {
        // 这里可以根据实际情况判断是否为U盘
        // 例如，U盘通常有一个较小的总大小
        try {
            FileStore fileStore = Files.getFileStore(path);
            long totalSpace = fileStore.getTotalSpace();
            return totalSpace < 100 * 1024 * 1024 * 1024; // 小于100GB
        } catch (Exception e) {
            return false;
        }
    }

    private static void traverseDirectory(Path path) throws Exception {
        Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("File: " + file);
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("Directory: " + dir);
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

代码说明

WatchService：用于监听文件系统的变更。

注册根目录：我们注册根目录（/）以监听U盘的插入和移除事件。

事件处理：

ENTRY_CREATE：表示U盘插入。
ENTRY_DELETE：表示U盘移除。

判断是否为U盘：通过检查文件系统的总大小来简单判断是否为U盘。

递归遍历：使用 Files.walkFileTree 方法递归遍历U盘中的所有文件和目录。

注意事项

权限：确保你的应用程序有权限访问文件系统和U盘。
跨平台：上述代码在Linux和macOS上运行良好。如果你需要在Windows上运行，可能需要调整路径和文件系统的处理方式。
性能：频繁的文件系统操作可能会对性能产生影响，特别是在处理大量文件时。

Java U盘检测程序和文件递归处理是两个相对独立但又可以结合使用的功能。下面我将详细介绍这两个部分的实现方法，并提供相应的代码示例。

1. Java U盘检测程序

在Java中，检测U盘插入和移除可以通过监听文件系统的变动来实现。虽然Java标准库没有直接提供这样的API，但我们可以通过一些间接的方法来实现这一功能。一个常见的方法是定期检查特定目录（如Windows系统下的D:\, E:\等）是否存在新的驱动器。

示例代码：U盘检测

import java.io.File;
import java.util.HashSet;
import java.util.Set;

public class USBDriveDetector {

    private Set<String> currentDrives = new HashSet<>();

    public void startMonitoring() {
        Thread monitorThread = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(5000); // 每5秒检查一次
                    checkForUSBDrives();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        monitorThread.start();
    }

    private void checkForUSBDrives() {
        File[] roots = File.listRoots();
        Set<String> currentRoots = new HashSet<>();
        for (File root : roots) {
            if (root.getTotalSpace() > 0) { // 确保驱动器是可用的
                currentRoots.add(root.getPath());
            }
        }

        // 检测新插入的U盘
        for (String drive : currentRoots) {
            if (!currentDrives.contains(drive)) {
                System.out.println("U盘已插入: " + drive);
                onUSBInserted(drive);
            }
        }

        // 检测移除的U盘
        for (String drive : currentDrives) {
            if (!currentRoots.contains(drive)) {
                System.out.println("U盘已移除: " + drive);
                onUSBRemoved(drive);
            }
        }

        currentDrives = currentRoots;
    }

    private void onUSBInserted(String drive) {
        // 处理U盘插入事件
        System.out.println("处理U盘插入事件: " + drive);
        // 例如，启动文件递归处理
        FileRecursion.recursiveProcess(new File(drive));
    }

    private void onUSBRemoved(String drive) {
        // 处理U盘移除事件
        System.out.println("处理U盘移除事件: " + drive);
    }

    public static void main(String[] args) {
        USBDriveDetector detector = new USBDriveDetector();
        detector.startMonitoring();
    }
}

2. 文件递归处理

文件递归处理是指从某个目录开始，遍历该目录及其所有子目录中的文件，并对每个文件执行特定的操作。Java提供了File类来处理文件和目录操作。

示例代码：文件递归处理

import java.io.File;

public class FileRecursion {

    public static void recursiveProcess(File directory) {
        if (directory.exists() && directory.isDirectory()) {
            File[] files = directory.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        recursiveProcess(file); // 递归处理子目录
                    } else {
                        processFile(file); // 处理文件
                    }
                }
            }
        }
    }

    private static void processFile(File file) {
        // 在这里处理文件，例如打印文件路径
        System.out.println("处理文件: " + file.getAbsolutePath());
    }

    public static void main(String[] args) {
        File directory = new File("C:\\path\\to\\directory"); // 替换为实际目录路径
        recursiveProcess(directory);
    }
}

结合使用

在上面的USBDriveDetector类中，当检测到U盘插入时，调用了FileRecursion.recursiveProcess(new File(drive));方法来递归处理U盘中的文件。这样，当U盘插入时，程序会自动遍历U盘中的所有文件并进行处理。

总结

U盘检测：通过定期检查系统根目录来检测U盘的插入和移除。
文件递归处理：从指定目录开始，递归遍历所有子目录和文件，并对每个文件执行特定的操作。

以上就是Java实现U盘的插入和移除检测程序的详细内容，更多关于Java U盘检测的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

Java
U盘

Java中各种集合判空方法总结
最近接触集合比较多,经常对于集合是否为空做判断,下面这篇文章主要给大家介绍了关于Java中各种集合判空方法总结的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下
2023-12-12
基于socket和javaFX简单文件传输工具
这篇文章主要介绍了基于socket和javaFX简单文件传输工具的相关资料,需要的朋友可以参考下
2016-02-02
如何使用spring ResponseEntity处理http响应
这篇文章主要介绍了如何使用spring ResponseEntity处理http响应的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-07-07
Java 注解的使用实例详解
这篇文章主要介绍了Java 注解的使用实例详解的相关资料,需要的朋友可以参考下
2016-12-12
Java三大特性-封装知识小结
所有的面向对象编程语言的思路都是差不多的，而这三大特性，则是思路中的支柱点，接下来我就重点讲解了一下java三大特性-封装，感兴趣的朋友跟随脚本之家小编一起看看吧
2018-03-03
基于JAVA文件中获取路径及WEB应用程序获取路径的方法
下面小编就为大家带来一篇基于JAVA文件中获取路径及WEB应用程序获取路径的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-11-11
SpringBoot上传文件到本服务器目录与jar包同级问题
这篇文章主要介绍了SpringBoot上传文件到本服务器目录与jar包同级问题,需要的朋友可以参考下
2018-11-11
javacv ffmpeg使用原生ffmpeg命令方式
在使用javacv集成ffmpeg进行视频处理时,发现使用ffmpeg-6.0-1.5.9版本出现原生命令执行失败的问题,通过降级至ffmpeg-5.1.2-1.5.8版本,问题得到解决,此外,ffprobe可以用于获取视频属性,需确保视频片段属性一致性
2024-11-11
详解java中finalize的实现与相应的执行过程
在常规的java书籍中,即会描述 object的finalize方法是用于一些特殊的对象在回收之前再做一些扫尾的工作,但是并没有说明此是如何实现的.本篇从java的角度(不涉及jvm以及c++)，有需要的朋友们可以参考借鉴。
2016-09-09
mybatis-plus IdWorker生成的Id和返回给前台的不一致的解决
这篇文章主要介绍了mybatis-plus IdWorker生成的Id和返回给前台的不一致的解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-03-03