Java力扣刷题最容易上手笔记：环境、基础题与避坑指南

作为一个用Java刷力扣刷了两年、还带过身边不少同学入门的普通后端开发，我一直想整理一份不带劝退色彩、可以直接照抄的刷题笔记。这个项目的标题很直白：力扣刷题笔记最容易上手版持续更新中（Java）。说白了，它解决的不是“算法有多深奥”，而是“今天到底该刷哪题、看完答案后怎么才能不忘记、下次面试前怎么快速复习”这三个最现实的问题。

如果你刚刚学完Java基础，准备开始碰力扣，但打开网站看到几千道题不知道从哪里下手；或者已经零零散散刷过几十题，却在面试时连上一次写过的解法都复述不出来——那这篇笔记就是按你的痛点来整理的。它不追求题量，也不堆砌高深理论，而是把高频考点、Java基础语法、解题套路和代码模板放在一起，按人能学会的节奏持续补充。这个系列默认你至少有Java基础，懂数组、字符串、HashMap、for循环和if条件判断。接下来的内容会从环境准备讲起，然后说刷题顺序规划、经典题目逐行讲解、容易踩的Java坑，以及最后怎么维护一份能持续更新的个人题解仓库。

1. 这套Java刷题笔记到底在解决什么问题

1.1 为什么我决定写“最容易上手版”

很多人在刷题入门时最大的问题不是智商，而是“启动姿势不对”。我第一次刷力扣时，也是从题库第一页开始，按题号往下做。前面几道简单题还能撑住，到了第10题左右直接遇到正则表达式匹配，那是动态规划加递归的典型难题，我一个下午都没看懂题解。结果就是连续三天不想打开网站，因为产生了“自己不适合刷题”的错觉。

后来我复盘时意识到，刷题最需要的不是一上来挑战难题，而是建立“我能做出来”的正反馈。最容易上手版的核心理念，就是先把高频基础题按专题拆开，每个专题只用最简单的那几道题，搞定之后再往里加变形和难度。举个例子，字符串专题可以先从“最长公共前缀”入手，它不需要任何数据结构基础，用一个双层循环就能解决。把它彻底搞懂，比刷五道难题更有用。

还有一点，很多刷题笔记默认读者已经熟悉复杂的Java集合类、泛型、流操作，导致新手看代码时一半时间在查语法。我的笔记刻意只用最基础、可读性最强的Java写法。能写for循环就不用stream，能用HashMap get就不用merge链式调用，能用if判断就不用双括号匿名内部类。因为面试时更重要的是把思路讲清楚，代码越直白越不容易出错。

1.2 我假设你具备什么基础、适合谁来抄作业

这套笔记适合的人群很明确：Java基础刚学完、准备在力扣上做笔试面试训练，或者想通过刷题巩固Java基本功的人。你需要掌握以下内容才能顺畅地往下走：变量和类型、if/else分支、for/while循环、数组的基本操作、String常用方法，以及HashMap、List这些常见集合的基本使用。如果这些还不够熟练，也不是不能刷，但你最好先花两周把Java环境配好、每天写几个控制台小程序，把常用语法练到不用查资料再过来。

不适合谁呢？只想背代码、不打算理解原理的人。因为力扣面试题虽然高频原题多，但稍微改个条件就能筛掉只会默写的人。比如最长公共前缀，多问一句“输入为空数组怎么办”“只有一个字符串怎么办”，不会分析边界条件的同学就会露馅。我的笔记会刻意把边界情况和思考路径写出来，而不是只丢一个标准答案。

这里有一个很重要的心态建设：没人规定刷题必须一题接一题从难到易。你可以把力扣当成一个大型题库，按自己的节奏去里面挑题。最容易上手版的意思是，每一道被选进来的题都有明确的学习目标，做完之后你能说清楚自己掌握了那个新的技巧。如果一道题看了题解还是觉得自己在背诵天书，就先跳过去，过两周再回来。持续更新正是为了在这种循环里不断补充新的解法、新的变体和新的复盘记录。

