Java：Scanner中的nextInt()方法——从输入阻塞到异常处理的完整避坑指南

1. 为什么你的 Scanner.nextInt() 总是卡住或报错

如果你刚开始学 Java，或者正在写一个控制台小工具，大概率绕不开Scanner这个类。它用起来确实方便，nextInt()一行就能把键盘输入的数字读进来。但很多人第一次踩坑，就是从这个方法开始的：程序明明提示“请输入年龄”，你敲了 25 回车，结果它直接抛出一个InputMismatchException；或者你连着写两个输入，第二个nextLine()还没等你打字就自己跳过去了。

这些现象背后其实是同一个原因：Scanner是基于分隔符（默认是空白符，包括空格、Tab、换行）来切分输入的，而nextInt()只负责把“数字那一段”拿走，剩下的换行符\n还留在缓冲区里。下一次调用nextLine()时，它一看缓冲区里有个换行符，直接返回一个空字符串，看起来就像“跳过”了输入。

我试过在初学阶段写一个“输入姓名和年龄”的小程序，结果姓名永远读不到，排查了半天才发现是nextInt()留下的换行符在捣乱。这篇文章就围绕Scanner.nextInt()这个核心方法，把输入阻塞、换行符残留、InputMismatchException这三类高频问题拆开讲清楚，并且给出可以直接复制到 IDE 里运行的代码，帮你从“能跑但不知道为什么”过渡到“知道每一步在干什么”。

适合谁看：Java 初学者、正在做控制台交互练习的后端开发者、以及被nextInt()和nextLine()混用折磨过的同学。你不需要很深的 Java 基础，只要能写main方法、会用System.out.println就够了。下面我会先讲清楚问题场景，再给出可复制的配置和验证步骤，最后把常见报错逐个对照排查。

2. Scanner.nextInt() 输入阻塞与换行符残留问题拆解

要理解nextInt()的行为，先要理解Scanner的工作方式。你可以把Scanner想象成一个“分词器”：它从输入流里不断读取字符，按照分隔符把内容切成一个个 token。默认分隔符是\p{javaWhitespace}+，也就是一个或多个空白字符，包括空格、制表符、换行符、回车符等。

当你调用nextInt()时，Scanner会做这几件事：跳过前面的空白符，读取接下来的字符，尝试把它们解析成一个 int。如果解析成功，它就把这个 token 消费掉，游标停在这个 token 之后。注意，它不会把 token 后面的换行符也吃掉。也就是说，你输入25\n，nextInt()只拿走了25，那个\n还留在缓冲区里。

这就解释了第一个经典问题：nextInt()之后调用nextLine()，nextLine()会读取“从当前游标到下一个换行符之间的内容”。因为游标正好停在\n前面，nextLine()读到的就是一个空字符串，然后把这个\n消费掉。用户感觉就是“我还没输入，它就跳过了”。

第二个问题是输入阻塞。Scanner的很多方法在缓冲区没有可用 token 时，会阻塞等待输入。比如你调用nextInt()，但用户一直不输入或者只输入空格，程序就停在那里。这在命令行工具里是正常行为，但如果你在循环里反复调用nextInt()却没有正确处理非数字输入，就会陷入“报错—继续—再报错”的循环，或者直接卡死。

第三个问题是InputMismatchException。当nextInt()读到的 token 不能被解析成 int 时，比如用户输入了abc或者25.5，就会抛出这个异常。更麻烦的是，抛出异常后，那个“坏 token”并没有被消费掉，还留在缓冲区里。如果你在 catch 块里继续调用nextInt()，它会再次读到同一个坏 token，再次抛异常，形成死循环。

下面用一个表格把nextInt()和nextLine()的行为差异列清楚，方便你对照：

方法	读取内容	是否消费换行符	遇到非数字	典型阻塞场景
nextInt()	下一个 int token	否	抛 InputMismatchException	缓冲区无 token 时等待输入
nextLine()	当前行剩余内容	是	不解析，直接返回字符串	缓冲区无行时等待输入
next()	下一个字符串 token	否	不适用	缓冲区无 token 时等待输入
nextDouble()	下一个 double token	否	抛 InputMismatchException	缓冲区无 token 时等待输入

理解了这张表，很多“诡异”现象就都能解释了。比如你写int a = in.nextInt(); String s = in.nextLine();，输入10\nhello\n，a得到 10，s得到空字符串，因为nextLine()读的是10后面那个\n之前的内容，也就是空。正确的做法是在nextInt()之后额外调用一次nextLine()把残留的换行符“吃掉”，或者统一用nextLine()读整行再自己解析。

