企业官网建设流程全解析

如果你在准备Java工程师面试，搜狗2015年的这套工程师笔试题，是值得拿出来重新做一遍的经典样本。别看到“2015年”就下意识觉得过时，Java这门语言的核心语法和面试考察点十几年没大变，集合框架、JVM内存、多线程并发那些问题，放到今天依旧是面试八股文的重灾区。当年这套题能筛出一批基础扎实的候选人，现在重新做，照样能帮你暴露不少知识盲区。

这篇文章我不会把整套卷子的原题逐字贴出来，而是根据当年参加笔试的人留下的回忆和网上流传的题目碎片，把常见题型和考点打散重讲，按“题目长什么样—考点是什么—答案怎么组织—容易踩哪些坑”的顺序带一遍。适合正在准备Java面试、想系统复习基础、或者做技术复盘的人看。你不需要是高手，但最好已经写过一些Java代码，能跟上节奏。

1. 整体认知与题型拆解

1.1 为什么2015年的题到现在还能打

不少人对年份敏感，觉得老题没有参考价值。但搜狗2015年Java工程师笔试题的考察内核，放在今天依然不过时。

原因很简单：Java工程师的笔试，核心从来不是考最新框架，而是考语言底子。2015年前后，Spring Boot刚开始流行，微服务还没完全统治后端，面试官关心的还是你对集合、并发、JVM、IO这些底层知识的理解。而这些东西，直到今天依然是Java岗位面试的必问题。就算你现在用的是JDK 17、Spring Boot 3，HashMap的扩容逻辑、Synchronized的锁升级、类加载的双亲委派，这些底层机制没有变。所以说，这套老题不是“过期真题”，而是一份浓缩的Java基础知识图谱。

我当时刷这套题的最大感受是：很多题目看起来是选择题，其实每个选项都是知识点。比如考“ArrayList和LinkedList的区别”，表面是考集合，实际是考数组和链表的数据结构；考“HashMap是否线程安全”，背后是fail-fast迭代器和并发修改的机制。一个题能展开成一个小时的面试追问，这就是经典题的价值。

1.2 整体题型分布与考察能力模型

按照我收集到的信息，搜狗2015年Java工程师笔试题大致分为三个部分：选择题、简答题和编程题。下面是我整理的题型分布和对应的能力模型：

这个分布很典型：一方面考验知识面的广度，另一方面考验表达和手写代码的熟练度。很多候选人选择题全对，一到手写快排就翻车；或者简答题能把概念背出来，但代码题边界条件处理不好。搜狗这类公司要的是能直接写代码解决问题的人，不是只会背概念的人。

1.3 从题目反推面试官想找什么样的人

通过一套笔试题，其实能反推面试官的筛选逻辑。搜狗2015年这轮笔试，明显在找三类人：第一类是基础扎实、能说清楚原理的人；第二类是代码风格好、边界意识强的人；第三类是遇到问题有排查思路的人。

什么叫“能说清楚原理”？举个例子：选择题里可能问“String为什么是不可变的”。如果只回答“因为它有final修饰”，这只是表面。真正的原理是：String类内部用final char数组存储，类本身被final修饰，并且不提供修改内部状态的方法。更深一层还要知道字符串常量池、String.intern()、以及不可变带来的线程安全和哈希缓存优势。这类追问在简答题和后续面试中都会出现。

所以备考的时候，不要满足于“我会用”，要追问自己“为什么这样设计”。我后面会针对具体知识点展开，告诉你怎么组织答案才能让面试官觉得你“真的懂”。

2. 核心知识点逐题解析

2.1 面向对象与基础语法：最容易被扣分的细节

Java基础部分的题，看似简单，其实到处是坑。比如equals和hashCode的关系，几乎是必考题。搜狗这套题里，我印象很深的一道变形题：重写equals但不重写hashCode，在HashSet中会发生什么？

答案是：同一个对象的两个实例，equals返回true，但hashCode不同，导致它们在HashSet的不同哈希桶里，Set里会出现两个“相等”的对象。这违反了HashSet的语义，也暴露了对hashCode约定理解不透。面试官接着会问：为什么HashMap用hashCode先定位桶，再通过equals比较链表里的元素？因为哈希表的设计目标是把查找时间降到O(1)，hashCode负责快速定位，equals负责精确确认。