2. 正式刷题前的Java环境与代码习惯准备

2.1 JDK安装与环境变量配置的避坑经验

工欲善其事，必先利其器。很多人不想装Java环境，总觉得力扣网页上直接写代码够用了。但我的建议恰恰相反：如果只是图方便，你永远不会建立自己的调试能力；而不会调试的刷题，效率会低一半。

本地装Java其实不复杂。先去下载JDK 11或JDK 17，别再用JDK 8了，虽然力扣老版本资料大多基于JDK 8，但现在很多公司都在升级，新的语法糖和GC表现都更好。安装之后最重要的一步是配环境变量。网上很多教程喜欢让你配置 JAVA_HOME、PATH、CLASSPATH三个变量，实际刷题过程中CLASSPATH一般不用手动配，JDK 9之后的版本也不推荐依赖CLASSPATH，反而容易踩坑。你只需要新建 JAVA_HOME，指向JDK安装目录；再在 PATH 里加上 %JAVA_HOME%\bin。

配置完环境变量后，打开命令行验证一下：

bash复制java -version
javac -version

如果都能输出版本号，就说明基本OK。如果出现“不是内部或外部命令”，优先检查PATH是否真的把bin目录加进去了，不要只看系统变量和用户变量有没有设错。还有个常见问题：配完之后命令行没刷新，重启一下终端即可。

我个人建议在本地新建一个最简单的Java项目，每个力扣题写成一个类，main方法里自己构造测试用例。这样你就能随时打印中间变量，观察每一步执行结果，而不是在网页上一遍遍提交猜测。比如写一个链表反转题，本地造个链表、跑一遍、打印节点顺序，比盯着代码空想会快很多。

2.2 选择顺手IDE并建立本地调试模板

Java刷题用什么IDE？如果是开发，IntelliJ IDEA是最主流的选择；如果是纯刷题练手，IDEA Community版免费版完全够用。VS Code配Java插件也能用，但调试体验不如IDEA顺手。我的建议是：不要在这个问题上纠结太久，选一个你觉得打开不烦的就行，重点是养成“把题拷到本地，跑起来看结果”的习惯。

本地模板可以做成这样：一个题目一个包或一个类文件，类名尽量和力扣要求保持一致。多数力扣题只需要你填写 Solution 类的某个方法，不需要自己处理输入输出，所以你本地写的时候可以模仿这个结构。比如最长公共前缀这道题，题目要求实现：

java复制class Solution {
    public String longestCommonPrefix(String[] strs) {
        // 待实现
    }
}

本地调试时，我通常会在同一个类里加一个main方法，或者在测试类里new Solution然后调用方法，打印结果。关键的一点是：一定要准备几个特殊测试用例，比如空数组、空字符串、只有一个字符串、所有字符串都相同等。把极端场景覆盖掉，比你跑一百遍正常用例更能锻炼边界意识。力扣的判题系统就是靠这些边界用例来卡人的。

也有同学用LeetCode插件在IDE里直接拉题、提交，省去复制粘贴的功夫。插件确实好用，但我提醒一句：插件提交时报错信息有限，如果调试不通过，还是要把代码复制到本地项目里，用断点或打印来定位问题。调试能力是刷题过程中的隐藏加分项，很多公司面试虽然不考IDE操作，但如果你能口述出打日志、断点观察引用关系的过程，会显得更像一个有经验的工程师而不是只会背答案的人。

2.3 Java刷题基础语法和集合速查

刷题过程中会反复用到几个Java知识点，这里先把容易混淆的整理一遍。

首先是字符串。String是不可变对象，每次用 + 拼接都会产生新对象，在循环里大量拼接时性能很差。比如从字符数组构建字符串，可以改成 StringBuilder。但力扣的简单题数据量通常不大，用 + 也不至于超时，新手不用过度优化。另一个坑是字符串比较：内容相等一定要用 equals()，千万别用 ==。== 比较的是引用地址，新人在这里翻车概率极高。