还有一个容易被忽略的点：Scanner的hasNextInt()方法。它会在不消费 token 的情况下判断下一个 token 是否是 int。如果你在循环里用while (in.hasNextInt())，当用户输入非数字时循环会退出，但那个非数字 token 还在缓冲区里。如果你之后又调用nextLine()，可能会读到它。所以hasNextInt()适合做“预检”，但不能替代对异常的处理。

在实际项目里，控制台交互虽然简单，但输入校验的逻辑一点都不能少。尤其是做命令行工具、算法题练习、或者教学 demo 时，用户输入是不可控的，必须假设他们会输入字母、小数、空行、超长数字。下面我会给出一个可复制的Scanner配置模板，把这些问题一次性处理掉。

3. 可复制的 Scanner 配置与 nextInt 安全读取模板

这一节直接给代码。你可以新建一个 Java 类，把下面的模板复制进去，在本地 IDE（IntelliJ IDEA、Eclipse、VS Code 都行）里运行。这个模板的核心思路是：统一用nextLine()读取整行，再用Integer.parseInt()解析数字，从根源上避开换行符残留和InputMismatchException的坑。同时保留一个nextInt()的对比示例，让你看清两种方式的差异。

先看推荐的“安全读取”模板：

import java.util.Scanner; public class SafeScannerDemo { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("请输入你的年龄："); String line = in.nextLine().trim(); int age; try { age = Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println("输入的不是合法整数：" + line); in.close(); return; } System.out.print("请输入你的姓名："); String name = in.nextLine().trim(); System.out.println("年龄 = " + age); System.out.println("姓名 = " + name); in.close(); } }

这段代码里，nextLine()会把整行读进来，包括用户可能多打的空格，所以用trim()去掉首尾空白。Integer.parseInt()在遇到非数字时会抛NumberFormatException，我们捕获它并给出友好提示。这样就不会出现“坏 token 留在缓冲区导致死循环”的问题，因为nextLine()已经把整行消费掉了。

如果你确实想用nextInt()，那就要显式处理换行符残留。下面是对比示例：

import java.util.Scanner; public class NextIntDemo { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("请输入一个整数："); if (in.hasNextInt()) { int num = in.nextInt(); in.nextLine(); // 关键：吃掉残留的换行符 System.out.println("你输入的数字是：" + num); } else { String bad = in.nextLine(); // 消费掉非法输入，避免死循环 System.out.println("不是合法整数：" + bad); } System.out.print("请输入一行文字："); String text = in.nextLine(); System.out.println("文字内容：" + text); in.close(); } }

这里有两个关键点。第一，in.nextInt()之后立刻调用in.nextLine()，把那个残留的\n消费掉，这样后面的nextLine()才能正常读到用户输入的文字。第二，用hasNextInt()做预检，如果下一个 token 不是 int，就用nextLine()把这一行消费掉，避免坏 token 一直留在缓冲区。

如果你在写一个需要反复读取数字的循环，比如“输入多个成绩，输入 -1 结束”，可以这样写：

import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class LoopInputDemo { public static void main(String[] args) { Scanner in = new Scanner(System.in); List<Integer> scores = new ArrayList<>(); System.out.println("请输入成绩，每行一个，输入 -1 结束："); while (true) { String line = in.nextLine().trim(); if (line.isEmpty()) { continue; } int value; try { value = Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println("跳过非法输入：" + line); continue; } if (value == -1) { break; } scores.add(value); } System.out.println("共录入 " + scores.size() + " 个成绩：" + scores); in.close(); } }

这个循环里，每次都用nextLine()读一整行，空行直接跳过，非法输入提示后继续，完全不会阻塞也不会抛异常。实测下来，这种写法在控制台交互里最稳，代码也不复杂。

关于Scanner的配置，还有一个细节：Scanner默认使用当前系统的区域设置来解析数字。如果你在有的环境里输入1,5期望解析成 1.5，可能会失败。对于nextInt()来说，它只认整数，不受小数点影响，但如果你混用nextDouble()，就要注意区域设置。可以在创建Scanner时指定Locale.US：

Scanner in = new Scanner(System.in).useLocale(java.util.Locale.US);

这样小数点统一用.，避免在不同系统上行为不一致。对于纯nextInt()场景，这个配置不是必须的，但加上更保险。

最后提醒一句：Scanner实现了Closeable，用完要close()。不过在System.in上调用close()会关闭标准输入流，如果你的程序后面还要读输入，就别提前关。一般建议在程序结束前统一关闭，或者用 try-with-resources 包起来。但System.in是全局的，关闭后无法再打开，所以很多示例干脆不关，这在短生命周期的控制台程序里是可以接受的。

4. 分步验证 nextInt 与 nextLine 混用场景

光看代码还不够，最好自己动手跑一遍，亲眼看到缓冲区里发生了什么。下面我设计了一组分步验证，你可以在 IDE 里新建一个类，按步骤修改代码并观察输出。每一步都对应一个典型现象，跑完你就能彻底理解nextInt()的行为。

第一步：复现换行符残留导致的“跳过输入”

新建Step1.java：

import java.util.Scanner; public class Step1 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("输入年龄："); int age = in.nextInt(); System.out.print("输入姓名："); String name = in.nextLine(); System.out.println("age=" + age + ", name=[" + name + "]"); in.close(); } }

