Java中如何实现连续输入并循环执行代码？

在Java编程中,实现连续输入执行是许多应用场景的核心需求，无论是处理用户交互、批量数据读取，还是实现命令行工具，都离不开对连续输入的灵活处理，本文将系统介绍Java中实现连续输入执行的多种方法，涵盖基础控制台输入、文件流处理、多线程并发等场景，并结合代码示例与实践技巧，帮助开发者掌握不同场景下的最佳实践。

基础控制台输入：使用Scanner实现循环读取

对于简单的控制台交互场景,Scanner类是最常用的工具，通过结合while循环和hasNext()方法，可以持续读取用户输入直到满足特定条件退出，以下是一个基础示例：

import java.util.Scanner;
public class ContinuousInputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据（输入'exit'结束）：");
        while (true) {
            String input = scanner.nextLine();
            if ("exit".equalsIgnoreCase(input)) {
                break;
            }
            System.out.println("你输入的是：" + input);
        }
        scanner.close();
    }
}

关键点解析：

• Scanner.nextLine()用于读取整行输入，避免nextInt()等方法可能导致的换行符问题。
• while (true)配合条件判断（如输入特定指令）实现无限循环，直到手动终止。
• 资源释放：使用完毕后必须调用close()关闭Scanner，避免资源泄漏。

进阶技巧：可通过Scanner.hasNextLine()判断是否还有输入，适用于不确定输入行数的场景，例如处理管道输入或文件重定向。

文件流处理：批量读取与逐行执行

当输入源从控制台转向文件时,Java的BufferedReader提供了更高效的读取方式，通过Files类结合try-with-resources语法，可以实现自动资源管理和连续读取：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FileInputExample {
    public static void main(String[] args) {
        String filePath = "input.txt";
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 处理每一行数据，例如解析、计算或输出
                System.out.println("处理行：" + line);
                // 模拟业务逻辑
                if (line.startsWith("error")) {
                    System.err.println("发现错误行：" + line);
                }
            }
        } catch (IOException e) {
            System.err.println("文件读取失败：" + e.getMessage());
        }
    }
}

核心优势：

• BufferedReader通过缓冲机制减少I/O操作次数，提升大文件读取效率。
• try-with-resources确保流对象自动关闭，避免资源泄漏。
• 逐行读取适合处理结构化文本,如日志文件、CSV数据等。

扩展场景：若需处理二进制文件，可使用FileInputStream结合DataInputStream，通过readBoolean()、readInt()等方法读取特定类型数据。

多线程并发处理：高效处理高并发输入

在需要同时处理多个输入源（如网络请求、传感器数据）的场景中，多线程是提升性能的关键，通过ExecutorService线程池和BlockingQueue实现生产者-消费者模式，可以高效管理连续输入任务：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class ConcurrentInputExample {
    private static final BlockingQueue<String> inputQueue = new LinkedBlockingQueue<>();
    private static final AtomicInteger counter = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        // 生产者线程：模拟连续输入
        executor.submit(() -> {
            for (int i = 0; i < 10; i++) {
                String input = "数据-" + i;
                inputQueue.add(input);
                System.out.println("生产者添加：" + input);
                try {
                    Thread.sleep(100); // 模拟输入间隔
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        // 消费者线程：处理输入
        for (int i = 0; i < 2; i++) {
            executor.submit(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    try {
                        String input = inputQueue.take();
                        System.out.println("消费者" + Thread.currentThread().getName() + "处理：" + input);
                        counter.incrementAndGet();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            });
        }
        // 主线程等待任务完成
        Thread.sleep(2000);
        executor.shutdownNow();
        System.out.println("处理完成，共处理 " + counter.get() + " 条数据");
    }
}

设计要点：

• BlockingQueue作为线程间通信的缓冲区，实现生产者与消费者的解耦。
• 线程池（ExecutorService）避免频繁创建销毁线程的开销，提升资源利用率。
• AtomicInteger保证计数器的线程安全，避免并发修改问题。

适用场景：实时数据处理、高并发API响应、批量任务调度等。

交互式命令行工具：结合Scanner与状态机

对于需要复杂交互逻辑的命令行工具（如CLI管理工具），可将Scanner与状态机模式结合，实现多步骤连续输入与状态流转：

import java.util.Scanner;
public class InteractiveCLIExample {
    private enum State { WAITING_COMMAND, PROCESSING_PARAM, EXIT }
    private static State currentState = State.WAITING_COMMAND;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (currentState != State.EXIT) {
            switch (currentState) {
                case WAITING_COMMAND:
                    System.out.print("请输入命令（create/delete/exit）：");
                    String command = scanner.nextLine();
                    if ("exit".equals(command)) {
                        currentState = State.EXIT;
                    } else if ("create".equals(command) || "delete".equals(command)) {
                        System.out.print("请输入参数：");
                        currentState = State.PROCESSING_PARAM;
                    } else {
                        System.out.println("未知命令，请重新输入");
                    }
                    break;
                case PROCESSING_PARAM:
                    String param = scanner.nextLine();
                    System.out.println("执行命令：" + currentState + "，参数：" + param);
                    currentState = State.WAITING_COMMAND;
                    break;
            }
        }
        scanner.close();
        System.out.println("程序退出");
    }
}

模式优势：

• 状态机清晰管理不同输入阶段的逻辑,避免代码混乱。
• 支持多步骤交互,如先输入命令再输入参数，提升用户体验。

实践注意事项

1. 资源管理：无论是Scanner、BufferedReader还是线程池，务必确保资源正确释放，避免内存泄漏。
2. 异常处理：对输入可能出现的异常（如文件不存在、格式错误）进行捕获和处理，增强程序健壮性。
3. 性能优化：高并发场景下优先使用BlockingQueue和线程池，避免频繁同步操作；大文件处理时采用缓冲流减少I/O开销。
4. 用户体验：交互式工具应提供清晰的提示信息，支持输入回显和错误纠正，提升用户友好度。

通过以上方法,开发者可以根据具体场景灵活选择连续输入执行的实现方案，从简单的控制台交互到复杂的高并发处理，均能高效实现，掌握这些技巧不仅能提升代码质量，更能应对实际开发中的多样化需求。