还有一个高频点是String和new String的区别。你要能说出：直接赋值会复用字符串常量池中的对象，new String会创建一个新对象；但更关键的是要能画出内存图，解释常量池和堆的区别。再往深了说，字符串拼接时，编译器会怎么做？如果循环里用+拼接，JDK 9之后会有invokedynamic优化，但这个知识点当年很多面试官自己都不一定清楚，你能说出来就是加分项。

除了这两个点，面向对象部分还喜欢考重载和重写的区别、抽象类和接口的区别、static方法能不能被重写。其中static方法不能重写，只能隐藏，这个细节很多人会答错。再加上标识符命名规则的题目，比如哪些字符能作为Java标识符开头、下划线能不能单独用等，都是选择题的常客。反正基础语法部分，就是靠平时的积累和细心程度。

2.2 集合框架与源码级别考察

集合是Java笔试的重头戏，HashMap更是“八股之王”。2015年的题可能比现在简单，但底层原理差不多。要答好这类题，至少需要掌握这几个层次：

第一层是使用层面：HashMap允许null键和null值，TreeMap不允许null键但允许null值，Hashtable不允许null。第二层是原理层面：HashMap默认容量16，负载因子0.75，当size超过capacity * loadFactor时扩容为原来的2倍。第三层是JDK 8以后的优化：链表长度超过8且数组长度超过64时转为红黑树，为什么阈值是8？因为泊松分布下，负载因子0.75时链表长度到8的概率已经极低。这部分如果能在答题时顺带提一句，会显得很有深度。

ArrayList和LinkedList的区别也是常客。最稳妥的答法不是“ArrayList查询快，LinkedList增删快”，而是要从数据结构讲：ArrayList底层是动态数组，支持随机访问，但中间插入和删除会移动元素；LinkedList底层是双向链表，插入删除只需调整指针，但随机访问需要遍历。同时要指出，在实际应用中，LinkedList的“增删快”并不绝对，因为要额外维护节点对象和前后指针，内存开销更大，而且随机访问性能差，所以在多数场景下ArrayList反而是更好的选择。

fail-fast机制也需要掌握。当使用迭代器遍历集合时，如果其他线程并发修改了集合结构，会抛出ConcurrentModificationException。原理是迭代器内部维护modCount，每次next()都会检查modCount是否变化。如果你在答题时提到“这不是fail-safe，是fail-fast”，并且能对比CopyOnWriteArrayList这类弱一致容器，面试官就会认为你对并发集合有自己的理解。

另外，面试题里还经常出现“数组与集合的转换”。比如Arrays.asList()返回的List不支持add和remove，因为底层还是数组，如果调用add会抛UnsupportedOperationException。这个坑很经典，很多好几年经验的工程师也会在上面翻车。所以复习集合时，不要只盯HashMap，也要把这些细节过一遍。

2.3 多线程与并发：从synchronized到volatile

并发题的考察点基本围绕“可见性、原子性、有序性”。面试官喜欢连环问：volatile能保证什么？不能保证什么？为什么不能保证原子性？我建议你把volatile的答案整理成三点：保证可见性、保证有序性（禁止指令重排）、不保证原子性。接着配合一个经典案例，比如两个线程对volatile变量i执行i++，最终结果可能小于20000，因为i++不是原子操作，包含读-改-写三步。

synchronized的考察也在升级。2015年可能还停留在“对象锁和类锁”的区别，但现在面试官更愿意问锁升级的过程。你可以答：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁。JDK 6之后对synchronized做了大量优化，不再是一上来就阻塞。如果笔试里出现“手写一个线程安全的单例”，最标准的答案是双重检查锁加volatile，volatile在这里的作用是防止指令重排导致返回半初始化的对象。这个点几乎每年都会刷掉一批人。

线程池也是热门。简答题可能会问：创建线程池有哪些方式？为什么不推荐用Executors？你要能回答：推荐通过ThreadPoolExecutor手动配置核心线程数、最大线程数、阻塞队列、拒绝策略和线程工厂，因为Executors的FixedThreadPool用的无界队列可能导致内存堆积，SingleThreadExecutor和CachedThreadPool也有各自的问题。如果编程题需要用到多线程，这些参数必须写明白，否则代码一跑就可能OOM。

