简介：这份Java基础知识笔试题及答案面向准备笔试、面试或课程复习的Java初学者与中级开发者，围绕基本概念、数据类型、运算符、控制结构、函数、数组、集合框架、泛型与封装等知识点组织练习，并配有参考答案，便于自测与查漏补缺。资源包共1个docx文件，大小约25KB，内容以选择题、代码运行结果分析、简答题和编程题为主，涵盖字符串比较与替换、Calendar日期计算、LinkedList堆栈实现、日期间隔计算等典型题型，可直接用于考前刷题或课堂练习。当前已有1308人学习下载，适合希望用较短时间梳理Java基础、熟悉常见笔试问法并对照答案复盘的读者。
1. Java 基础笔试的分数地图：先看清哪些题是送分，哪些题是分水岭
Java 基础知识笔试题及答案这类卷子，题型分布很固定：十几道单选、两三道读程序写输出、四五道编程题。分值也稳定——选择题占四到五成，几乎全是「记住就对、记错就错」的硬点：包装类、equals、Calendar.getInstance、Set 与 Map 的重复元素、Throwable 是父类。真正拉开差距的是输出题和编程题：LinkedList 按下标插入越界、try/finally 里有 return、数组元素打印出 0 和 null，这些不考你背没背，考你有没有在脑子里跑过一遍。下面按「考什么 → 高频考点 → 怎么答 → 错在哪」往下推，适合临考两周拿来对着练，也适合面试前把基础盘一遍。
2. 高频考点：String、包装类与 equals 的四类必考题
2.1 包装类清单：八个基本类型对应八个类，第 1 题和第 9 题都在考它
第 1 题问「Java 中提供名为（）的包装类来包装原始字符串类型」，选项给了 Integer、Char、Double、String，答案是 String。这题看着简单，但命题人真正在筛选的是你知不知道「包装类」的完整清单：byte 对 Byte、short 对 Short、int 对 Integer、long 对 Long、float 对 Float、double 对 Double、char 对 Character、boolean 对 Boolean，一共八组。其中 int→Integer 和 char→Character 是全称拼写，没有缩写，这是最容易写错的两个。
第 9 题「Java 语言中的封装类有哪些」，标准答案就是 Double、Integer、Float、Byte、Long、Character、Short、Boolean 这八个。答题时注意两点：一是别把 String 混进去，String 是引用类型、是类，本身不是包装类，第一题之所以选 D，是题干用「包装原始字符串」这种说法在引导你选它；二是别把 Void 或 BigInteger 写进去，它们不属于八个基本类型的包装。
面试场合如果被追问，面试官最想听的是：「包装类把基本类型包成对象，才能放进集合、才能为 null、才能调用 toString 与 parseXxx。」再加一句自动装箱拆箱的常识就够，不要往缓存区间那些没被问到的细节上飘。
提示：这一组题的复习方式不是背题，而是拿一张纸默写八个基本类型与对应包装类，两分钟默完，比刷十道同类选择题管用。
2.2 equals 与 ==：第 2 题和第 11 题为什么答案是两个样子
第 2 题问 java.lang 包的哪个方法比较两个对象是否相等、相等返回 true，答案是 equals()。toString() 返回字符串描述，compare() 在这个语境下是干扰项。这里要顺手把 equals 的默认行为记住：Object 里的 equals 比的是引用地址，String、Integer 这些类重写了它，改成比内容。
第 11 题就正好踩在这个分界上：str1 = “It is”，str2 = “It is”，然后分别打印 str1==str2 和 str1.equals(str2)。参考答案里两个都是 true。很多人凭手感写「== 是 false」，直接翻车。原因是字符串字面量会复用同一份常量池对象，两个变量指向同一处，== 自然为 true；而 equals 比内容，更是 true。换一种写法结论就变了：
String a = "It is"; String b = new String("It is"); // 强制在堆上新开一个对象 System.out.println(a == b); // false，引用不同 System.out.println(a.equals(b)); // true，内容相同这段代码的价值在于让你分清「== 比引用、equals 比内容」这句话什么时候显灵。答题模板可以固定成三句：== 比较的是引用是否指向同一对象；equals 在 Object 中默认等价于 ==，被 String 等类重写后比较内容；字面量赋值走常量池复用，new 出来的对象不复用。题目只要出现字符串比较，先看有没有 new，再看是不是字面量，八成不会错。
2.3 String.valueOf 的三个重载：10.0、true、bcd 从哪来
这道输出题的原文是：
char[] data = {'a', 'b', 'c', 'd'}; System.out.println(String.valueOf(10D)); // 10.0 System.out.println(String.valueOf(3 > 2)); // true System.out.println(String.valueOf(data, 1, 3));// bcd第一行传的是 10D，带 D 后缀就是 double 字面量，String.valueOf(double) 走的是浮点转字符串，输出带小数点，所以是 10.0 而不是 10。这里最容易丢分的地方是把 D 看成装饰，写成 10。第二行 3 > 2 是布尔表达式，命中 String.valueOf(boolean) 重载，输出 true。第三行是 String.valueOf(char[] data, int offset, int count)，从下标 1 开始取 3 个字符，得到 b、c、d 拼成 bcd。
参数说明要记牢：offset 是起始下标，count 是个数，不是结束下标。写成 valueOf(data,1,3) 如果理解成「下标 1 到 3」，就会答成 bcd 之外的错误答案——虽然这道题两个理解碰巧都落在 bcd 上，但只要换成 valueOf(data,1,2)，正确答案是 bc，按「1 到 2」理解也不会错，按「取到第 3 个」就会答成 bcd。考场上宁可多花十秒确认 count 的含义。
同类重载还有 String.valueOf(Object)、String.valueOf(char[])、String.valueOf(int)、String.valueOf(long) 等等。判断输出时先看实参的静态类型，再看有没有后缀，最后才动手写答案。
2.4 进制与类型转换：parseInt 的第二个参数、valueOf 与 toString 的分工
第 16 题要求把字符串 “200” 按十六进制转成 int，把 “123456” 转成 float。标准写法是：
String str1 = "200"; System.out.println(Integer.parseInt(str1, 16)); // 512，按 16 进制解析 String str2 = "123456"; System.out.println(Float.parseFloat(str2)); // 123456.0parseInt(String s, int radix) 的第二个参数是进制基数，不是「转成几进制」。这一点极其容易搞反：把 “200” 当十六进制读，值是 2×256 = 512；如果想表达「把十进制的 200 转成十六进制字符串」，用的不是 parseInt，而是 Integer.toHexString(200) 或 Integer.toString(200, 16)，结果是 “c8”。题面说「由十六进制转换为十进制」，那就只能是 parseInt 加 radix 这一条路。
第 17 题是把 long 型 987654 转字符串、把十进制 365 转十六进制字符串。前者 String.valueOf(987654L) 或 Long.toString 都行；后者标准答案给了一段手写的 DtoX 方法，原理是反复对 16 取余、把 10 到 15 映射成 A 到 F，再倒序拼接。这段手写代码在笔试卷上不算优雅，但它是命题人想看的「你会不会自己实现进制转换」。365 除以 16 得 22 余 13（D），22 除以 16 得 1 余 6，1 不够再除，结果是 16D。考场上如果允许，直接用 Integer.toHexString(365) 更快，但要在注释里写清思路，避免被判为「没按题意实现」。
2.5 数组默认值：那道输出 0 和 null 的题
原文第 8 题给了一段 Arrtest：
public class Arrtest { public static void main(String[] args) { int[] i = new int[5]; System.out.println(i[4]); // 0 amethod(); Object[] obj = new Object[5]; System.out.println(obj[2]); // null } public static void amethod() { int[] K = new int[4]; System.out.println(K[3]); // 0 } }输出顺序是 0、0、null。核心规则只有一条：数组一旦用 new 分配，元素立刻拥有类型的默认值——整型是 0，浮点是 0.0，布尔是 false，char 是空字符，引用类型是 null。局部变量本身没有默认值，必须初始化才能用，但「局部变量」和「局部变量指向的数组元素」是两码事，很多人就在这里混掉。
这道题的隐藏考点是输出顺序：main 里先打印 i[4]，再调用 amethod 打印 K[3]，最后打印 obj[2]，所以是 0、0、null，不是 0、null、0。读程序题务必按执行流逐行标号，别看到几个打印就凭印象排序。
3. 高频考点：集合框架与泛型的边界题，List、Set、Map 谁存重复元素
3.1 Set、List、Map 的重复元素边界，以及第 4 题为什么选 Map
先把三者的定位摆清楚：List 有序、可重复、按索引访问；Set 无序、不允许重复元素；Map 以键值对存储，键唯一、值可重复。第 4 题问「下面的集合中，（）不可以存储重复元素」，选项是 Set、Collection、Map、List，参考答案给的是 Map。这道题在题库里属于口径题：命题人想强调的是 Map 的键不能重复，同键 put 会覆盖旧值。Set 按定义同样不允许重复元素，但选项设计上把它当成「元素容器」这一侧来排除。
考场上遇到这种「Set 和 Map 同框」的单选，判断顺序建议是：先看题干问的是「元素」还是「键值」；问元素唯一性优先考虑 Set，问键唯一或键值覆盖优先考虑 Map；实在两难，按「哪个选项覆盖面最广、最不容易被举反例」来选。复习阶段更该记住的是结论本身：List 可重复，Set 去重，Map 键唯一值可重复，以及 Map 的 put 同键是覆盖不是新增。
3.2 Map 与 List 的关系：为什么答案落在「value 可以是 List 或 Map」
第 5 题的四个选项很有代表性：A 说 Map 继承 List，错，Map 和 List 是两条平行的接口线，Map 不是 Collection 的子接口；B 说 List 中可以保存 Map 或 List，在没加泛型限制时确实编译得过；C 说两者只能保存数据库取出的数据，明显错；D 说 Map 的 value 可以是 List 或 Map，对。参考答案选 D。
B 之所以不选，是因为这是单选题，命题人想考的是「Map 的 value 是 Object，什么都能装」这个结构性认识。答题时给自己一句口诀：Map 装的是键值对，value 位置可以再套一个 Map 或一个 List，形成嵌套结构，这在真实代码里就是「一个用户对应多条订单」的写法。
如果这题出现在面试里被追问，面试官最想听的是三层：Map 不继承 Collection；List 和 Set 继承 Collection；Map 的 key 用 equals 与 hashCode 定位，所以键对象要正确重写这两个方法。最后这句是加分项，笔试卷上写不出来不影响得分，面试里说出来就显出你用过。
3.3 LinkedList 按下标插入：编译通过、运行抛异常
第 6 题是典型的分水岭题：
import java.util.*; public class Test { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("A"); // 下标 0，size() 变成 1 list.add(2, "B"); // 下标 2 > size()=1，越界 String s = (String) list.get(1); System.out.println(s); } }答案选 B：运行时引发异常。原因是 add(int index, E element) 的合法范围是 0 ≤ index ≤ size()，插入前 size() 只有 1，index 取 2 就越界，抛 IndexOutOfBoundsException。注意它不是编译错误——参数类型是 int 和 Object，编译器管不着下标大小，这类「编译通过、运行炸掉」的题在卷子上年年出现。
如果题目改成 list.add(1, “B”)，index 等于 size()，属于合法的尾部追加，此时 get(1) 取到的就是 “B”，输出 B，答案变成 D。同一个题面改一个数字，选项就换人，这就是要你区分「下标上限是 size() 而不是 size()-1」的原因：插入允许等于 size，访问 get 才要求小于 size。
3.4 泛型三问的标准答法：是什么、优点、泛型 List 与普通 List 的区别
原文第 10 题把泛型拆成三问，这三问几乎是必背模板。第一问「什么是泛型」：泛型是对 Java 数据类型系统的扩展，支持创建按类型参数化的类，类型参数相当于使用时指定类型的一个占位符。第二问「优点」：提高类型安全，把类型错误从运行期提前到编译期；消除强制类型转换；提高代码重用率。三条按顺序写，一条不落。
第三问「泛型 List 和普通 List 有什么区别」，标准答法是：泛型 List 在声明时指定元素类型，只能存该类型及其子类型，取元素时不需要强转；普通 List 不带类型参数，什么对象都能塞进去，取出来必须自己强转，转错就在运行期抛 ClassCastException。再补一句编译期的差别：List 和 List 在编译期是两个不同的类型，不能互相赋值，但运行期类型擦除后都是 List。
面试追问常落在「类型擦除」上，能答出「泛型信息只存在于编译期，运行期被擦除成原始类型或上界」就够了，别往字节码细节上扯。
3.5 编程题：泛型 minmax 方法与数组转集合
第 19 题要求写一个泛型方法，返回 int 数组和 String 数组的最大最小值。判分点有三个：泛型方法声明、上界约束、返回值封装。
class Pair<T> { private T min, max; public Pair(T min, T max) { this.min = min; this.max = max; } public T getMin() { return min; } public T getMax() { return max; } } class ArrayAlg { // <T extends Comparable> 是必须的：没有上界就调不到 compareTo public static <T extends Comparable> Pair<T> minmax(T[] a) { if (a == null || a.length == 0) return null; T min = a[0], max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) min = a[i]; if (max.compareTo(a[i]) < 0) max = a[i]; } return new Pair<T>(min, max); } }这段代码的说明要点：方法签名里 写在返回值之前，这是泛型方法的标志，写在类上就是泛型类，两者不能混。上界 Comparable 决定了 T 必须有比较能力，否则 compareTo 编译不过。循环从下标 1 开始，因为 min 和 max 已经用了 a[0]。字符串数组走同一套逻辑，比较的是字典序。
第 20 题是反向操作，把数组元素搬进集合：
static <T> void fromArrayToCollection(T[] a, Collection<T> c) { for (T o : a) { c.add(o); } } // 调用：Integer[] ia 与 Collection<Number> cn，T 推导为 Number这里的考点是类型推导：形参是 T[] 和 Collection ，传入 Integer[] 与 Collection ，编译器把 T 推成 Number，而 Integer[] 是 Number[] 的子类型，所以合法。如果反过来传 Number[] 和 Collection ，就编译不过。答题时把「T 由实参共同推导，取最具体的公共父类型」写进注释，阅卷人一眼能看出你懂。
3.6 编程题：通讯录 List 与 Map 翻译
第 21 题要求 List 只能存通讯录对象，第 22 题要求用泛型 Map 做英译汉。这两题的分都在「泛型写没写全」上。
class Student { private String name, phone; public Student(String name, String phone) { this.name = name; this.phone = phone; } public String toString() { return name + ":" + phone; } // 决定打印效果 } List<Student> list = new ArrayList<Student>(); list.add(new Student("John", "23214")); list.add(new Student("Alice", "4563")); for (int i = 0; i < list.size(); i++) System.out.println(list.get(i));要点：List 的尖括号不能省，否则「只能存储通讯录」这个要求没落实；实体类要重写 toString，否则打印出来是哈希码，卷面上看不出效果。第 22 题同理：
Map<String, String> map = new HashMap<String, String>(); for (int i = 0; i < eng.length; i++) map.put(eng[i], chs[i]); System.out.println("Orange" + "翻译：" + map.get("Orange")); // 桔子Map 取值用 get(键)，键不存在返回 null，所以正式代码里要先判 null 再输出。这两道题阅卷看的是结构：泛型声明、集合选型、遍历方式、输出格式，四项齐了就是满分，不要在这上面玩花活。
4. 高频考点：异常处理机制的六道选择加两道编程
4.1 异常体系与 catch 顺序：Throwable 是根，Exception 排最后
第 3 题问所有异常的父类，选项 Error、Throwable、RuntimeException、Exception，答案是 Throwable。这条必须记死：Throwable 是根，下面分 Error 和 Exception 两支；Error 是程序无法处理的内部错误，Exception 才是通常说的异常，RuntimeException 是 Exception 的子类，代表运行时才暴露的那批。
第 5 题问能单独和 finally 一起使用的块，答案是 try。语法上 try 必须配 catch 或 finally，至少有一个；catch 和 finally 不能脱离 try 单独出现；throws 和 throw 是声明与抛出，跟这个搭配无关。
第 6 题问多重 catch 里哪个异常类该最后列，答案是 Exception。规则是子类在前、父类在后：ArrayIndexOutOfBoundsException、NumberFormatException、ArithmeticException 都是 Exception 的子类，写前面才能被精确捕获；把 Exception 提到最前面，后面所有分支都变成不可达代码，编译直接报错。这条规则在编程题里也常被扣分，写 catch 链时从具体到宽泛排一遍。
第 4 题问哪个操作不会抛异常，除数为零抛 ArithmeticException，负数索引访问数组抛 ArrayIndexOutOfBoundsException，打开不存在的文件抛文件相关异常，所以答案是「以上都会抛出异常」。这类题的答法是逐个在脑子里跑一遍，别凭「这个应该没事」的感觉选。
4.2 try/return/finally 的输出与返回值：finally 会把结果吃掉
第 8 题：
try { System.out.print("try，"); return; // 准备返回，但 finally 还没执行 } catch (Exception e) { System.out.print("catch，"); } finally { System.out.print("finally"); }输出是 try，finally。执行顺序是：进 try 打印，遇到 return 先把返回值存起来，然后必须执行 finally，打印完 finally 才真正返回。catch 没触发，所以不打印。
第 9 题更狠：
public int count() { try { return 5 / 0; // 抛 ArithmeticException } catch (Exception e) { return 2 * 3; // 准备返回 6 } finally { return 3; // 直接覆盖，最终返回 3 } }答案是 3。5/0 抛异常进 catch，准备返回 6，finally 里的 return 3 覆盖了这个返回值。这是血泪经验级的考点：只要 finally 里有 return，前面 try 和 catch 的 return 全部作废。写业务代码时不要在 finally 里写 return，它会吞掉异常和返回值；但考试就爱考这个反直觉的结论。
4.3 自定义异常：继承 Exception、重写 toString、throw 与 catch 配对
第 11 题要求输入字符串等于 “abc” 时抛自定义异常。判分点是四个动作齐全：
class MyException extends Exception { private String errorMsg; public MyException(String errorMsg) { this.errorMsg = errorMsg; } @Override public String toString() { return errorMsg; } // 决定打印内容 } // 使用处 try { if (strIn.equals("abc")) throw new MyException("输入的字符串不正确！"); } catch (MyException e) { System.out.println(e); // 打印 toString 的返回 }说明几点：自定义异常继承 Exception 属于受检异常，throw 之后必须 try-catch 或往上声明 throws，否则编译不过；构造方法里要把信息存下来，最好再调一次 super(errorMsg)，这样 getMessage() 也有值；重写 toString 是为了 System.out.println(e) 时输出可读内容，不重写就打印类名加哈希码。这三个细节少一个都会被扣分。
4.4 输入不合法也要跑下去：异常兜底的写法
第 12 题要求从键盘读两个数做减法，输入含非数字时靠异常机制让程序继续。参考结构是这样：
Scanner in = new Scanner(System.in); try { int num1 = Integer.parseInt(in.nextLine().trim()); int num2 = Integer.parseInt(in.nextLine().trim()); System.out.println(num1 - num2); } catch (NumberFormatException e) { System.out.println("输入的不是数字，请重新输入"); }关键在选对异常类型：parseInt 解析失败抛 NumberFormatException，属于 RuntimeException 的子类，不强制捕获，但题目要求「程序正常运行」，那就必须接住。如果改用 in.nextInt()，输入非数字抛的是 InputMismatchException，捕获类型就得跟着换。答题时把「用哪个方法读、抛哪个异常、捕获哪个类型」三件事对齐，是最容易被忽略的送分点。
5. 失分点：五个最容易在考场上写错的细节
5.1 错在把 Calendar 的 MONTH 当成 1 到 12
错在哪：第 12 题算 10 天后的日期，直接写 cal.get(Calendar.MONTH) 拼字符串，输出月份比真实月份小 1。为什么错：Calendar 的月份常量从 0 开始，JANUARY 是 0，DECEMBER 是 11，只有 DATE 和 YEAR 是自然数。怎么答对：拼月份时统一加 1，写成 (cal.get(Calendar.MONTH) + 1)。
Calendar cal = Calendar.getInstance(); cal.add(Calendar.DAY_OF_YEAR, 10); // 10 天后 String strDate = cal.get(Calendar.YEAR) + "年" + (cal.get(Calendar.MONTH) + 1) + "月" + cal.get(Calendar.DATE) + "日";同一族题还有第 14 题算两个日期间隔天数，写法是分别取 getTimeInMillis() 相减，再除以 24×60×60×1000。注意两个坑：一是除法是整数除法，余数被截断；二是如果两个日期带时分秒，结果会少一天，正式代码里先把时分秒清零，卷面上写一句注释说明即可。
5.2 错在 Scanner 一行三值读成三次 nextLine
错在哪：第 18 题要求输入 “3-100-2.1” 这种一行三值、以 - 分隔的格式，有考生写三次 nextLine 去接，结果后两次读到空串。为什么错：nextLine 是按行读，一行只有一行内容，读第二次当然读不到东西。怎么答对：先整行读进来，再用第二个 Scanner 包住这个字符串并设置分隔符。
Scanner scan = new Scanner(System.in); String strIn = scan.nextLine(); // 整行读入："3-100-2.1" Scanner sc = new Scanner(strIn); sc.useDelimiter("-"); // 把分隔符换成 - int num = sc.nextInt(); // 3 int bag = sc.nextInt(); // 100 float price = sc.nextFloat(); // 2.1 double total = price * num * bag; // 630.0参数说明：useDelimiter 接受的是正则表达式，写 “-” 就行，写 “\-” 更保险；total 用 double 接，避免 float 乘法出现 629.9999 这种输出。总额算完记得核对题面给的样例，630 对上了再往下写。
5.3 错在异常类型张冠李戴：空指针、越界、算术异常分不清
错在哪：第 7 题 String str = null; new String(str); 有人答 IllegalArgumentException，实际抛 NullPointerException。第 10 题 arr 长度 2 访问 arr[2]，有人答 NullPointerException，实际是 ArrayIndexOutOfBoundsException。为什么错：三类异常触发的条件完全不同——对 null 调用方法或构造对象是空指针；下标超出 0 到 length-1 是越界；除数为零是 ArithmeticException。怎么答对：读题时先找「谁为 null」「下标是多少」「除数是不是 0」这三个信号，再对号入座，别整段扫一眼就下手。
5.4 错在 finally 里写 return，还去算 try 的返回值
错在哪：第 9 题算出 6，或者算出 0。为什么错：finally 一定执行，里面的 return 会覆盖 try 和 catch 已经准备好的返回值；算成 0 的多半是把 5/0 当成了「返回 0」。怎么答对：在草稿上按「try 抛异常 → catch 准备返回 → finally 执行并覆盖」三步走，最后只看 finally 的 return。同一套思路可以推广到「finally 里改了对象字段，外面看到的是改后的值」这类变形题。
5.5 错在泛型方法漏写上界，编译不过还以为是逻辑错
错在哪：写 minmax 方法时签名只写 static Pair minmax(T[] a)，里面调 a[i].compareTo 编译报错。为什么错：T 没有上界，编译器只知道它是 Object，Object 没有 compareTo 方法。怎么答对：把签名改成 static Pair minmax(T[] a)，上界写在 T 后面、返回值前面；如果要比的是自定义类型，该类还得实现 Comparable 并重写 compareTo。写泛型题时先在草稿上标出「类型参数、上界、返回值」三处，再动手补方法体。
6. 答题技巧：读程序题的三步走和一份押题清单
读程序写输出的题，我建议固定走三步，不要在考场上凭直觉。第一步定编译：先扫有没有类型不匹配、下标常量越界、泛型签名缺上界、catch 顺序写反这类编译期问题，只要有一处，答案就是「编译错误」，后面的执行流根本不用推。第二步定异常：把每个可能抛异常的位置标出来，写明抛的是哪一类，看有没有被对应的 catch 接住，接不住的直接终止。第三步定输出：按执行顺序逐行写打印内容，遇到 return 和 finally 就在旁边画个箭头标明「谁覆盖谁」。三步走完再写答案，比读完题就下笔稳得多。
编程题反过来，顺序是「先骨架、再逻辑、后格式」。骨架指 import、类名、main 方法签名、方法声明，这些先写全，哪怕逻辑没写完也有结构性分数；逻辑指循环、判断、集合操作，一行一个动作，不追求炫技；格式指输出文案和题面给的样例对齐，题目说输出「销售总额为：630.0」就别自作主张改成中文冒号加单位。这三段任何一段塌了，都比我见过的「逻辑全对但类名写错导致零分」要轻。
押题清单按出现频率排，考前半小时扫一遍比刷题有用：
| 考点 | 常见出题形式 | 一句话答案 |
|---|---|---|
| 包装类清单 | 单选：哪个是包装类 / 列举封装类 | 八个基本类型对应八个类，int→Integer，char→Character |
| equals 与 == | 读程序写输出 | == 比引用，equals 被 String 重写后比内容，字面量走常量池 |
| 集合重复性 | 单选：谁不能存重复元素 | List 可重复，Set 去重，Map 键唯一值可重复 |
| 集合嵌套 | 单选：Map 与 List 的关系 | Map 的 value 可以再套 List 或 Map |
| 按下标插入 | 读程序写输出 | 插入下标上限是 size()，超过抛 IndexOutOfBoundsException |
| 泛型优点 | 简答三问 | 类型安全、免强转、提高复用率 |
| 异常根类 | 单选 | Throwable 是根，catch 里 Exception 放最后 |
| try/finally | 读程序写输出 | finally 一定执行，里面有 return 就覆盖前面的返回值 |
| 自定义异常 | 编程 | 继承 Exception，构造里存信息，重写 toString |
| 日期计算 | 编程 | MONTH 从 0 开始，记得加 1；间隔天数用毫秒差除以一天 |
| 输入分隔 | 编程 | 整行读入再 useDelimiter，别连着调 nextLine |
| 类型转换 | 编程 | parseInt(s, radix) 的第二个参数是进制基数 |
这套清单不是让你背答案，是让你在考场上看到题干能立刻归类——归到哪一类，就知道该调哪条规则，不用现场推导。
最后说一条我自己的习惯。早年做这类卷子，我最常犯的错不是不会，而是看到「输出结果」四个字就开始在脑子里跑代码，跑完直接写，从来不检查编译期。有一次一道 LinkedList 题我笃定输出 B，交卷后才发现插入下标越界，整道题白给。从那以后我每次做读程序题，都强制先问自己一句「这行编译得过吗」，再问「运行到这儿会不会抛」，最后才写输出。这个顺序救回来的分数，比多刷二十道题都实在。希望帮到你。
本文还有配套的精品资源，点击获取