运行后，在控制台输入25然后回车，再输入Tom回车。你会看到输出是age=25, name=[]，姓名是空的。原因就是nextInt()只拿走了25，\n留在缓冲区，nextLine()读到空字符串。这一步验证了换行符残留。

第二步：手动消费换行符

把Step1改成Step2，在nextInt()后面加一行in.nextLine();：

import java.util.Scanner; public class Step2 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("输入年龄："); int age = in.nextInt(); in.nextLine(); // 消费残留换行符 System.out.print("输入姓名："); String name = in.nextLine(); System.out.println("age=" + age + ", name=[" + name + "]"); in.close(); } }

同样输入25回车、Tom回车，这次输出age=25, name=[Tom]，姓名正常读到了。这一步验证了“多调用一次nextLine()”可以解决混用问题。

第三步：复现 InputMismatchException

新建Step3.java：

import java.util.Scanner; public class Step3 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("输入一个整数："); int num = in.nextInt(); System.out.println("num=" + num); in.close(); } }

运行后输入abc回车，程序会抛出InputMismatchException，堆栈信息里能看到Scanner.nextInt相关调用。这一步验证了非数字输入会触发异常。

第四步：用 hasNextInt 预检避免异常

新建Step4.java：

import java.util.Scanner; public class Step4 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("输入一个整数："); if (in.hasNextInt()) { int num = in.nextInt(); System.out.println("num=" + num); } else { String bad = in.nextLine(); System.out.println("非法输入：" + bad); } in.close(); } }

输入abc回车，输出非法输入：abc，不再抛异常。这一步验证了hasNextInt()的预检作用。

第五步：验证坏 token 残留导致的死循环

新建Step5.java：

import java.util.Scanner; public class Step5 { public static void main(String[] args) { Scanner in = new Scanner(System.in); while (true) { System.out.print("输入整数（0 退出）："); try { int num = in.nextInt(); if (num == 0) break; System.out.println("读到：" + num); } catch (Exception e) { System.out.println("发生异常，但坏 token 还在缓冲区"); } } in.close(); } }

运行后输入abc回车，你会看到程序疯狂打印“发生异常，但坏 token 还在缓冲区”，根本停不下来。这就是坏 token 没有被消费导致的死循环。要修复它，需要在 catch 块里加in.nextLine();把坏 token 消费掉。

第六步：用 nextLine + parseInt 统一处理

把Step5改成用nextLine()读取：

import java.util.Scanner; public class Step6 { public static void main(String[] args) { Scanner in = new Scanner(System.in); while (true) { System.out.print("输入整数（0 退出）："); String line = in.nextLine().trim(); if (line.isEmpty()) continue; int num; try { num = Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println("非法输入：" + line); continue; } if (num == 0) break; System.out.println("读到：" + num); } in.close(); } }

输入abc回车，输出“非法输入：abc”，然后继续等待下一次输入，不会死循环。输入0退出。这一步验证了统一用nextLine()的稳定性。

跑完这六步，你应该对nextInt()的换行符残留、异常、阻塞都有了直观感受。下面把常见报错和排查方法整理成对照表，方便你遇到问题时快速定位。

5. Scanner.nextInt 常见报错排查对照

这一节把实际开发中高频出现的报错和现象列出来，每条都给出原因和修复动作。你可以把它当成一个速查表，遇到问题先对照，再回到上面的模板里找对应写法。

报错一：java.util.InputMismatchException

完整堆栈通常长这样：

Exception in thread "main" java.util.InputMismatchException at java.base/java.util.Scanner.throwFor(Scanner.java:939) at java.base/java.util.Scanner.next(Scanner.java:1594) at java.base/java.util.Scanner.nextInt(Scanner.java:2258) at Step3.main(Step3.java:7)

原因：nextInt()读到的 token 不是合法整数，比如abc、25.5、1,000。修复：用hasNextInt()预检，或者在 catch 块里用nextLine()消费坏 token。推荐直接用nextLine()+Integer.parseInt()。

报错二：java.lang.NumberFormatException: For input string: "abc"

这个异常通常出现在你用Integer.parseInt()手动解析时。原因和上面类似，输入不是数字。修复：捕获NumberFormatException，给出提示并继续循环。注意parseInt不会处理前后空格，所以要先trim()。