这块还有一个容易被忽略的知识点：ThreadLocal。它的作用是线程隔离，每个线程可以拥有自己的变量副本。但使用不当会造成内存泄漏，因为ThreadLocalMap的key是弱引用，value是强引用，如果线程长期存活，value可能一直被引用，无法回收。笔试里可能会用它来考内存泄漏场景，你要能说清楚什么时候需要remove。

2.4 JVM与内存管理：OutOfMemoryError的几种场景

Java面试题里，JVM永远不会缺席，搜狗这套题也不例外。选择题喜欢考“Java内存区域分哪几块”，简答题喜欢问“哪些情况会触发Full GC”，而编程题则可能在在线判题时让你解决内存问题。

你要能口述清楚：堆、虚拟机栈、本地方法栈、方法区、程序计数器。特别要分清哪些区域线程共享、哪些线程私有。堆和方法区是共享的，栈和程序计数器是私有的。然后要能说出OutOfMemoryError的常见场景：堆内存不足（对象过多且无法回收）、栈溢出（递归太深）、元空间不足（加载类过多）。结合很多人遇到过的“java: outofmemoryerror: insufficient memory”，这种报错在在线笔试环境里很常见，后面我会专门讲排查方法。

GC方面，至少要能回答：怎么判断对象已死？答案是引用计数法和可达性分析，但主流通用JVM用的是可达性分析，从GC Roots出发遍历。GC Roots包括虚拟机栈中引用的对象、静态属性引用的对象、常量引用的对象、JNI引用的对象等。然后能解释年轻代和老年代的存活对象转移，以及常见的垃圾回收器，比如CMS、G1。如果笔试里让你设计一个高并发系统，你会怎么解决OOM问题？基础答法是调大堆内存，但更好的答法是：先分析是内存泄漏还是内存溢出，用jmap、jstat等工具查看堆转储，再定位到具体代码。

JVM这块，我见过很多候选人只背概念，问“什么情况会StackOverflow”答不上来。StackOverflow通常是因为方法递归调用太深，比如没有正确设置递归结束条件。而OutOfMemoryError里的insufficient memory，除了堆内存不够，可能是指Native内存不足，这在NIO和DirectBuffer场景下容易出现。答出这个区别，能体现你的实战经验。

3. 编程题实战：算法与代码实现

3.1 手写冒泡排序和快速排序：从能跑到能优化

搜狗2015年的编程题，排序算是必备题型。我猜很多人一看到“请手写快速排序”就紧张，其实面试官不是考你会不会背，而是看你能不能写出一个边界正确的版本。

先看冒泡排序，最基础版本：

public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } }

能写出这个只是及格。进一步优化是加一个flag，如果某一轮没有发生交换，说明数组已经有序，直接结束。复杂度方面要说清楚最好情况O(n)，最坏情况O(n^2)。

快速排序则更考验思维。经典写法是选一个基准，左右指针交替移动，最终把基准放到正确位置后递归排序左右两边。

public static void quickSort(int[] arr, int left, int right) { if (left >= right) return; int pivot = partition(arr, left, right); quickSort(arr, left, pivot - 1); quickSort(arr, pivot + 1, right); } private static int partition(int[] arr, int left, int right) { int pivot = arr[right]; int i = left; for (int j = left; j < right; j++) { if (arr[j] <= pivot) { swap(arr, i, j); i++; } } swap(arr, i, right); return i; }

写快速排序时，最容易踩的坑是递归结束条件遗漏、相等元素处理不当、以及基准选择导致最坏O(n^2)。这些都是面试官追问的点。如果能补充一句“可以用三数取中或随机基准来避免最坏情况”，就已经超过大多数人了。

3.2 链表反转与数组去重：考察代码基本功

除了排序，链表操作也是经典编程题。手写单链表反转，最常用的迭代法要记住三要素：pre、curr、next。

public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode curr = head; while (curr != null) { ListNode next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; }

这段代码很简短，但能一次写对的人不多。常见错误是丢掉next引用导致断链，或者在循环里没有更新prev和curr。建议在笔试时先画一下链表指向变化，再动笔。

