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中基于推、拉模式的sentinel规则持久化详解
这篇文章主要介绍了Java中基于推、拉模式的sentinel规则持久化详解,推模式是sentinelDashboard 把规则推给Nacos,Nacos监听规则的变化推给微服务,拉模式是sentinelDashboard 把规则直接给微服务, Nacos定时的同步微服务端的规则,需要的朋友可以参考下
2023-09-09
Jar包反编译修改代码后重新打jar包图文详解
这篇文章主要给大家介绍了关于Jar包反编译修改代码后重新打jar包的相关资料,JAR文件就是Java Archive(Java档案文件),它是 Java的一种文档格式,文中通过图文介绍的非常详细,需要的朋友可以参考下
2023-07-07
@Valid 校验无效,BindingResult未获得错误的解决
这篇文章主要介绍了@Valid 校验无效,BindingResult未获得错误的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-10-10
深入Java ThreadLocal核心原理与内存泄漏解决方案
这篇文章主要介绍了深入阐述了ThreadLocal的底层实现机制,即通过每个线程内部维护的ThreadLocalMap的哈希表来存储数据,从而为每个线程提供独立的变量副本,实现线程隔离,关键点在于其Entry的Key是弱引用,而Value是强引用,这直接引出了内存泄漏问题,需要的朋友可以参考下
2026-01-01
centos7中如何优雅的动态切换jdk版本实例详解
这篇文章主要介绍了CentOS7安装多版本jdk并切换jdk版本的完整步骤,文中通过代码详细介绍使用alternatives命令管理多个JDK版本,步骤包括安装不同JDK、配置alternatives及切换版本验证,需要的朋友可以参考下
2026-06-06
java观察者模式实现和java观察者模式演化
观察者模式是经典设计模式中很常用的一种，平常我们看到的监听器，基本上都是采用这种设计模式实现的，这里探讨一下观察者模式的演化
2014-02-02
java判断http地址是否连通(示例代码)
这篇文章通过实例代码给大家介绍了java判断http地址是否连通，文末给大家补充知识点url.openconnection() 设置超时时间的方法，感兴趣的朋友跟随小编一起看看吧
2021-12-12
Mybatis插件+注解实现数据脱敏方式
这篇文章主要介绍了Mybatis插件+注解实现数据脱敏方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-09-09
SpringBoot整合Mybatis-plus的具体过程使用
这篇文章主要介绍了SpringBoot 整合mybatis+mybatis-plus的步骤,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-06-06
java数据结构与算法之希尔排序详解
这篇文章主要介绍了java数据结构与算法之希尔排序,结合实例形式分析了希尔排序的概念、原理、实现方法与相关注意事项,需要的朋友可以参考下
2017-05-05