每日 Java 面试题分享【第 13 天】

欢迎来到每日 Java 面试题分享栏目！
订阅专栏，不错过每一天的练习

今日分享 3 道面试题目！

评论区复述一遍印象更深刻噢~

目录

• 问题一：如何在 Java 中调用外部可执行程序或系统命令？
• 问题二：如果一个线程在 Java 中被两次调用 start() 方法，会发生什么？
• 问题三：栈和队列在 Java 中的区别是什么？

---

问题一：如何在 Java 中调用外部可执行程序或系统命令？

在 Java 中，可以通过 Runtime 类 或 ProcessBuilder 类 调用外部可执行程序或系统命令。以下是两种方法的详细说明和使用示例。

---

方法 1：使用 Runtime 类

代码示例

public class RuntimeExample {public static void main(String[] args) {try {// 调用系统命令（如 Windows 的 dir 或 Linux 的 ls）Process process = Runtime.getRuntime().exec("ls"); // 替换为需要的命令// 获取命令执行的输出try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}}// 等待命令执行完成int exitCode = process.waitFor();System.out.println("退出码：" + exitCode);} catch (Exception e) {e.printStackTrace();}}
}

注意

1. 返回的 Process 对象：
   • Process 表示外部进程，可以用来获取输出流、错误流，并控制进程的生命周期。
2. 输出流的读取：
   • 如果不读取或关闭进程的输出流，可能会导致进程阻塞。

优点

• 简单直接，代码量少。

缺点

• 不够灵活，难以传递复杂参数或处理多个 I/O。

---

方法 2：使用 ProcessBuilder 类

代码示例

import java.io.BufferedReader;
import java.io.InputStreamReader;public class ProcessBuilderExample {public static void main(String[] args) {try {// 创建 ProcessBuilderProcessBuilder processBuilder = new ProcessBuilder();// 设置要执行的命令（可带参数）processBuilder.command("ping", "www.google.com");// 合并错误流和标准输出流（可选）processBuilder.redirectErrorStream(true);// 启动进程Process process = processBuilder.start();// 读取进程输出try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}}// 等待进程完成并获取退出码int exitCode = process.waitFor();System.out.println("退出码：" + exitCode);} catch (Exception e) {e.printStackTrace();}}
}

优点

• 更灵活：
  • 支持设置环境变量：processBuilder.environment().put("ENV_VAR", "value");
  • 支持设置工作目录：processBuilder.directory(new File("/path/to/dir"));
• 可读性好：链式调用清晰明了。

缺点

• 比 Runtime 稍微复杂一点。

---

两种方法的对比

特性	Runtime	ProcessBuilder
使用简单性	更简单	略复杂
灵活性	较低	较高
支持环境变量设置	不支持	支持
合并输出和错误流	需要手动实现	直接支持（redirectErrorStream）
推荐程度	适合简单命令调用	更推荐，适合复杂调用场景

---

常见使用场景

1. 运行系统命令：

   • 例如在 Linux 上执行 ls 或在 Windows 上执行 dir。
   • 使用 ProcessBuilder 的 command 方法可以方便地传递参数。

2. 调用外部可执行程序：

   • 例如运行 .exe 文件、Python 脚本、Shell 脚本等。
   • 确保路径正确，并且有足够权限执行外部程序。

3. 环境变量控制：

   • 使用 ProcessBuilder.environment() 可以轻松传递自定义的环境变量。

4. 读取命令输出：

   • 无论是标准输出还是错误输出，Java 都可以捕获并处理。

---

注意事项

1. 路径问题：

   • 确保外部命令或可执行程序的路径正确，建议使用绝对路径。
   • 如果使用相对路径，请确保工作目录正确设置（ProcessBuilder.directory()）。

2. 阻塞问题：

   • 如果外部进程产生大量输出，但未被读取，会导致阻塞。
   • 建议及时读取或关闭进程的输出和错误流。

3. 跨平台性：

   • 不同操作系统的命令语法可能不同，编写代码时需注意适配性。

4. 权限问题：

   • 运行外部程序可能需要特定的权限，特别是在受限的环境（如服务器）中。

---

扩展

如何执行带空格的命令或参数？

• 使用 ProcessBuilder.command() 方法，将每个参数单独传递为列表元素。

  ProcessBuilder processBuilder = new ProcessBuilder();
  processBuilder.command("cmd.exe", "/c", "echo", "Hello World!");
  

如何处理输入流（标准输入）？

• 使用 Process 对象的 getOutputStream() 方法，向外部进程写入数据。

  Process process = new ProcessBuilder("cat").start();
  try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()))) {writer.write("Hello from Java!");writer.flush();
  }
  

---

总结

在 Java 中调用外部程序时：

• 简单任务使用 Runtime.getRuntime().exec()；
• 复杂任务优先使用 ProcessBuilder，以获得更好的灵活性和控制力。

---

问题二：如果一个线程在 Java 中被两次调用 start() 方法，会发生什么？

问题分析

在 Java 中，Thread 类的 start() 方法被用来启动一个新线程。如果尝试对同一个线程对象调用两次 start() 方法，会发生异常。

---

答案

如果对同一个线程对象调用两次 start() 方法，第二次调用会抛出 IllegalThreadStateException 异常。这是因为线程一旦启动后，其状态会从 NEW（新建） 转变为其他状态（如 RUNNABLE、TERMINATED 等）。根据 Java 线程模型，已经启动过的线程对象不能被重新启动。

---

代码示例

public class ThreadStartExample {public static void main(String[] args) {Thread thread = new Thread(() -> {System.out.println("线程正在运行…");});// 第一次启动线程thread.start();// 再次调用 start() 方法try {thread.start(); // 这里会抛出 IllegalThreadStateException} catch (IllegalThreadStateException e) {System.out.println("异常信息：线程已经启动过，不能再次调用 start()");}}
}

运行结果

线程正在运行…
异常信息：线程已经启动过，不能再次调用 start()

---

原因分析

1. 线程生命周期

线程的生命周期如下：

• NEW：线程对象被创建，但未调用 start()。
• RUNNABLE：调用 start() 后，线程处于可运行状态。
• TERMINATED：线程运行完毕，进入终止状态。

当线程离开 NEW 状态后，不能回到 NEW，因此无法再次启动。

2. start() 方法的作用

start() 方法的核心功能是：

• 通知 JVM 创建一个新的线程（底层通过本地方法调用操作系统线程）。
• 将线程状态从 NEW 改为 RUNNABLE，并让线程进入可调度队列。

第二次调用 start() 时，由于线程不再是 NEW 状态，JVM 会拒绝这个操作，抛出异常。

3. 设计初衷

Java 线程模型的设计目的是让每个 Thread 对象只启动一次，避免复杂的状态管理（如重新初始化线程）。如果需要再次启动线程，应该创建一个新的 Thread 实例。

---

扩展讲解

如何避免这种问题？

• 检查线程状态：如果需要对线程进行管理，可以通过 Thread.getState() 方法检查其状态。