数组去重这道题，不同环境有不同的最优解。如果是在笔试卷子上手写，可以用Set去重，简单直观；但如果在线笔试要求不借助额外空间，就要用双指针或排序后去重。排序后去重的思路：数组有序后，重复元素会相邻，维护一个慢指针，把不重复的元素放到前面。这是很典型的“原地去重”，考的是对数组操作的理解。

除此之外，编程题还经常考字符串处理，比如反转字符串、判断回文、统计字符频率。这些题都没有太高深的算法，但特别看边界处理。比如反转字符串时，空串和null要先处理；判断回文时，要不要忽略大小写和空格，题目没说明的时候可以主动询问，或者按最常见的情况处理。

3.3 用lambda和Comparator优化解算法题

部分同学可能不知道，搜狗2015年那会儿Java 8已经发布，笔试题里偶尔会要求用新特性解题。比如按字符串长度排序，传统写法是匿名内部类：

Collections.sort(list, new Comparator<String>() { @Override public int compare(String a, String b) { return Integer.compare(a.length(), b.length()); } });

如果试卷允许Java 8，可以简化为：

list.sort(Comparator.comparingInt(String::length));

这种写法更简洁，但要注意：方法引用和lambda虽然好用，如果对语法不熟，反而容易出错。我看到过很多人在笔试里写lambda，结果连变量捕获的限制都不清楚，导致编译不过。所以建议平时多练，至少在本地能跑通。另外，如果题目要求稳定排序，要注意Comparator的返回值不要溢出，比如直接返回a - b在某些场景下会溢出，最好用Integer.compare。

lambda本质上还是匿名内部类的语法糖，但底层用的是invokedynamic，和匿名内部类生成的.class文件并不一样。这个细节面试官如果问到，你可以说：Java 8的lambda通过invokedynamic指令实现，避免了为每个lambda生成一个匿名类，从而减少了类加载和内存占用。能答到这一层，说明你不只是会用。

3.4 代码风格与边界条件：让面试官多给一分

编程题不只是对错问题，还有印象分。我参与过不少简历筛选和笔试阅卷，发现代码风格好的答案，哪怕小错也能得到机会；而风格差的代码，即使能跑，面试官也懒得看。几个关键点：

第一，变量命名有意义。用pivot而不是p，用current而不是cur，都能提升可读性。第二，边界条件优先处理。比如数组为空、长度为0、只有一个元素、左右指针相等，这些在函数开头就写好，能大幅减少Bug。第三，注释写关键行。别写“// 排序”，要写“// 挖坑填数，把小于基准的值放在左侧”。第四，如果时间允许，在代码末尾补一个简单测试用例说明，比如“输入[3,1,2]，输出[1,2,3]”。

另外，输入输出格式要确认好。如果在线笔试要求读取标准输入，尽量用BufferedReader和StringTokenizer，而不是Scanner，因为Scanner性能差，数据量大时可能超时。这一点我在下一章详细说。

4. 环境与工具链避坑：从笔试到机试的实战经验

4.1 本地Java环境配置：JDK与JAVA_HOME

准备笔试的第一步，是确保本地环境不拖后腿。很多同学在机试前才发现IDE跑不起来，或者编译报错，白白浪费宝贵的答题时间。这里我把最常见的环境配置问题讲一遍。

先装JDK，然后配置JAVA_HOME和PATH。如果你用的是Windows，环境变量里新建JAVA_HOME，值指向JDK安装目录，比如C:\Program Files\Java\jdk-17；然后在PATH里加上%JAVA_HOME%\bin。Linux/Mac则通常通过.bashrc或.zshrc导入，也可以直接用包管理器安装后把export加进去。配置完，在命令行执行java -version验证。

这里有个容易踩的坑：电脑上装了好几个JDK版本，或者安装了多个JRE，导致java和javac版本不一致。很多“源发行版 17 需要目标发行版 17”的报错，就是因为项目编译级别和当前JDK版本不一致。解决办法是统一IDE里的Project SDK、Module SDK和Java Compiler版本，或者直接用Maven/gradle配置编译器版本属性。如果用的是IDEA，在Settings -> Build Tools -> Maven -> Runner里把JRE设为项目JDK。

4.2 IDE与编译期报错：vscode乱码、lombok与source/target版本