然后是集合类。HashMap 是刷题中使用频率最高的工具，常用方法有 put、get、containsKey、getOrDefault。很多新手不知道 getOrDefault 能减少空指针判断，比如统计每个字符出现次数时，写成 map.put(c, map.getOrDefault(c, 0) + 1) 就很简洁。但理解原理比背方法更重要，你需要清楚HashMap的键是允许为null的，键需要正确处理 equals 和 hashCode 才能正常工作，好在力扣题里用String、Integer这些内置类型不会出问题。

关于栈和队列，Java官方其实推荐用 Deque 而不是 Stack。因为 Stack 继承自Vector，线程安全带来额外开销，并且它的迭代顺序也不是后进先出。刷括号匹配、单调栈题目时，优先用：

java复制Deque<Integer> stack = new ArrayDeque<>();

ArrayDeque 作为栈时，push() 和 pop() 方法都可以直接用，不会出现多余的NULL提醒，代码和标准栈用法几乎一致。

最后是多维数组和排序。二维数组在Java里本质上是一维数组的数组，用 int[][] matrix = new int[m][n] 创建时，m是行数，n是列数。排序常用 Arrays.sort，如果是二维数组按照某一列排序，可以传入lambda比较器：

java复制Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

但要注意 a[0] - b[0] 在极端值下会溢出，稳妥的写法是 Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]))。力扣上很多同学因为减出负数越界导致答案错，都是这一类小细节。

3. 刷题路线怎么规划：从Hot100建立肌肉记忆

3.1 为什么首推力扣Hot100而不是全题库乱刷

力扣现在的题目数量已经超过3000道，哪怕每天做10道也要做一年多，显然不现实。我见过太多人刷了一个月，题量高达100多，但问到他这周学了什么算法分支，完全说不出来。这就是乱刷的坏处，感觉每天都很忙，实际上没有一个系统性的知识框架。

热题100（力扣Hot100）现在几乎是国内外面试高频入门题库的代名词。它覆盖了数组、字符串、哈希表、链表、二叉树、动态规划、贪心、回溯、堆、图等主流算法方向，每一类都有一定数量的经典题。更重要的是，Hot100里的题目经过了大量面试反馈筛选，很多题在面试中会被直接原题或者小改。当然，这并不意味着所有Hot100都是简单题，但它的难度曲线更适合“先刷简单，再挑medium”的节奏。

我不建议你一上来就把Hot100按顺序从头刷到尾，因为它在不同难度之间跳来跳去。更好的用法是这样的：先把Hot100当成一个“高频题库池”，进入某个专题时，从里面挑选对应题号的题目来练手。这样你的题量和考点都是一一对应的，比漫无目的随缘刷扎实得多。

3.2 按数据结构分组的刷题顺序建议

刷题顺序有一个公认的好节奏：先从“线性结构”开始，再去碰“递归和树”，最后啃“动态规划”。我按自己带人的经验整理了一个推荐顺序，不一定适合所有人，但对Java新手比较友好。

第一个阶段是数组与哈希表。数组是Java里最基础的数据结构，两数之和、三数之和、多数元素、合并区间都属于这个范畴。这一阶段你能学会“暴力解法”和“空间换时间”的思维方式，理解HashMap如何把查找降到O(1)。

第二个阶段是字符串和双指针。字符串的基础操作多，但套路相对固定。除了前面说的“最长公共前缀”，还有无重复字符的最长子串、反转字符串、验证回文串等。双指针这种思想在有序数组和链表里特别重要，比如盛最多水的容器、三数之和都涉及首尾指针。把这些练熟后，你会发现很多题其实就是“一个指针遍历，另一个指针按条件移动”。

第三个阶段是链表。链表的插入、删除、翻转操作，都是指针引用之间的转换。对很多人来说，反转链表、合并两个有序链表、检测环形链表，乍一看是死记硬背，实际上需要画图演算。我刷链表专题时，每次都会在草稿纸上画出prev、cur、next三个引用的变化，等画熟了，代码自然就背下来了。