  示例代码：

  public class ThreadStateCheck {public static void main(String[] args) {Thread thread = new Thread(() -> {System.out.println("线程运行中…");});System.out.println("线程状态：" + thread.getState()); // NEWthread.start();System.out.println("线程状态：" + thread.getState()); // RUNNABLE 或 TERMINATEDtry {thread.start(); // 再次调用会抛异常} catch (IllegalThreadStateException e) {System.out.println("异常：线程已经启动过");}}
  }
  

• 重新创建线程对象：如果需要重复执行任务，可以通过新建线程实现：

  Thread thread1 = new Thread(() -> System.out.println("任务 1"));
  thread1.start();Thread thread2 = new Thread(() -> System.out.println("任务 2"));
  thread2.start();
  

线程池的使用

如果需要多次执行相同任务，推荐使用线程池（ExecutorService），而非手动管理 Thread 对象。例如：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadPoolExample {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(2);Runnable task = () -> System.out.println("任务正在运行…");executor.execute(task); // 启动任务executor.execute(task); // 再次启动任务executor.shutdown();}
}

线程池可以高效管理线程复用，避免直接操作线程带来的复杂性。

---

总结

1. 对一个线程对象调用两次 start() 方法会抛出 IllegalThreadStateException。
2. 每个线程对象只能启动一次。如果需要重新运行任务，需要新建线程实例或使用线程池。
3. 推荐使用线程池（如 ExecutorService）来管理多次任务执行，避免手动控制线程的复杂性。

---

问题三：栈和队列在 Java 中的区别是什么？

栈和队列的区别

栈（Stack）和队列（Queue）是两种常用的线性数据结构，它们在数据存取方式和应用场景上有显著的区别。以下从定义、操作规则、实现和应用等方面进行分析：

---

1. 栈 (Stack)

定义

栈是一种**后进先出（LIFO, Last In First Out）**的数据结构，即最后插入的数据最先被取出。

核心操作

• push(E item)：将元素压入栈顶。
• pop()：移除并返回栈顶元素。
• peek()：仅返回栈顶元素，但不移除。

Java 实现

• 使用 java.util.Stack 类。

• 示例代码：