在线笔试里，经常给一个简化版IDE或者让你用VSCode写代码。VSCode运行Java报错乱码，通常有两个原因：控制台编码和文件编码不一致。解决办法是把VSCode的Terminal编码和file.encoding都设置为UTF-8，或者运行时加上-Dfile.encoding=UTF-8参数。

另一个高频报错是lombok相关：“You aren't using a compiler supported by lombok, so lombok will not work”。这通常是因为Lombok版本和你当前JDK版本不兼容，或者IDE里的注解处理器没有开启。解决办法优先级：升级lombok版本到较新版本，保证兼容；检查Maven/Gradle依赖；确保IDE安装了Lombok插件并启用Annotation Processing。如果你在机试中遇到这种报错，最简单的方法是去掉lombok，手写getter/setter，别让环境问题影响解题。

编译选项的“源发行版 17 需要目标发行版 17”也是高频问题。本质上是指源码编译级别和目标class文件版本不一致。在Maven里，可以用maven.compiler.source和maven.compiler.target指定版本；在纯命令行下，用javac -source 17 -target 17。但注意，从JDK 9开始，-source和-target不再支持小于当前版本的旧值，具体看JDK版本支持范围。

这些报错看着心烦，但本质上都是版本和编码问题。平时多熟悉一下自己的IDE，别在笔试时才发现不会切换JDK版本。我用过的组合是JDK 8和JDK 17并存，通过IDEA的Project Structure切换，比反复改环境变量省心得多。

4.3 在线笔试的内存限制与Scanner性能

在线笔试平台通常会限制堆内存，可能是64MB、128MB或256MB。如果你的代码用了大数组、集合或缓存，很容易遇到“java.lang.OutOfMemoryError: Java heap space”或类似报错。这时先别急着调JVM参数，要检查代码里是否有不必要的对象引用。

举个例子，如果题目要处理100万条数据，你却用了String.split()，会创建大量中间字符串对象，内存一下子见顶。更稳的做法是直接用BufferedReader逐行读取，用indexOf或substring按需提取。如果确认是JDK默认堆太小，可以在代码里手动设置JVM参数，但很多在线笔试平台不允许Java程序自己修改Runtime参数，所以还是要在代码层面优化。

Scanner性能问题在数据量大的时候尤其明显。Scanner的hasNext/nextInt是同步且基于正则的，性能很差。推荐用：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int n = Integer.parseInt(st.nextToken());

这种写法比Scanner快一个数量级，在ACM风格题目中很实用。手写代码题时，如果时间有限，也可以用Scanner快速实现，但要知道性能瓶颈在哪，面试官问起来能答上来。

另外，数组越界也是一个高频运行时错误。在在线笔试中，如果代码抛了ArrayIndexOutOfBoundsException，平台不会告诉你是哪一行，只会显示异常类型，非常难受。所以写循环时一定要仔细检查边界条件，比如for (int i = 0; i <= arr.length; i++)这种经典错误，千万别犯。

5. 面试八股文之外：复习策略与搜狗场景扩展

5.1 系统复习Java基础：从学习路线到每日计划

如果你正在准备面试，我建议不要直接刷题，先花一周时间把Java基础系统地过一遍。可以参考这样的学习路线：

• 第一阶段：Java基础语法，包括数据类型、运算符与表达式、流程控制、数组、方法、标识符命名规则、枚举类型的使用。
• 第二阶段：面向对象深入，包括类与对象、封装继承多态、接口与抽象类、内部类、Object类方法重写。
• 第三阶段：常用类与集合，包括String、StringBuffer、Date、集合框架的源码阅读。
• 第四阶段：IO与多线程，包括InputStream/OutputStream、线程创建、线程池、锁与并发工具。
• 第五阶段：JVM基础，包括内存区域、类加载、GC、常用调优工具。

每个阶段都要配合手写代码和面试题。比如学集合时，就自己实现一个简易HashMap；学多线程时，就写一个生产者消费者模型。只看不写，刷了十套题也容易忘。我自己的经验是，每学一个模块，就用一张A4纸画脑图，然后再把脑图默写出来，能默写出来的才是真正掌握的内容。

5.2 八股文之外：怎样把基础概念讲活

