前阵子有学弟拿一份Java笔试题来问我，说自己LeetCode刷了几百道，结果看到“java基础”的单选题还是发懵。他说的这份题，就是网上讨论度不低的点我达2019届校招Java开发笔试。我把它完整过了一遍，又对照这几年常见的Java面试题、java面试八股文、java面试大全翻了翻，发现这套题放在今天依旧很有参考价值——它的考点覆盖得很典型：Java语法、面向对象、集合框架、并发、JVM、基础算法，再加一点工程化常识。这篇文章我就按这套题的考查维度，把每块背后的知识点、出题逻辑和易错点掰开讲，最后补一份能直接执行的备考古程。不管你是准备校招，还是工作一两年想回头补基础，都可以对照自查。
1. 这套笔试到底在筛什么样的人：先拆题目背后的用人逻辑
1.1 笔试不考你会多少，考的是基础牢不牢
很多同学在校招季有个错觉，以为笔试是“比谁刷题多”，所以拼命堆LeetCode题量，结果Java基础题错一半，编程题也没写利索。实际上，校招笔试是招聘流程里成本最低、覆盖面最广的一道筛选关卡，它要的不是“最聪明的人”，而是“基础最扎实的人”。
为什么？因为应届生普遍没有太多真实项目经验，简历上写的东西面试官很难短时间内验证。笔试反而给了所有人同一套题，考察的是最底层的知识体系：Java语法是否准确、面向对象是否真懂、集合和并发有没有踩过坑、JVM内存有没有概念、代码能不能一次写对。这些能力不是靠考前突击背题能糊弄过去的，它们是后面三个月试用期能不能快速上手干活的基础。
点我达2019届这套题就是典型代表。它没有出什么偏题怪题，所有考点都能在《Java核心技术》或Java官方文档里找到出处，但每一道题都埋了细节。但凡知识点只停留在“听过”而不是“理解”，做起来就会模棱两可。这其实就是出题人的初衷：筛掉那些简历写得花团锦簇、基本功却一塌糊涂的候选人。
1.2 一份重型Java笔试题的常见构成
从当年考生回忆和各平台讨论帖来看，这类校招笔试通常会分成四个模块：
| 题型 | 典型考点 | 考察能力 |
|---|---|---|
| 单选题 | Java基础语法、集合、面向对象、异常 | 知识准确性 |
| 多选题 | 并发、JVM、类加载、运算符边界 | 知识边界的清晰度 |
| 简答题 | Synchronized与Lock区别、HashMap原理 | 语言组织与原理深度 |
| 编程题 | 排序、链表、字符串处理、简单算法 | 手写代码的规范性与正确性 |
这四个模块组合起来，对应的是四个能力维度：基础是否牢、边界是否清、表达是否有条理、代码是否能跑通。很多同学做完题对答案时会发现，丢分最多的不是编程题，而是单选和多选里的那些“我以为我会”的题。这是最可惜的，因为基础题明明是可以靠系统复习拿满分的。
1.3 题目难不难不重要，通过线才是关键
这里要提醒一点：校招笔试的通过标准，从来不是“考到90分才过”。公司会根据当年hc数量、投递人数、笔试平均分画一条动态通过线，可能只有50分，也可能是70分。这意味着，即使你有一道编程题完全没写出来，只要基础题和简答题稳定拿分，照样能进面试。
所以我反复跟学弟学妹强调：笔试策略上，稳定拿分的单选多选优先于压轴编程题。先把会做的做完，再回头啃硬骨头；千万别在一道题上死磕40分钟，导致后面简单的题都没时间做。这套笔试真正想选拔的，是“在有限时间内能稳定输出的人”，而不是“某一道极限题能解出来的人”。
2. Java基础与面向对象：六个最容易丢分的细节考点
2.1 标识符、运算符和表达式：送分题为什么送不了分
Java基础题在笔试里占了很大比例，但正因为大家觉得简单，反而容易翻车。先看最基础的标识符命名。规则其实不难：字母、数字、下划线、美元符号组成；数字不能开头；不能用Java关键字和保留字；大小写敏感。但考试不会直接问你“标识符规则是什么”，而是给四个选项让你选“哪个是合法的标识符”，其中必然会混入2value、class、my-value、$name这类干扰项。这道题能快速淘汰那些只背过规则、没有实际写代码经验的考生。
运算符和表达式更是重灾区。比如：
int i = 0; int j = i++ + ++i; System.out.println(j);这行代码实际输出什么？很多人第一反应是1，但我可以告诉你，正确答案是2。为什么？因为i++先取当前值0参与运算，i变成1；++i是先自增到2再参与运算，0加2等于2。这种“左到右求值”的逻辑，只有真正在IDE里跑过代码的人才会留下深刻印象。
再看短路逻辑：
boolean a = false; boolean b = (a && (1 / 0 > 0));这段代码不会抛异常，因为&&左边为false时右边根本不会执行。同理||左边为true时右边也不会执行。笔试特别喜欢在“会不会抛异常”“输出什么”这种判断题里埋伏短路运算符，因为一眼看不出答案。
2.2 面向对象三大特性：继承体系下的初始化顺序
面向对象部分，封装、继承、多态三件套是必考。但现在的出题方式早就不是“什么是多态”这种简答题了，而是给一段多层继承代码，问“输出顺序是什么”。比如：
class A { static { System.out.print("A static "); } { System.out.print("A block "); } A() { System.out.print("A constructor "); } } class B extends A { static { System.out.print("B static "); } { System.out.print("B block "); } B() { System.out.print("B constructor "); } } public class Test { public static void main(String[] args) { new B(); } }结论是：A static B static A block A constructor B block B constructor。这里有两个关键机制：静态块在类加载阶段执行，且父类先于子类；实例块在构造函数体之前执行，且父类构造函数先于子类构造函数。如果你对这个顺序没感觉，说明JVM的类生命周期理解还停留在背概念阶段。
多态的考察点则集中在重写与重载的区别、动态绑定、向下转型上的ClassCastException。最常见的坑是：父类引用指向子类对象时，能调用的方法集合以父类为准，实际执行的方法是子类重写后的版本；但属性没有多态性，访问属性时看的是引用类型，不是实际对象类型。
2.3 equals还是==：字符串比较题里的经典陷阱
字符串比较是Java笔试几乎必出的一道题，也是最容易踩坑的题。先看这个：
String a = new String("abc"); String b = "abc"; String c = "abc"; System.out.println(a == b); // false System.out.println(a.equals(b)); // true System.out.println(b == c); // true==对引用类型来说比较的是内存地址，equals在String类中被重写为比较内容。b和c都指向字符串常量池中的同一个对象，所以b == c为true；而new String("abc")在堆里新建了一个对象，和常量池中的"abc"地址不同，所以a == b为false。
如果你再深入一点，还会遇到intern()方法的题：调用a.intern()后，返回的是常量池里那个"abc"引用，所以a.intern() == b是true。这类题在项目里最现实的意义就是：比较字符串永远用equals，不要用==；同时要明白字符串常量池存在的意义是节省内存，但过度intern反而可能带来性能问题。
2.4 枚举类型：比常量更安全的写法
热词里专门有“java枚举类型的使用”，说明这道题出现概率不低。枚举在笔试中常考的点有三个：枚举本质上是一个类，可以定义字段、构造函数和方法；枚举的构造函数默认是private的；枚举可以用在switch中。
更进阶一点的考点是枚举实现单例。代码长这样：
public enum Singleton { INSTANCE; public void doSomething() { ... } }这种写法相比懒汉式、双重检查锁式，天生就线程安全，而且能防止反射破坏和序列化破坏。笔试如果问“Java中哪种单例写法最安全”，答案就是枚举单例。很多人对枚举的印象还停留在“定义状态常量”，实际上它在框架源码里被大量用来做状态机、策略分发，属于性价比很高的考点。
2.5 Lambda表达式与函数式接口：新语法背后的核心思想
Java 8引入的Lambda表达式是校招笔试现在绕不开的点。笔试常见的考法是：下列哪个接口可以用Lambda表达式实现？答案是只能用于函数式接口，即有且仅有一个抽象方法的接口，通常用@FunctionalInterface注解标记。
@FunctionalInterface interface MyFunction { int apply(int x); } MyFunction f = x -> x * 2;这里有个隐藏考点：Lambda表达式可以捕获局部变量，但被捕获的变量必须是effectively final——也就是说，变量在初始化之后不能再被重新赋值。如果在Lambda里面试图修改这个变量，编译器会直接报错。很多人用Lambda写集合遍历时想顺手改外部计数器，就会踩这个坑。
与Lambda相伴的Stream API也常出现在笔试里：map、filter、collect、forEach这几个方法要熟练。尤其是Collectors.toList()、Collectors.groupingBy()这类归约操作，经常被用来和传统for循环写法做对比。背后的设计思想是“把集合操作声明式化”，让代码更易读、更利于并行处理。
3. 集合与算法基础：写代码题之前，先过这两关
3.1 HashMap：一道题能问出一整章“八股文”
集合框架是Java基础笔试里的重头戏，而HashMap又是集合框架里的绝对C位。热词里虽然没有直接出现HashMap，但“java面试八股文”“java面试题”基本都绕不开它。毫不夸张地说，HashMap一道题可以从数据结构问到并发，再从并发问到源码细节，足够面试官聊二十分钟。
底层结构大家都会背：数组加链表，链表长度超过8且数组长度达到64时转为红黑树。但笔试和面试真正想听的，是你有没有想过“为什么”。比如哈希算法为什么要把key的hashCode高16位异或低16位？因为这样可以让高位的特征也参与数组下标的计算，减少哈希碰撞。为什么数组长度总是2的n次幂？因为(n - 1) & hash等价于hash % n，且位运算比取模更快；当n是2的幂时，n-1的二进制全是1，散列更均匀。
还有一个高频考点：HashMap为什么线程不安全？JDK7里扩容时头插法可能形成循环链表，导致get死循环；JDK8改成了尾插法，循环链表问题解决了，但put时仍可能因为多个线程同时修改导致数据覆盖。这个“JDK7与JDK8差异”几乎出现在每一份Java面试八股文里，笔试简答题也很爱出。
3.2 ArrayList与LinkedList：别再只背“数组vs链表”
ArrayList和LinkedList的对比题，看似简单，实则容易答偏。很多人只知道“ArrayList底层是数组，LinkedList底层是双向链表，所以ArrayList查询快、LinkedList增删快”——这句话大方向没错，但经不起追问。
追问一：LinkedList的“增删快”真的在任何位置都快吗？如果是在中间插入，需要先遍历找到指定位置，时间复杂度还是O(n)；只有头尾插入才真正快。追问二：ArrayList的扩容机制是什么？默认容量10，满后扩容为原来的1.5倍，扩容要复制数组，所以频繁在List头部插入时性能很差。追问三：内存占用上，ArrayList每个元素只要一个引用，LinkedList每个节点要存前后指针和元素引用，内存开销大得多。
笔试可能会出现这样的多选题：“下列哪些说法正确？A. ArrayList是线程安全的。B. ArrayList扩容会复制旧数组。C. LinkedList实现了Deque接口。D. LinkedList增删永远比ArrayList快。”正确答案是B和C。A错，ArrayList线程不安全；D错，因为随机位置的插入操作LinkedList不一定比ArrayList快。
3.3 快速排序与冒泡排序：手写代码的边界决定得分
手写排序算法是校招编程题的常客，热词里“冒泡排序java”和“快速排序java实现”都上了榜，说明这是广大考生真实的需求。我的建议是：冒泡排序和快速排序不仅要会背模板，还要理解每一步为什么这么写。
先看冒泡排序：
public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { boolean swapped = false; for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; swapped = true; } } if (!swapped) { break; } } }外层循环每走一趟，最大的元素就会被“冒泡”到最后面，所以内层循环只需要比较到arr.length - 1 - i的位置。swapped标志位是优化点：如果一趟下来没有发生交换，说明数组已经有序，可以提前结束。
再看快速排序的实现：
public static void quickSort(int[] arr, int left, int right) { if (left >= right) { return; } int pivot = arr[left]; int i = left; int j = right; while (i < j) { while (i < j && arr[j] >= pivot) { j--; } arr[i] = arr[j]; while (i < j && arr[i] <= pivot) { i++; } arr[j] = arr[i]; } arr[i] = pivot; quickSort(arr, left, i - 1); quickSort(arr, i + 1, right); }这里的关键点有三个：基准值选最左边元素时，必须先从右边开始找，否则会覆盖错误的位置；arr[j] >= pivot和arr[i] <= pivot里的等号不能少，否则遇到重复元素会死循环；递归终止条件是left >= right，不是left == right。很多人在纸上写快排看着没问题，一跑就栈溢出或结果错误，原因就是这些边界细节没处理好。
笔试时如果时间紧张，优先保证逻辑正确，再谈优化。写完后一定要用最简单的测试用例在脑子里过一遍，比如{3,1,2}、{1,1,1}，这两个用例能暴露大部分边界问题。
3.4 数组越界：那个最容易被忽视的运行时异常
热词里有“java中数组越界异常”，说明这也是踩坑高发区。笔试常见的出题方式，是给一段循环代码让你选“会输出什么”或“哪一行会抛异常”：
int[] arr = {1, 2, 3}; for (int i = 0; i <= arr.length; i++) { System.out.println(arr[i]); }第四轮循环时，i等于3，而arr的有效下标是0到2，于是抛出ArrayIndexOutOfBoundsException。这不是什么高深问题，但它在真实项目里非常常见：比如遍历字符串时s.charAt(i)的边界、二维数组的arr[i][j]行列数搞反、集合遍历时边遍历边删除导致下标错位。笔试考的不是你会不会写i < arr.length，而是你有没有形成“访问任何容器前先确认边界”的肌肉记忆。
再补充一个容易混淆的异常：访问字符串时越界抛的是StringIndexOutOfBoundsException，它是IndexOutOfBoundsException的子类；而数组越界抛的是ArrayIndexOutOfBoundsException。如果多选题问“下列哪些异常是IndexOutOfBoundsException的子类”，这两个都要选上。
4. 并发与JVM：一道OOM题能拉开多大差距
4.1 synchronized、Lock与volatile：并发基础题的核心
并发是Java笔试中区分度最大的一块，因为很多人只在理论层面理解“线程安全”，没有真正处理过并发问题。最常考的是synchronized和ReentrantLock的区别。
常规答案有四点：synchronized是关键字，ReentrantLock是类；synchronized不需要手动释放锁，ReentrantLock需要lock()和unlock()成对出现，通常在finally里释放；ReentrantLock支持公平锁、可中断、可设超时时间、支持多个条件队列；JDK6之后synchronized经过锁升级优化，性能不输ReentrantLock。笔试如果出简答题，按这四点展开就能拿分。
volatile也是一个必考点。它保证可见性和有序性，但不保证原子性。最经典的例子是多个线程同时对volatile int count执行count++，最终结果依然可能小于预期，因为count++是读改写三步操作，volatile无法锁住这个复合操作。很多人把volatile理解成“万能并发钥匙”，这是大忌。
4.2 JVM内存区域与OutOfMemoryError的排查思路
热词里有一条“java: outofmemoryerror: insufficient memory”，这个报错在真实开发里很常见，笔试中对应的就是JVM内存模型题。先背清楚 JVM 内存区域：程序计数器、虚拟机栈、本地方法栈、堆、方法区（JDK8之后是元空间）。
各区域对应哪些异常，常考两点：堆内存不够抛OutOfMemoryError: Java heap space；栈深度不够抛StackOverflowError（注意它是Error不是Exception）。笔试中模拟堆溢出的代码通常是这样的：
List<byte[]> list = new ArrayList<>(); while (true) { list.add(new byte[1024 * 1024]); }如果你在准备面试，比笔试更进一步的是要知道怎么排查：先用jps找到Java进程号，再用jmap -heap <pid>看堆内存使用情况，用jstack <pid>看线程状态，用jstat -gcutil <pid>看GC频率。这些命令不需要背得很细，但至少要知道名字和作用。
4.3 垃圾回收与类加载：深入一点就能超过大多数人
垃圾回收的笔试考点集中在：如何判断对象可回收、GC Roots有哪些、常见收集器的特点。判断可回收的核心是“可达性分析”，从GC Roots出发，能遍历到的对象就是活的，遍历不到的就标记为可回收。GC Roots包括：虚拟机栈中引用的对象、方法区中静态属性引用的对象、常量引用的对象、JNI引用的对象等。
类加载器部分，必考双亲委派模型：类加载器收到加载请求后，先委派给父加载器加载，父加载器加载不了才由子加载器自己加载。这样做的核心目的是保证类的一致性，避免核心类库被自定义类覆盖。笔试常考“为什么要双亲委派”，回答“防止内存中出现多份相同的类、保证核心类安全”就可以。
4.4 编译版本与环境问题：很多人挂在笔试环境题上
热词里有一条非常现实的报错：“java: 警告: 源发行版 17 需要目标发行版 17”。这是典型的环境配置问题：本机装了JDK 17，但项目的编译目标版本还停留在旧版本，或者IDE的Java Compiler版本和Project SDK不一致。
出现这种情况时，解决思路是：在IDE里把Project Structure中的Project SDK和Language Level统一，Maven项目则检查pom.xml中maven-compiler-plugin的source和target，最好直接用<release>17</release>或Java 17的<java.version>属性。还有一个更隐蔽的坑：多个JDK并存时，JAVA_HOME指向的JDK版本和IDE里配置的JDK版本不是同一个，导致命令行编译正常、IDE编译报错。这类问题虽然不是笔试的知识点，但很多公司的机考环节会让你现场配置环境，环境跑不通，后面再多知识也白搭。
5. Spring Boot与工程化考题：笔试里暗藏的实战能力测试
5.1 Spring IoC与AOP：理解框架而不只是背注解
Java开发笔试不可能只有纯Java语法题，只要岗位描述里写了“熟悉Spring Boot”，试卷里就会渗透Spring相关的简答题。最基础的是IoC和AOP。IoC，控制反转，核心思想是把对象的创建和依赖关系的管理交给容器，而不是在代码里手动new。这种设计理念的好处是解耦，改一个依赖实现类的时候不需要改业务代码。
AOP，面向切面编程，适合处理日志、事务、权限校验这类横切逻辑。笔试常考点是：AOP中@Before、@After、@Around的执行顺序，以及它们对方法返回值的影响。如果你能说出@Around需要在内部手动调用proceed()才能继续执行目标方法，并可以修改返回值，就已经超过很多人了。
5.2 Bean生命周期与自动配置原理
Spring IoC里的Bean生命周期也是一个高频题。比较重要的几个阶段：实例化、属性填充、初始化（包括@PostConstruct、InitializingBean、init-method）、使用、销毁。一个容易出错的地方是：如果@PostConstruct和InitializingBean同时存在，先后顺序是先执行@PostConstruct，再执行afterPropertiesSet()，最后执行init-method。笔试多选题喜欢考这种执行顺序。
自动配置原理也是Spring Boot的招牌题。核心是@EnableAutoConfiguration注解，通过META-INF/spring.factories或AutoConfiguration.imports文件加载所有自动配置类，再通过@ConditionalOnClass、@ConditionalOnMissingBean等条件注解决定是否生效。这样做的直接好处是：你只需要引入spring-boot-starter-web依赖，项目就能自动配置好内嵌Tomcat和DispatcherServlet。
5.3 API对接安全：从Spring Boot API Key到接口签名设计
热词里有一条“java springboot apikey 安全对接”，这在真实项目里非常现实。笔试的简答题喜欢问“如果让你设计一个对外接口的鉴权方案，你会怎么做”。比较完整的回答包含四层：
- API Key：每个接入方一个唯一Key，用来标识身份；
- 签名机制：请求参数加上timestamp、nonce、appKey，服务端用约定好的secret算出sign，防止参数被篡改；
- 防重放：用timestamp判断请求是否在有效窗口内，用nonce或业务流水号做幂等；
- 加密传输：涉及到敏感数据时，用HTTPS加必要的对称加密/非对称加密。
这套思路在任何业务系统里都通用，笔试答出来会让面试官觉得你有真实项目意识，而不只是会写CRUD。
如果你连一个简单的Spring Boot接口怎么写都不熟，笔试里的“工程化”题基本就悬了。至少要做到：知道@RestController、@RequestMapping、@RequestBody、@Validated这几个核心注解各自的作用，知道如何通过拦截器或过滤器做统一鉴权，知道用@ControllerAdvice做全局异常处理。
5.4 环境变量与接口自动化测试：两张容易忽略的“小考卷”
除了框架题，笔试也经常考察基础的工程环境能力。比如“如何配置JAVA_HOME和PATH”。这个问题的标准流程是：安装JDK后，设置JAVA_HOME指向JDK安装目录，把%JAVA_HOME%\bin追加到PATH，然后在命令行用java -version验证。Windows和Linux的配置方式略有不同，但核心逻辑一样：让系统能找到javac和java可执行文件。
“接口自动化测试框架”也是热词，说明很多人的笔试经验里会遇到这类抽象题。其实框架设计思路很简单：从测试用例管理开始，用TestNG或JUnit组织用例，通过HTTP客户端发送请求，对响应结果做断言，最后把测试报告和CI流水线对接。你要明确的是：自动化测试不是把每个接口写一个main方法，而是把“测试数据、请求逻辑、断言逻辑、报告输出”分层解耦。这种工程化思维，笔试可能不直接考代码，但简答题里很容易让你写“如何设计一个接口自动化测试框架”。
6. 三个月冲刺计划：从基础薄弱到笔试稳过的实操路线
6.1 先做一轮“摸底考”，别急着看八股文
很多人准备笔试的第一件事是去背“java面试八股文”，这是本末倒置。你先做一套历年真题，限定时间，做完之后把错题按知识点归类：是基础语法丢分多，还是并发JVM丢分多，还是算法题写不完？这个环节决定了你接下来两个月的精力分配。
如果基础题正确率低于80%，别急着刷LeetCode，先把Java基础、集合、异常处理这些最核心的概念过一遍。如果基础题还行但算法题写得慢，说明代码熟练度不够，需要加大手写代码的密度。摸底考的意义不是打击自信心，而是让你把有限时间花在短板而不是舒适区。
6.2 分阶段练习：两个月搞定知识体系，一个月搞定手感
我个人推荐的节奏是：第一个月集中补Java基础和面向对象，顺带把集合源码常见的几个类读一遍，ArrayList、HashMap这俩必须吃透。第二个月主攻并发和JVM，再配合算法专项训练：每天一道中等难度的算法题，手写一遍冒泡和快排，把链表的反转、删除倒数第N个节点练熟。第三个月回到项目复盘和框架知识，把Spring IoC、AOP、Spring Boot自动配置、MySQL索引和事务隔离级别都串一遍，然后开始做模拟笔试。
这个阶段最容易掉进的坑是贪多。今天看Redis，明天看消息队列，后天又去刷设计模式，结果每样都只是“听过”。校招笔试覆盖范围再广，也集中在Java基础、集合、并发、JVM、Spring、算法、数据库这几块，先把这些吃透，分布式、微服务那些只有进了面试才会被深入追问。
6.3 八股文要背，但更要会“接话茬”
所谓Java面试八股文，本质上是对常见问题的标准答案归纳。笔试阶段你确实需要背，因为单选题没有让你发挥的余地；但光背不解决问题，因为现在越来越多的笔试题开始反模板化，会给你一段源码或一段报错，让你判断行为，而不是直接问“HashMap和Hashtable的区别”。
我的建议是：每个知识点都尝试“用一句话解释 + 用一个例子验证 + 说一个常见的坑”三层结构。比如ConcurrentHashMap，先背结论：JDK8中是CAS加synchronized，锁粒度是桶；然后想一个例子：多线程put时为什么不会像HashMap那样数据覆盖；最后记住坑：计算size时为什么不能用单纯的count字段。你会发现，经过这三层梳理的知识，不管笔试怎么换角度都很难再被问倒。
6.4 考前一天与笔试现场的时间分配
考前一天的复习重点不是刷难题，而是看错题本和基础概念。把那些“容易混淆的点”再过一遍：equals和==、ArrayList和LinkedList、HashMap和ConcurrentHashMap、synchronized和ReentrantLock、堆和栈。再看几道简单的编程题练手感，保证最基本的代码写得顺。
笔试现场的时间分配也有一套策略。我的个人习惯是：先拿到试卷后，用两分钟快速扫一遍编程题，评估难度。然后按顺序做选择填空，单选多选不用纠结太久，每道题控制在90秒以内，不会就先标一下跳过。做完基础题后，如果编程题有三道，先写最简单那道，拿到基本分；再挑战中等难度；最后有时间再攻最难那道。你要明白，校招笔试的及格线通常不高，稳定的基本分，比追求一道全对的压轴题更划算。
最后再分享一点个人体会。我见过太多人花大量时间背八股文，结果一写代码就漏洞百出。笔试不是终点，它只是把你送到面试官面前的门票。点我达2019届这套Java笔试题之所以值得反复刷，不是因为它难，而是因为它代表了一家互联网公司对Java应届生最朴素的要求：基础扎实、边界清晰、代码能跑。你认真把每一道错题背后的原理弄懂，比盲目刷一千道题都管用。