  import java.util.Stack;public class StackExample {public static void main(String[] args) {Stack<Integer> stack = new Stack<>();stack.push(10);stack.push(20);stack.push(30);System.out.println("栈顶元素：" + stack.peek()); // 输出 30System.out.println("弹出元素：" + stack.pop()); // 输出 30System.out.println("弹出后栈顶：" + stack.peek()); // 输出 20}
  }
  

---

2. 队列 (Queue)

定义

队列是一种**先进先出（FIFO, First In First Out）**的数据结构，即最先插入的数据最先被取出。

核心操作

• add(E item) 或 offer(E item)：将元素添加到队列尾部。
• remove() 或 poll()：移除并返回队列头部元素。
• element() 或 peek()：仅返回队列头部元素，但不移除。

Java 实现

• 使用 java.util.Queue 接口的实现类，例如 LinkedList 或 ArrayDeque。

• 示例代码：

  import java.util.LinkedList;
  import java.util.Queue;public class QueueExample {public static void main(String[] args) {Queue<Integer> queue = new LinkedList<>();queue.offer(10);queue.offer(20);queue.offer(30);System.out.println("队列头元素：" + queue.peek()); // 输出 10System.out.println("移除元素：" + queue.poll()); // 输出 10System.out.println("移除后队列头：" + queue.peek()); // 输出 20}
  }
  

---

3. 栈与队列的主要区别

特性	栈 (Stack)	队列 (Queue)
访问规则	后进先出（LIFO）	先进先出（FIFO）
常用方法	push()、pop()、peek()	offer()、poll()、peek()
插入位置	栈顶	队尾
移除位置	栈顶	队头
实现方式	使用 java.util.Stack	使用 java.util.Queue 接口及实现类
常见应用场景	递归、括号匹配、函数调用栈、回溯算法	消息队列、任务调度、广度优先搜索

---

4. 特殊队列：双端队列 (Deque)

定义

双端队列（Deque, Double-Ended Queue）允许在队首和队尾同时插入和移除元素。

实现

• 使用 java.util.ArrayDeque 或 java.util.LinkedList。

• 示例代码：

  import java.util.Deque;
  import java.util.ArrayDeque;public class DequeExample {public static void main(String[] args) {Deque<Integer> deque = new ArrayDeque<>();deque.addFirst(10); // 插入到队首deque.addLast(20);  // 插入到队尾System.out.println("队首元素：" + deque.peekFirst()); // 输出 10System.out.println("队尾元素：" + deque.peekLast());  // 输出 20deque.removeFirst(); // 移除队首deque.removeLast();  // 移除队尾}
  }
  

应用

• 双端队列可用于实现栈或队列的功能，也可以用作滑动窗口算法等高级场景。

---

5. 实际应用场景

• 栈：
  • 函数调用栈
  • 括号匹配
  • 表达式求值
  • 深度优先搜索（DFS）
• 队列：
  • 任务调度
  • 广度优先搜索（BFS）
  • 消息队列
  • 缓冲区管理

---

总结

• 栈是后进先出的数据结构，常用于递归、回溯等场景。
• 队列是先进先出的数据结构，适合任务调度和广度优先搜索等场景。
• 双端队列是栈和队列的通用化版本，既可以实现栈的功能，也可以实现队列的功能。

---

总结

今天的 3 道 Java 面试题，您是否掌握了呢？持续关注我们的每日分享，深入学习 Java 面试的各个细节，快速提升技术能力！如果有任何疑问，欢迎在评论区留言，我们会第一时间解答！

明天见！🎉