很多候选人面试时背八股文，一听到“HashMap的负载因子”就能流利回答，但面试官问“为什么是0.75而不是0.5或1.0”就卡住了。其实正确答案没有标准数字那么死板，关键是理解权衡：负载因子越小，冲突越少，但空间浪费越多；负载因子越大，空间利用率高，但冲突增加，查询变慢。0.75是时间与空间的一个折中。

同样，回答“Java是值传递还是引用传递”这类题，不要说“基本类型是值传递，对象是引用传递”，因为严格来说，Java只有值传递，对象引用本身也是按值传递。你可以在纸上画一个方法调用图，说明方法栈和堆的关系。这种细微差别，才是面试官想听的深度。

平时复习可以多问自己几个“如果是我设计，我会怎么做”。比如“为什么ArrayList要动态扩容为1.5倍而不是2倍？”答案是：基于位运算和内存效率的考虑，但更重要的是体现你思考过这个设计。这类问题没有标准答案，但能展示你的工程判断力。

还有一个技巧是给自己出题。某个知识点复习完，想象自己是面试官，会怎么从各个角度追问。比如复习了HashMap，就设计一连串问题：为什么用红黑树？红黑树和AVL树的区别？为什么阈值是8？扩容时怎么迁移数据？这些问题想不出来，就是知识盲区，马上翻书补上。

5.3 结合搜狗业务场景思考技术栈

搜狗的业务特点是什么？搜索、输入法、AI应用，这些场景对Java工程师的要求不仅仅是后端CRUD，还涉及大量的文本处理、检索排序、海量数据和高并发接口。所以笔试和面试里，会偏向考察算法功底和性能意识。

如果你拿到搜狗这类公司的面试机会，建议在准备时额外看一些搜索和推荐相关的知识。不是要你精通算法，而是要知道：搜索引擎里documents怎么存储、倒排索引是什么、为什么查询要拆词、输入法里的候选词排序和高频词缓存怎么做。这些业务场景能帮你在回答“为什么HashMap比TreeMap更适合做缓存”时，给出更有说服力的案例。

比如，面试官问“如何设计一个热点词排行榜”，你可以先说用HashMap统计词频，再想到用堆/优先队列维护TopK，最后考虑容量上限、并发更新和持久化。这个思路链条，其实和2015年笔试题里关于集合和并发的内容完全能串联起来。这就是老题新用的价值。

另外，搜狗这类公司对JVM调优也有一定要求，因为搜索引擎后端要处理海量请求，暂停时间（STW）过长会影响用户体验。你可以提前了解一下G1和ZGC的区别，以及什么时候适合用Serial GC。这些虽然不一定会出现在笔试题里，但在面试聊项目时会很加分。

5.4 面试现场答题节奏与心态管理

最后聊聊临场经验。笔试开始前，先花2分钟把题目全部浏览一遍，判断哪些题是送分题、哪些题需要思考、哪些题会占用大量时间。我的策略是：选择题快速过，拿不准的先标记；简答题每道控制在10分钟内，先写关键词，再逐步扩展；编程题至少留出40分钟。

编程题如果写不出来，先写暴力解法，拿到一半分，再考虑优化。不要一上来就想最优解，结果卡了20分钟，最后连暴力解都没交。另外，如果笔试平台支持本地IDE，建议先在本地跑通示例，再复制到网页上，避免网页编辑器自动格式化导致的语法问题。

我当年就因为太纠结一道JVM简答题，导致最后一道编程题没写完。事后看，那道编程题其实不难，暴力遍历也能拿到不错的分数。所以笔试不仅是考技术，也是考时间分配。不要追求每一题都完美，先保证总分最大化。

还有一点，心态上不要把笔试当成“一锤定音”。很多公司笔试之后还有面试，笔试更多是给你一个展示自己的机会。就算某道题完全不会，也可以把思路写上去，比如“我知道这里可以用动态规划，但状态转移方程还没想清楚”，这比留白要好得多。

关于搜狗2015年Java工程师笔试题，我想分享的基本就是这些。刷题不是目的，通过刷题把Java基础打扎实才是正经事。如果你正在准备面试，建议把上面提到的知识点都手写一遍，尤其是HashMap、volatile、快排、单例这些高频考点，写到肌肉记忆的程度。等你面试时就会发现，很多问题其实都是同一套底层逻辑，只是换了个问法。希望这些东西能帮到你，祝笔试顺利。