报错三：nextLine()返回空字符串，看起来像“跳过输入”

现象：nextInt()之后调用nextLine()，后者直接返回空。原因：nextInt()留下了\n。修复：在nextInt()后加一次in.nextLine();，或者统一用nextLine()读整行。

报错四：程序卡住不输出，像“输入阻塞”

现象：运行后光标一直闪，程序不继续。原因：Scanner在等待输入，但你可能在循环里反复调用nextInt()而没有消费坏 token，或者输入流没有正确结束。修复：检查循环逻辑，确保每次迭代都有消费 token；在命令行里可以用 Ctrl+D（Linux/Mac）或 Ctrl+Z（Windows）发送 EOF。注意，这不是“代理”或“网络”问题，纯粹是输入流等待。

报错五：java.util.NoSuchElementException

完整信息可能是NoSuchElementException: No line found或NoSuchElementException。原因：在输入流已经结束（EOF）后继续调用nextLine()或nextInt()。常见于从文件读取时文件已到末尾，或者你在System.in上提前调用了close()。修复：用hasNextLine()或hasNextInt()判断是否还有输入，避免在流关闭后继续读。

报错六：IllegalStateException: Scanner closed

原因：调用了in.close()之后又调用nextInt()或nextLine()。修复：确保close()只在程序结束前调用一次，或者干脆不关闭System.in的Scanner。

报错七：数字读进来但值不对，比如输入 25 得到 2

原因：你可能用了next()而不是nextInt()，或者next()按空白符切分，把25拆成了2和5？实际上next()会读整个 token，不会拆。更可能的原因是你在循环里多次调用nextInt()，但输入格式和预期不一致。修复：打印每次读到的值，对照输入逐行排查。

报错八：local proxy failed或OAuth相关提示

这类信息通常和Scanner无关，属于网络或认证层面的问题。如果你在控制台程序里看到类似字样，先确认是不是你的程序在调用外部服务。Scanner本身只处理标准输入，不涉及网络。排查时把网络相关代码和输入读取代码分开，先确保输入部分独立可运行。

报错九：reading choices之类的日志

这也不是Scanner的报错，可能是某个库在读取配置。排查思路同上：先隔离输入逻辑，用最小可复现代码验证nextInt()行为。

报错十：中文输入乱码

原因：控制台编码和 JVM 默认编码不一致。修复：在 IDE 的运行配置里加上-Dfile.encoding=UTF-8，或者在Scanner创建时指定字符集：

Scanner in = new Scanner(System.in, "UTF-8");

注意Scanner的这个构造方法会抛UnsupportedEncodingException，需要处理。

把上面这些对照着看，你会发现大部分nextInt()的问题都围绕“token 消费”和“换行符残留”两个点。只要记住：nextInt()不消费换行符，坏 token 不消费会死循环，用nextLine()读整行最稳，就能避开绝大多数坑。

6. 从 Scanner 到稳定输入：接入与验证的下一步

控制台输入看起来简单，但它是很多后端工具、算法练习、教学 demo 的入口。把Scanner.nextInt()的脾气摸清楚，后面写文件读取、命令行参数解析、甚至简单的交互式脚本都会顺很多。如果你想把输入校验做得更工程化，可以考虑把“读取一行 + 解析 + 异常处理”封装成一个工具方法，比如：

public static int readInt(Scanner in, String prompt) { while (true) { System.out.print(prompt); String line = in.nextLine().trim(); if (line.isEmpty()) continue; try { return Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println("请输入合法整数，你输入的是：" + line); } } }

这样在主流程里只需要int age = readInt(in, "请输入年龄：");，代码干净，行为稳定。类似的还可以封装readDouble、readNonEmptyLine等。

如果你在本地 IDE 里验证完上面的代码，想进一步测试不同模型对 Java 代码的解释能力，或者让模型帮你生成更多边界用例，可以到模型对话页面直接贴代码提问，对比不同模型的回答质量。地址是 https://taotoken.net/api-keys ，先拿到 API Key，再配合接入文档 https://taotoken.net/doc 把调用跑通。对于需要长期写代码、做 Agent 实验的场景，Coding Plan 会更合适，入口在 https://taotoken.net/coding-plan 。

回到Scanner本身，最后再强调三个实用技巧。第一，永远假设用户会输入非法内容，用nextLine()读整行再解析，比直接用nextInt()省心。第二，如果非要用nextInt()，记得在它后面补一次nextLine()，并且在 catch 块里消费坏 token。第三，Scanner用完要关闭，但System.in关闭后不可恢复，短程序可以不关，长程序要规划好生命周期。把这三条落实到你的代码里，InputMismatchException和输入阻塞基本就告别了。