第四个阶段是二叉树和递归。二叉树是递归思想最好的练习场景。前序、中序、后序遍历、最大深度、翻转二叉树，每道题都在训练你“把一个大问题拆成两个小问题”。树这关过不去，后面动态规划基本也学不会，因为DP的状态转移同样依赖“划分成子问题”的能力。

第五个阶段才是动态规划。动态规划最容易劝退人，所以必须放在后面。初始只需要掌握斐波那契、爬楼梯、打家劫舍这类一维DP，把状态定义和转移方程写出来。如果一上来就啃股票买卖、编辑距离，很容易把自己劝退。

3.3 “看答案-关闭-默写-复盘”四步法

我发现很多人刷题失败不是因为题看不懂，而是因为“看懂答案之后误以为自己会了”。在题解里看懂每一行，和自己在空白编辑器里写出来之间，隔着一条巨大的鸿沟。所以我总结了适合新手的四步刷题法，每次只做一道题也能有效果。

第一步是“原题思考”。拿到题目先给自己10到15分钟，别急着看答案。哪怕最后没有思路，也要记录下卡在哪里，是不知道怎么把题目转化成代码，还是不知道该用哪一种数据结构。这10分钟的思考不会白费，因为之后看题解时你会更容易抓住重点。

第二步是“看答案并且画出流程”。看题解不是浏览，而是把别人的代码在草稿纸上走一遍。比如反转链表题解里有一个不断移动的next引用，你就画出每一步链表的实际状态，直到原始链表开始变化的那一行。

第三步是“关掉全部参考，默写代码”。把题解页面和IDE参考关掉，新建一个空白类，凭记忆和理解把代码敲出来。如果敲不下去或者报错，说明你刚才看懂了表面，没理解本质。这时回去重新看题解，再关掉重写，直到能顺畅写出为止。

第四步是“复盘并约定复习时间”。做完一道题并不代表它属于你了。我会在自己维护的题解仓库里记录题目编号、解法类型和易错点，然后在三天后、一周后分别重做一次。这个步骤最关键，因为长期记忆不是看出来的，而是“在遗忘边缘被重新激活”出来的。

如果你能坚持按这个流程处理Hot100里的基础题，你就会慢慢发现很多题的核心思路是共通的。所谓的题感，其实就是看到题之后能自动匹配已经练过的解题模式。

4. 从零手写经典题目：关键是看懂每一步

4.1 最长公共前缀：一道最适合入门的字符串题

力扣第14题“最长公共前缀”是我逢人就推荐的入门题。它看起来简单，但能把字符串边界、数组遍历和代码严谨性都练到。输入是字符串数组，要求返回所有字符串共同的最长前缀，比如：

java复制输入：strs = ["flower", "flow", "flight"]
输出："fl"

这道题有好几种解法，最容易上手的思路是“纵向扫描”：以数组第一个字符串为基准，逐一取出它的字符，再和剩下所有字符串的同一位置字符比较。只要遇到某个字符串长度到边界，或者字符不相等，就立即返回当前已经匹配的前缀。

代码可以这样写：

java复制class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int count = strs.length;
        int len = strs[0].length();
        for (int j = 0; j < len; j++) {
            char c = strs[0].charAt(j);
            for (int i = 1; i < count; i++) {
                if (j >= strs[i].length() || strs[i].charAt(j) != c) {
                    return strs[0].substring(0, j);
                }
            }
        }
        return strs[0];
    }
}

注意，这里最外层的循环是以第一个字符串的长度为准。假如第一个字符串很长，但第二个字符串很短，到了第二个字符串末尾还没有出现字符不相等，strs[i].charAt(j) 就会越界，所以必须先判断 j >= strs[i].length()。很多面试官喜欢把这种边界情况作为考察点，如果一开始忽略掉，在本地测试时可能正常，一旦提交立刻报错。

除了纵向扫描，还有一种水平扫描法：把第一个字符串先行设为“临时公共前缀”，然后依次和后面的字符串求交集，每次把前缀长度缩小。这种写法更贴近把问题拆成“两两求公共前缀”的直觉，但要注意使用 indexOf 判断是否为前缀：

java复制public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) {
        return "";
    }
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++) {
        while (strs[i].indexOf(prefix) != 0) {
            prefix = prefix.substring(0, prefix.length() - 1);
            if (prefix.isEmpty()) {
                return "";
            }
        }
    }
    return prefix;
}

indexOf(prefix) 返回的是子串出现的位置，如果返回0，说明 prefix 恰好是 strs[i] 的前缀，这是Java里判断前缀的一个常用技巧。substring 不断缩短后缀，等到短到空字符串，就说明没有公共前缀。这种解法的时间复杂度同样是O(n*m)，但在字符频繁“缩短”时会产生很多新的字符串对象，如果测试数据特别长，纵向扫描会更稳一些。对于入门阶段，我更推荐先掌握纵向扫描，因为它没有太多API依赖，思路直接用数组和字符比较就能表达。

4.2 两数之和：HashMap的空间换时间

力扣第1题“两数之和”是Hot100的开篇，也是很多人的第一道算法题。题目要求：在数组中找到两个数，使它们的和等于目标值，返回下标。最暴力的想法是两个for循环穷举每对组合：

java复制for (int i = 0; i < nums.length; i++) {
    for (int j = i + 1; j < nums.length; j++) {
        if (nums[i] + nums[j] == target) {
            return new int[]{i, j};
        }
    }
}

这种写法正确，时间复杂度是O(n^2)。如果数组长度只有几百，能通过；但力扣服务器可能会准备几万长度的数组，一旦超时，你就得想优化办法。

优化的核心思想是：与其在数组里线性寻找配对数字，不如把已经遍历过数字和它的下标存进HashMap。这样当你遍历到 nums[i] 时，只需要查一下 target - nums[i] 是否已经在map里，如果存在，就直接拿到它的下标。因为HashMap的查询是O(1)，总时间变成O(n)，代价是额外用了O(n)的存储空间，这就是典型的“空间换时间”。

这里的实现细节容易出错：为什么要在循环里先查、后放，而不是先把所有元素放进map再查找？如果你先把元素全放进去，遇到 nums = [3, 3]，第二个3会覆盖第一个3的下标，最终可能返回错误结果，或者需要额外处理相同元素的情况。边遍历边查询，就可以保证map里的数字只来自当前元素之前的数组，天然避免“同一个元素被使用两次”的问题。

java复制class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int need = target - nums[i];
            if (map.containsKey(need)) {
                return new int[]{map.get(need), i};
            }
            map.put(nums[i], i);
        }
        return new int[0]; // 根据题目约定不会走到这里
    }
}

这个解法值得反复练习的点不只是HashMap本身，还有“记录遍历过程中的历史信息”这种思维。很多题目都是从暴力遍历优化为使用字典，你以后在做字符串、前缀和、记忆化搜索时都会用上同一套逻辑。

4.3 有效的括号：把栈当成天然配对工具

力扣第20题“有效的括号”仍然是一道高频入门题。给定一个只包含 ()[]{} 的字符串，判断括号是否匹配正确。什么叫正确匹配？不仅左右括号数量相等，还要注意嵌套顺序，比如 ([)] 虽然两种括号数量都没问题，但它是无效的。

这种“最近的左括号必须和最近的右括号配对”的需求，非常自然地让人想到栈。因为栈的特点是后进先出，最后进入的左括号，会最先遇到对应的右括号。看一下这个例子：字符串是 ( [ ] )，遍历到 ( 和 [ 时分别入栈；遍历到 ] 时栈顶是 [，匹配成功，把 [ 弹出；再遍历到 ) 时栈顶是 (，匹配成功。结束之后栈是空的，说明全部括号都成功配对。

用Java实现时，我推荐用 Deque<Character>：

java复制import java.util.ArrayDeque;
import java.util.Deque;

class Solution {
    public boolean isValid(String s) {
        Deque<Character> stack = new ArrayDeque<>();
        for (char c : s.toCharArray()) {
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.pop();
                if (c == ')' && top != '(') {
                    return false;
                }
                if (c == ']' && top != '[') {
                    return false;
                }
                if (c == '}' && top != '{') {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }
}

代码里有三个特别容易踩的点。第一，遇到右括号时栈可能为空，比如输入就是 }，此时没有任何左括号可以匹配，需要直接返回false，否则调用 pop() 会报EmptyStackException或NoSuchElementException。第二，弹出的栈顶元素必须和当前右括号配对，如果用if语句依次判断，一定要检查每种右括号。第三，循环结束后不能直接返回true，因为可能所有字符都遍历完了，但栈里还残留着没有配对的左括号，比如 ((，这时必须返回 stack.isEmpty()。

这道题也有用HashMap存配对关系的写法，但新手阶段用这种直白的if判断更容易理解。等你已经熟练，再多背一种更简短的方案也不迟。

4.4 反转链表：画图理解引用变化的训练场

链表题对刚入门的人一直不太友好，因为你在代码里移动的是“引用”，而不是像数组一样移动下标。力扣第206题“反转链表”是链表专题的必做题，题目要求把一条单链表反转，返回新的头节点。

先说一下基本结构：

java复制public class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

反转链表的迭代思路是：准备两个指针，prev 指向已经反转好的部分的上一个节点，初始是null；cur 指向当前要处理的原链表节点。每一步都做三件事：先保存当前节点的下一个节点，防止修改 cur.next 后丢失后续链表；然后把当前节点的 next 指向 prev，完成一次反转；再让 prev 移动到当前节点，cur 移动到保存好的下一个节点，继续下一轮循环。

java复制class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
}

我见过太多人在写这块时卡死在 cur.next = prev 这里。他们想不清楚：为什么 cur.next 不是指向原来的下一个节点，而是指向前一个？其实反转做的事情就是“把箭头方向掉转”，原来 1->2->3，反转后就是要 3->2->1。当 cur 是1时，它原来的 next 是2，反转后应该指向 null，也就是 prev；等处理到2时，它原来的 next 是3，反转后应该指向1，这时的 prev 恰好是刚才处理完的1。所以循环里的顺序不能换，一旦先修改 cur.next 再取 next = cur.next，就取不到原来后面的节点了。

链表题一定要画图。如果你刚开始接触，强烈建议在纸上画一条四五个节点的链表，然后用箭头模拟prev、cur、next的变化。多画三轮之后，你就能理解为什么反转完之后要返回 prev 而不是 cur：因为循环结束时 cur 已经为null，真正的新头节点就是最后一个被处理的原链表节点，也就是现在的 prev。

5. 刷题过程中最常见的Java坑与排查清单

5.1 整数溢出、数组越界与空指针

刷题新手最常见的编译或运行错误并不是算法思路有问题，而是Java本身的边界坑。先说整数溢出。Java中 int 的取值范围是 -2147483648 到 2147483647，很多题目需要求两数之和、判断是否溢出，或者计算中间值，比如排序取 mid = (left + right) / 2。当 left 和 right 都很大时，left + right 可能溢出，稳妥写法是 mid = left + (right - left) / 2。再比如判断字符串是否超过int范围，就不能用 Integer.parseInt 直接转，而要一边遍历一边判断是否已经超过 Integer.MAX_VALUE / 10。

数组越界通常在循环访问时发生。最容易忽略的是二维数组的行列关系，以及“当前字符串长度可能小于被比较字符串长度”这种情况。每次用到 strs[i].charAt(j)、nums[i + 1] 这种访问，都要习惯性先问自己：i 的上限是什么？i + 1 会不会到最后越界？即使本地调试时数据规模小没触发，力扣的大数据测试也会让你立刻看到红色报错。

空指针在Java里更是家常便饭。操作HashMap前一定要确认 get 的返回值不是null，尤其是使用自动拆箱的时候，比如把一个 Integer 直接赋值给 int，如果它实际是null，会触发NullPointerException。还有递归时没有处理空节点，比如二叉树题直接访问 root.left，必须先判断 root == null。

5.2 List与数组之间的转换细节

LeetCode经常要求返回 List<Integer> 或 int[]，如果题目给的是数组，你需要把答案存进一个动态长度的容器里。新手经常在 Arrays.asList 上翻车。Arrays.asList("a", "b") 返回的列表其实是基于原数组的固定长度视图，它不支持 add 和 remove，调用时会抛 UnsupportedOperationException。如果你想得到一个可以自由增删的ArrayList，应该这样创建：

java复制List<String> list = new ArrayList<>(Arrays.asList("a", "b"));

另一个常见需求是把 List<Integer> 转成 int[]。Java 8之后可以用Stream一行转换：

java复制List<Integer> list = new ArrayList<>();
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

但如果你刚开始刷题，不一定熟悉Stream的细节，完全可以用普通for循环：

java复制int[] arr = new int[list.size()];
for (int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

这样虽然代码多一些，但可读性更好，也不会出现 mapToInt 里的意向不到的错误。

还有一个很隐蔽的问题：Arrays.asList 不支持基本类型数组。如果你有一个 int[]，想通过 Arrays.asList(nums) 转成 List<Integer>，得到的其实是一个长度只有1、元素为 int[] 的列表，完全不是想要的结果。要处理这个问题，可以用Java 8的流式转换：

java复制int[] nums = {1, 2, 3};
List<Integer> list = Arrays.stream(nums).boxed().collect(Collectors.toList());

5.3 字符串比较、StringBuilder和lambda的使用细节

字符串比较必须用 equals，这条至少会坑每个Java刷题新手一次。比如判断两个字符是不是相同时可以用 ==，因为char是基本类型；但判断两个String对象内容是否相同时，用 == 的结果不稳定，因为Java有字符串常量池的优化，有些时候用 == 碰巧返回true，有些时候又是false。最典型的例子是：

java复制String a = new String("ab");
String b = new String("ab");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

刷题时别把希望寄托在常量池上，所有字符串内容比较一律用 equals。

字符串性能问题也要注意。在一个 for 循环里反复执行 result = result + c，每次都会创建新的String对象，效率很低。如果发现代码在大数据量下超时，优先检查是不是字符串拼接问题。替换成：

java复制StringBuilder sb = new StringBuilder();
for (char c : chars) {
    sb.append(c);
}
return sb.toString();

lambda是Java 8之后面试常问，也越来越多地出现在题解里。比如使用 Comparator.comparingInt、mapToInt、Collectors.toList，它们的可读性很强，但对新手来说，如果只看题解照抄，很可能不知道底层函数接口是怎么工作的。我的建议是：把lambda当成一种语法糖来用，但要确保自己能用普通循环写出同样逻辑。排序比较器里有个经典坑：有些人写 (a, b) -> a - b，当a为正数、b为负数时减法结果可能溢出，推荐用 Integer.compare(a, b) 表达式。

5.4 一刷没思路、二刷还是记不住怎么办

这不是方法问题，而是重复次数不够和时间间隔不对的问题。刷题是技能训练，和练琴、健身很像。你看别人弹了一段很流畅的琶音，眼睛看会了，手指依然不会；只有关节反复练习，肌肉才会记住动作。算法也一样，“看懂题解”用的是大脑的阅读理解区，“默写代码”用的才是编程技能区。建议每一道新题至少安排三次提交：第一次是学习后当天默写，第二次是三天后重做，第三次是一周后重做。第三次如果还能独立写出来，这道题才算真正进入你的知识体系。

如果二刷时完全没思路，不要沮丧，这是正常的记忆曲线作用。你需要做的是看一下自己之前写的记录，想想当时的易错点，然后关掉它再写一遍。刷题不是为了当第一遍就记住的天才，而是为了在面试那一刻遇到类似题时能知道往哪个方向想。

还有一个小技巧：分类复习比随机复习有效。假设你本周刷了链表专题，那么周末复习时就不要再去看动态规划的题，而是把反转链表、环形链表、合并两个有序链表这几个问题统一重刷一遍。这样你对同一类套路的印象会更深刻。

6. 如何维护一份能持续更新的个人题解仓库

6.1 题解模板：让每道题都不是孤立的记录

这个项目的标题里有“持续更新中”，说明它不是一锤子买卖。很多人在本地或GitHub上建过刷题记录，但往往坚持不到一个月就烂尾了。烂尾的原因很多，最典型的一个是记录过于重复，每道题都只复制一份代码，没有写出值得回顾的内容。下次再回来看，还要重新读题、重新理解思路，自然就不想打开这个仓库。

我建议一份有价值的题解至少包含以下几个部分：

比如最长公共前缀这道题，你可以这样记录：

标签：字符串
核心思路：纵向扫描，以第一个字符串为基准，逐位比较所有字符串
复杂度：时间复杂度O(n*m)，空间复杂度O(1)
易错点：比较前需要判断是否超出当前字符串长度
相似题目：力扣28题找出字符串中第一个匹配项的下标

这样记录的好处是，你在面试前复习时不用把整张题解截图重新看一遍，只看核心思路和易错点就能快速回忆起解法。记忆需要线索，这些结构化字段就是最好的线索。

6.2 复盘节奏与面试前复习方式

持续更新不只是“每天往仓库里加一个新文件”，更重要的节奏是“定期清理和重构旧内容”。我自己的习惯是每周日做一次周复盘：把这周刷过的所有题过一遍，能秒写的标记为掌握，卡壳的标记为待复习，并把待复习的题目安排到下周一、周三各做一次。

面试前两三周，如果时间紧张，我不建议再去追逐新题。这时候正确策略是：把仓库里所有核心思路和易错点快速扫一遍，然后挑出标记为“高频”“容易忘”的10到20道题，每道题写三遍。三遍都顺利，就可以放心上考场了。对于时间充足的同学，可以每天保持一两道Hot100的medium题，但一定要保证后面的复习窗口，积累新题的同时不要丢掉旧题。

关于题解仓库的形式，我推荐用GitHub私有仓库或者本地Markdown文件都行。形式不重要，重要是能快速搜索。如果你使用GitHub，建议文件名直接叫 001-two-sum.md、014-longest-common-prefix.md，这样想找某道题时用文件排序或搜索都很快。还可以在每一篇题解顶部维护一个“更新时间”字段，提醒自己最近一次复习是什么时候。

另外，持续更新的项目会遇到一个心态挑战：某段时间工作忙、考试多，可能一周都联系不上力扣。这时候不用强迫自己必须连续打卡。只要保证第一次学过的题已经在后续时间被重做过，就不会彻底遗忘。我的做法是：断更没关系，恢复后先花15分钟重做昨天留的“待复习题”，而不是急着开新题。很多热爱刷题的人容易陷入“今天没学新东西就很焦虑”的陷阱，反而导致行动停滞。真正能坚持很久的刷题方式，应该像记账一样轻松，像复盘一样有反馈。

我在实际维护这套笔记的过程中感受最深的，是“持续更新”带来的复利远比想象中强大。一开始我每道题写得很慢，代码逻辑自己都解释不清；后来每次新开一题，都会先翻翻仓库里有没有类似结构的题，回想当时的解题过程。渐渐地，我看到题目不再是“会不会做”，而是会下意识地想：这是数组类的题，可能要用HashMap；这是括号相关，十有八九是栈；这是链表，只改引用不交换值。这种条件反射不是靠熬夜刷题刷出来的，而是靠着一点点记录、复盘和保持节奏磨出来的。如果你也正卡在刷题起步阶段，不用想太多，先按最容易上手的专题选一道能解决的题，跑通代码，留下笔记，明天再打开它重写一遍，属于你的持续更新就算开始了。