【Hot100｜先导篇 Java算法常用API的调用&易错语法点】-优快云博客

以下是 Java 算法题中常用的 API 及易错语法点分类整理，涵盖基础语法、字符串、集合框架、数学运算、数组操作等核心场景，每条均包含说明、注意点及示例代码，总计 100 + 条目。

一、基础语法与数据类型（15 条）

1. 基本类型与包装类转换

API 说明：基本类型（如int）与包装类（如Integer）的自动装箱（int → Integer）和拆箱（Integer → int）。
易错点：包装类为null时拆箱会抛NullPointerException。
示例：

java

运行

Integer a = null;
// int b = a; // 运行时抛NullPointerException（拆箱失败）
int c = a != null ? a : 0; // 安全处理

2. 包装类缓存机制

API 说明：Integer对-128~127范围的值缓存，直接赋值时相同值引用同一对象。
易错点：超出范围时==比较会返回false（需用equals）。
示例：

java

运行

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true（缓存命中）
Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false（超出缓存范围）
System.out.println(m.equals(n)); // true（正确比较）

3. `final`关键字

API 说明：修饰变量时不可重新赋值，修饰方法不可重写，修饰类不可继承。
易错点：final修饰引用类型时，对象内容可修改（仅引用不可变）。
示例：

java

运行

final List<Integer> list = new ArrayList<>();
list.add(1); // 合法（对象内容可改）
// list = new LinkedList<>(); // 编译错误（引用不可改）

4. 三元运算符类型兼容

API 说明：condition ? expr1 : expr2需保证expr1和expr2类型兼容。
易错点：基本类型与包装类混合时可能触发自动拆箱导致 NPE。
示例：

java

运行

Integer a = null;
int b = 1;
// int c = true ? a : b; // 运行时抛NPE（a拆箱失败）
Integer d = true ? a : b; // 合法（b自动装箱为Integer）

5. `++i`与`i++`的区别

API 说明：++i先自增后取值，i++先取值后自增。
易错点：在复杂表达式中易混淆执行顺序。
示例：

java

运行

int i = 3;
int j = i++ * 2; // j=6（先取3*2，再i=4）
int k = ++i * 2; // k=10（i先增为5，再5*2）

6. 方法参数传递

API 说明：基本类型传值（修改不影响原变量），引用类型传引用（修改对象内容影响原对象）。
易错点：误以为引用类型参数赋值会改变原引用。
示例：

java

运行

void modify(int a, List<Integer> list) {
    a = 10; // 不影响外部变量
    list.add(1); // 影响外部list
    list = new ArrayList<>(); // 不影响外部list引用
}

7. `switch-case`语句

API 说明：多分支判断，支持int、char、String（Java 7+）、枚举。
易错点：缺少break会导致穿透执行。
示例：

java

运行

int num = 2;
switch (num) {
    case 1: System.out.println(1);
    case 2: System.out.println(2); // 执行
    case 3: System.out.println(3); // 穿透执行（无break）
    default: System.out.println("default");
}
// 输出：2 3 default

8. 增强 for 循环（foreach）

API 说明：遍历集合或数组，语法for (元素类型变量 : 集合/数组)。
易错点：遍历中修改集合（如add/remove）会抛ConcurrentModificationException。
示例：

java

运行

List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
// 错误：遍历中删除元素
for (int num : list) {
    if (num == 2) list.remove(num); // 抛ConcurrentModificationException
}
// 正确：用迭代器
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    if (it.next() == 2) it.remove(); // 安全删除
}

9. 数组长度与集合大小

API 说明：数组用length属性（无括号），集合用size()方法（有括号）。
易错点：混淆length和size()导致编译错误。
示例：

java

运行

int[] arr = new int[5];
System.out.println(arr.length); // 正确（数组用length）

List<Integer> list = new ArrayList<>();
System.out.println(list.size()); // 正确（集合用size()）
// System.out.println(list.length); // 编译错误

10. 浮点数精度问题

API 说明：float和double存在精度误差，不适合精确计算。
易错点：直接比较浮点数是否相等。
示例：

java

运行

double a = 0.1 + 0.2;
double b = 0.3;
System.out.println(a == b); // false（精度误差）
// 正确：用BigDecimal
BigDecimal a2 = new BigDecimal("0.1").add(new BigDecimal("0.2"));
BigDecimal b2 = new BigDecimal("0.3");
System.out.println(a2.equals(b2)); // true

11. `null`判断

API 说明：对象可能为null，调用方法前需判断。
易错点：忽略null判断导致NullPointerException。
示例：

java

运行

String s = null;
// s.length(); // 抛NPE
int len = s != null ? s.length() : 0; // 安全处理

12. 字符串常量池

API 说明：String s = "abc"会存入常量池，new String("abc")创建新对象。
易错点：用==比较字符串内容（应使用equals）。
示例：

java

运行

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1 == s2); // true（同常量池对象）
System.out.println(s1 == s3); // false（不同对象）
System.out.println(s1.equals(s3)); // true（内容相同）

13. `static`关键字

API 说明：static变量 / 方法属于类，而非实例，可直接通过类名调用。
易错点：静态方法中调用非静态成员（编译错误）。
示例：

java

运行

class A {
    static int x = 1;
    int y = 2;
    static void method() {
        System.out.println(x); // 合法
        // System.out.println(y); // 编译错误（静态方法不能直接用非静态变量）
    }
}

14. 构造方法

API 说明：与类名相同，无返回值，用于初始化对象。
易错点：定义带参构造后，默认无参构造会失效（需显式定义）。
示例：

java

运行

class B {
    int num;
    B(int num) { this.num = num; } // 带参构造
    // 未定义无参构造
}
// B b = new B(); // 编译错误（无参构造已失效）

15. 访问修饰符

API 说明：public（全公开）、protected（同包 + 子类）、默认（同包）、private（仅本类）。
易错点：跨包访问非public成员导致编译错误。
示例：

java

运行

package p1;
class C { int x = 1; } // 默认修饰符（仅p1包可见）

package p2;
import p1.C;
class D {
    void test() {
        C c = new C();
        // System.out.println(c.x); // 编译错误（p2包不可访问）
    }
}

二、字符串处理（15 条）

1. `String`不可变性

API 说明：String对象创建后内容不可修改，修改会生成新对象。
易错点：频繁拼接字符串效率低（应使用StringBuilder）。
示例：

java

运行

String s = "a";
s += "b"; // 实际创建新对象"ab"，原"s"仍为"a"

2. `StringBuilder`与`StringBuffer`

API 说明：可变字符串，StringBuilder线程不安全（效率高），StringBuffer线程安全（效率低）。
易错点：多线程场景误用StringBuilder导致数据不一致。
示例：

java

运行

StringBuilder sb = new StringBuilder();
sb.append("a").append("b"); // 链式调用，高效
String res = sb.toString(); // "ab"

3. `substring(int beginIndex, int endIndex)`

API 说明：截取子串，包含beginIndex，不包含endIndex（左闭右开）。
易错点：索引越界（beginIndex > endIndex或超出字符串长度）。
示例：

java

运行

String s = "abcde";
System.out.println(s.substring(1, 3)); // "bc"（1≤x<3）
// s.substring(3, 1); // 抛StringIndexOutOfBoundsException

4. `indexOf(String str)`与`lastIndexOf(String str)`

API 说明：indexOf返回子串首次出现索引，lastIndexOf返回末次出现索引，无则返回-1。
易错点：未判断返回值是否为-1直接使用导致索引越界。
示例：

java

运行

String s = "ababa";
int first = s.indexOf("aba"); // 0
int last = s.lastIndexOf("aba"); // 2
int none = s.indexOf("c"); // -1

5. `startsWith(String prefix)`与`endsWith(String suffix)`

API 说明：判断字符串是否以指定前缀 / 后缀开头 / 结尾。
易错点：参数为null时抛NullPointerException。
示例：

java

运行

String s = "hello.txt";
System.out.println(s.startsWith("hello")); // true
System.out.println(s.endsWith(".txt")); // true
// s.startsWith(null); // 抛NPE

6. `trim()`与`strip()`（Java 11+）

API 说明：trim()去除首尾 ASCII 空白符（\u0020），strip()去除所有 Unicode 空白符（如全角空格）。
易错点：需要去除非 ASCII 空白时误用trim()。
示例：

java

运行

String s = "  a b 　"; // 包含半角空格和全角空格（\u3000）
System.out.println(s.trim()); // "a b 　"（全角空格未去除）
System.out.println(s.strip()); // "a b"（全角空格被去除）

7. `split(String regex)`

API 说明：按正则表达式分割字符串，返回字符串数组。
易错点：正则特殊字符（如.、*、|）需转义；连续分隔符会产生空串。
示例：

java

运行

String s = "a.b.c";
String[] arr1 = s.split("\\."); // ["a", "b", "c"]（.需转义）

String s2 = "a,,b";
String[] arr2 = s2.split(","); // ["a", "", "b"]（连续分隔符产生空串）

8. `toCharArray()`

API 说明：将字符串转换为字符数组，便于修改单个字符。
易错点：修改数组不影响原字符串（String不可变）。
示例：

java

运行

String s = "abc";
char[] arr = s.toCharArray();
arr[0] = 'd';
System.out.println(s); // "abc"（原字符串不变）
System.out.println(new String(arr)); // "dbc"（新字符串）

9. `valueOf()`

API 说明：String.valueOf(任意类型)将其他类型转为字符串（避免null转成 "null"）。
易错点：null调用toString()抛 NPE，valueOf(null)返回 "null"。
示例：

java

运行

Integer num = null;
// System.out.println(num.toString()); // 抛NPE
System.out.println(String.valueOf(num)); // "null"（安全转换）

10. `compareTo(String anotherString)`

API 说明：按字典序比较字符串，返回负数（当前小）、0（相等）、正数（当前大）。
易错点：混淆返回值含义（非-1/0/1，可能是其他数值）。
示例：

java

运行

"apple".compareTo("banana"); // 负数（'a' < 'b'）
"cat".compareTo("cat"); // 0
"dog".compareTo("bird"); // 正数（'d' > 'b'）

11. `equalsIgnoreCase(String anotherString)`

API 说明：忽略大小写比较字符串内容，equals则区分大小写。
易错点：需要忽略大小写时误用equals。
示例：

java

运行

"Hello".equals("hello"); // false
"Hello".equalsIgnoreCase("hello"); // true

12. `replace(char oldChar, char newChar)`与`replaceAll(String regex, String replacement)`

API 说明：replace替换所有字符，replaceAll按正则替换。
易错点：replaceAll的第一个参数是正则，特殊字符需转义。
示例：

java

运行

String s = "a.b.c";
s.replace('.', '-'); // "a-b-c"（替换字符）
s.replaceAll("\\.", "-"); // "a-b-c"（正则替换，.需转义）

13. `isEmpty()`与`isBlank()`（Java 11+）

API 说明：isEmpty()判断长度是否为 0，isBlank()判断是否全为空白字符（长度可为 0）。
易错点：判断 " " 时，isEmpty()返回false，isBlank()返回true。
示例：

java

运行

"".isEmpty(); // true
"   ".isEmpty(); // false
"   ".isBlank(); // true

14. `concat(String str)`

API 说明：拼接字符串，与+类似，但concat仅接受String，+可接受任意类型。
易错点：concat效率低于StringBuilder，不适合多段拼接。
示例：

java

运行

"a".concat("b").concat("c"); // "abc"

15. 字符串长度`length()`

API 说明：s.length()返回字符串字符数（Unicode 代码单元数量）。
易错点：对包含增补字符（如 Emoji）的字符串，length()可能大于实际字符数。
示例：

java

运行

String emoji = "😀"; // 1个Emoji（Unicode增补字符）
System.out.println(emoji.length()); // 2（占用2个代码单元）

三、集合框架（30 条）

List 接口（10 条）

ArrayList初始化与扩容
- 说明：基于动态数组，初始容量 10，扩容为原容量 1.5 倍。
- 易错点：频繁扩容影响性能，可指定初始容量优化。
- 示例：
java

运行
```
List<Integer> list = new ArrayList<>(100); // 初始容量100，减少扩容
```
ArrayList.add(int index, E e)
- 说明：在指定索引插入元素，后续元素后移（时间复杂度 O (n)）。
- 易错点：索引越界（index < 0或index > size()）。
- 示例：
java

运行
```
List<Integer> list = new ArrayList<>(Arrays.asList(1,3));
list.add(1, 2); // [1,2,3]
```
ArrayList.remove(int index)
- 说明：删除指定索引元素，后续元素前移（O (n)）。
- 易错点：删除后索引变化，循环中删除需注意下标。
- 示例：
java

运行
```
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
list.remove(1); // [1,3]
```
LinkedList与ArrayList选择
- 说明：LinkedList基于双向链表，增删首尾快（O (1)），随机访问慢（O (n)）；ArrayList随机访问快（O (1)），增删中间慢（O (n)）。
- 易错点：频繁随机访问用LinkedList导致性能差。
- 示例：
java

运行
```
// 频繁增删首尾用LinkedList
LinkedList<Integer> queue = new LinkedList<>();
queue.addFirst(1); // 队首加元素
queue.removeLast(); // 队尾删元素
```
List.indexOf(Object o)
- 说明：返回元素首次出现索引，无则返回-1（基于equals判断）。
- 易错点：元素未重写equals导致判断错误。
- 示例：
java

运行
```
List<String> list = Arrays.asList("a", "b");
list.indexOf("b"); // 1
list.indexOf("c"); // -1
```
List.subList(int fromIndex, int toIndex)
- 说明：返回子列表视图（左闭右开），与原列表共享数据。
- 易错点：修改子列表会影响原列表；原列表结构修改（如add/remove）会导致子列表操作抛ConcurrentModificationException。
- 示例：
java

运行
```
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4));
List<Integer> sub = list.subList(1, 3); // [2,3]
sub.set(0, 5); // 原列表变为[1,5,3,4]
```
Collections.sort(List<T> list)
- 说明：对列表排序，元素需实现Comparable或传入Comparator。
- 易错点：元素未实现Comparable会抛ClassCastException。
- 示例：
java

运行
```
List<Integer> list = Arrays.asList(3,1,2);
Collections.sort(list); // [1,2,3]（Integer实现了Comparable）
```

List.toArray()

说明：将列表转为数组，无参返回Object[]，带参返回指定类型数组。
易错点：无参方法返回的数组强转可能抛ClassCastException。
示例：

java

运行

List<String> list = Arrays.asList("a", "b");
String[] arr = list.toArray(new String[0]); // 正确（指定类型）
// Object[] objArr = list.toArray();
// String[] arr2 = (String[]) objArr; // 抛ClassCastException

List.contains(Object o)
- 说明：判断列表是否包含元素（基于equals）。
- 易错点：元素为null时，contains(null)可正确判断（equals会处理null）。
- 示例：
java

运行
```
List<String> list = new ArrayList<>();
list.add(null);
list.contains(null); // true
```
List.retainAll(Collection<?> c)
- 说明：保留列表中与集合c共有的元素（交集），删除其他元素。
- 易错点：修改原列表，返回值为是否发生修改（boolean）。
- 示例：
java

运行
```
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
list.retainAll(Arrays.asList(2,3,4)); // 保留[2,3]，返回true
```

Set 接口（10 条）

HashSet去重原理

说明：基于哈希表，元素需重写hashCode()和equals()（两者需一致：equals为true则hashCode必须相等）。
易错点：未重写hashCode/equals导致去重失效。
示例：

java

运行

class User {
    String name;
    User(String name) { this.name = name; }
    @Override
    public boolean equals(Object o) {
        return o instanceof User && name.equals(((User)o).name);
    }
    @Override
    public int hashCode() { return name.hashCode(); } // 必须与equals一致
}
Set<User> set = new HashSet<>();
set.add(new User("a"));
set.add(new User("a")); // 去重成功（size=1）

HashSet与TreeSet区别
- 说明：HashSet无序，查询快（O (1)）；TreeSet有序（自然排序或比较器），查询 O (log n)，元素需可比较。
- 易错点：TreeSet元素未实现Comparable且无比较器会抛ClassCastException。
- 示例：
java

运行
```
TreeSet<Integer> set = new TreeSet<>(); // 自然排序（升序）
set.add(3); set.add(1);
System.out.println(set); // [1,3]
```

TreeSet自定义排序

说明：通过Comparator实现自定义排序（优先于自然排序）。
示例：

java

运行

TreeSet<Integer> descSet = new TreeSet<>((a, b) -> b - a); // 降序
descSet.add(3); descSet.add(1);
System.out.println(descSet); // [3,1]

Set.add(E e)
- 说明：添加元素，若已存在则返回false，否则true。
- 易错点：忽略返回值导致判断添加是否成功失败。
- 示例：
java

运行
```
Set<String> set = new HashSet<>();
set.add("a"); // true
set.add("a"); // false（已存在）
```

Set.remove(Object o)

说明：删除元素，成功返回true，否则false。
示例：

java

运行

Set<String> set = new HashSet<>(Arrays.asList("a", "b"));
set.remove("a"); // true，set变为{"b"}

Set.iterator()
- 说明：返回迭代器，用于遍历元素（HashSet迭代无序，TreeSet有序）。
- 易错点：迭代中修改集合（非迭代器方法）抛ConcurrentModificationException。
- 示例：
java

运行
```
Set<String> set = new HashSet<>(Arrays.asList("a", "b"));
Iterator<String> it = set.iterator();
while (it.hasNext()) {
    if (it.next().equals("a")) it.remove(); // 安全删除
}
```
LinkedHashSet
- 说明：继承HashSet，维护插入顺序（通过双向链表），性能略低于HashSet。
- 适用场景：需要保留插入顺序的去重场景。
- 示例：
java

运行
```
Set<String> set = new LinkedHashSet<>();
set.add("b"); set.add("a");
System.out.println(set); // [b, a]（保留插入顺序）
```

Set.containsAll(Collection<?> c)

说明：判断集合是否包含c中所有元素。
示例：

java

运行

Set<Integer> set = new HashSet<>(Arrays.asList(1,2,3));
set.containsAll(Arrays.asList(1,2)); // true
set.containsAll(Arrays.asList(1,4)); // false

Set与List转换

说明：new ArrayList<>(set)将 Set 转为 List（去重）；new HashSet<>(list)将 List 转为 Set（去重）。
示例：

java

运行

List<Integer> list = Arrays.asList(1,2,2,3);
Set<Integer> set = new HashSet<>(list); // 去重为{1,2,3}
List<Integer> uniqueList = new ArrayList<>(set); // [1,2,3]（顺序不确定）

Set的null元素
- 说明：HashSet和LinkedHashSet允许 1 个null元素；TreeSet不允许（会抛NullPointerException）。
- 示例：
java

运行
```
Set<String> hashSet = new HashSet<>();
hashSet.add(null); // 合法
Set<String> treeSet = new TreeSet<>();
// treeSet.add(null); // 抛NPE
```

Map 接口（10 条）

HashMap原理与扩容
- 说明：基于数组 + 链表 / 红黑树，初始容量 16，负载因子 0.75，扩容为原 2 倍。
- 易错点：初始容量需为 2 的幂（否则自动调整）；频繁扩容影响性能。
- 示例：
java

运行
```
Map<String, Integer> map = new HashMap<>(32); // 初始容量32（2的5次幂）
```
HashMap的key要求
- 说明：key需重写hashCode()和equals()（同HashSet），key为null时存于索引 0。
- 易错点：key为可变对象时，修改后可能导致无法查询。
- 示例：
java

运行
```
Map<List<Integer>, String> map = new HashMap<>();
List<Integer> key = new ArrayList<>();
map.put(key, "a");
key.add(1); // 修改key
map.get(key); // null（哈希值变化，无法找到）
```
TreeMap排序
- 说明：key需实现Comparable或传入Comparator，按key有序存储。
- 易错点：key为null时抛NPE（与HashMap不同）。
- 示例：
java

运行
```
TreeMap<Integer, String> map = new TreeMap<>(); // 按key升序
map.put(3, "c"); map.put(1, "a");
System.out.println(map.keySet()); // [1,3]
```
Map.put(K key, V value)
- 说明：添加键值对，若key已存在则覆盖旧值，返回旧值（否则null）。
- 易错点：误判put返回值（null可能是新添加，也可能是旧值为null）。
- 示例：
java

运行
```
Map<String, Integer> map = new HashMap<>();
map.put("a", 1); // 返回null（新添加）
map.put("a", 2); // 返回1（覆盖旧值）
```
Map.get(Object key)
- 说明：返回key对应的value，无则返回null。
- 易错点：value可能为null，无法通过get返回null判断key是否存在（需用containsKey）。
- 示例：
java

运行
```
Map<String, Integer> map = new HashMap<>();
map.put("a", null);
map.get("a"); // null（但key存在）
map.containsKey("a"); // true（正确判断key是否存在）
```
Map.containsKey(Object key)与containsValue(Object value)
- 说明：containsKey判断key是否存在（O (1) for HashMap）；containsValue判断value是否存在（O (n)）。
- 易错点：频繁用containsValue导致性能差。
- 示例：
java

运行
```
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.containsKey("a"); // true
map.containsValue(1); // true
```

Map.entrySet()

说明：返回键值对集合（Set<Map.Entry<K,V>>），便于遍历键值对。
示例：

java

运行

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
}

Map.keySet()与values()
- 说明：keySet()返回key集合，values()返回value集合（可重复）。
- 易错点：values()返回的集合无add方法（抛UnsupportedOperationException）。
- 示例：
java

运行
```
Set<String> keys = map.keySet();
Collection<Integer> values = map.values();
```
LinkedHashMap
- 说明：继承HashMap，维护插入顺序或访问顺序（accessOrder=true时，访问元素后移至尾部）。
- 适用场景：LRU 缓存（基于访问顺序）。
- 示例：
java

运行
```
Map<String, Integer> map = new LinkedHashMap<>(16, 0.75f, true); // 访问顺序
map.put("a", 1); map.put("b", 2);
map.get("a"); // 访问后，顺序变为b, a
```
Map.remove(Object key)
- 说明：删除key对应的键值对，返回旧值（无则null）。
- 示例：
java

运行
```
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.remove("a"); // 返回1，map为空
```

四、数组操作（10 条）

1. `Arrays.sort()`

说明：对数组排序，基本类型用双轴快排，对象用 TimSort（归并 + 插入）。
易错点：对对象数组排序，元素需实现Comparable或传入Comparator。
示例：

java

运行

int[] arr = {3,1,2};
Arrays.sort(arr); // [1,2,3]

String[] strs = {"c", "a", "b"};
Arrays.sort(strs); // ["a","b","c"]（String实现Comparable）

2. `Arrays.binarySearch()`

说明：二分查找元素，返回索引（找到）或-(插入点+1)（未找到），需先排序。
易错点：未排序数组调用会返回错误结果。
示例：

java

运行

int[] arr = {1,2,3,4};
Arrays.binarySearch(arr, 3); // 2（找到）
Arrays.binarySearch(arr, 5); // -5（插入点为4，-(4+1)=-5）

3. `Arrays.copyOf()`与`Arrays.copyOfRange()`

说明：copyOf(arr, newLength)复制数组至指定长度；copyOfRange(arr, from, to)复制指定范围（左闭右开）。
示例：

java

运行

int[] arr = {1,2,3};
int[] copy1 = Arrays.copyOf(arr, 2); // [1,2]
int[] copy2 = Arrays.copyOfRange(arr, 1, 3); // [2,3]

4. `Arrays.fill()`

说明：填充数组元素（全部或指定范围）。
示例：

java

运行

int[] arr = new int[3];
Arrays.fill(arr, 5); // [5,5,5]
Arrays.fill(arr, 1, 2, 8); // [5,8,5]（填充索引1）

5. `Arrays.equals()`

说明：比较两个数组是否相等（长度 + 元素均相等），基本类型按值比较，对象按equals。
易错点：用==比较数组引用（应使用Arrays.equals）。
示例：

java

运行

int[] a = {1,2};
int[] b = {1,2};
System.out.println(a == b); // false（引用不同）
System.out.println(Arrays.equals(a, b)); // true（内容相同）

6. 二维数组初始化

说明：int[][] arr = new int[2][3]（固定列数）或int[][] arr = new int[2][]（列数可变）。
易错点：访问未初始化的子数组会抛NullPointerException。
示例：

java

运行

int[][] arr = new int[2][];
arr[0] = new int[2]; // 初始化第0行
arr[0][0] = 1; // 合法
// arr[1][0] = 2; // 抛NPE（第1行未初始化）

7. 数组遍历

说明：for 循环或增强 for 循环，注意索引边界。
易错点：索引越界（i >= arr.length）。
示例：

java

运行

int[] arr = {1,2,3};
for (int i = 0; i < arr.length; i++) { // 避免i <= arr.length
    System.out.println(arr[i]);
}

8. 数组转集合

说明：Arrays.asList(arr)返回固定大小的List（不可add/remove），基本类型数组会被当作单个对象。
易错点：对基本类型数组使用Arrays.asList会导致集合元素为数组对象。
示例：

java

运行

Integer[] arr = {1,2,3};
List<Integer> list = Arrays.asList(arr); // 正确（元素为1,2,3）

int[] primArr = {1,2,3};
List<int[]> wrongList = Arrays.asList(primArr); // 错误（元素为int[]对象）

9. 集合转数组

说明：list.toArray(new T[0])（推荐，JVM 会优化容量）。
示例：

java

运行

List<Integer> list = Arrays.asList(1,2,3);
Integer[] arr = list.toArray(new Integer[0]); // [1,2,3]

10. 数组排序自定义比较器（对象数组）

说明：通过Comparator自定义排序规则。
示例：

java

运行

String[] strs = {"apple", "banana", "cat"};
// 按字符串长度排序
Arrays.sort(strs, (a, b) -> a.length() - b.length());

五、数学运算（10 条）

1. `Math.abs(int a)`

说明：返回绝对值，注意Integer.MIN_VALUE的绝对值溢出（结果仍为Integer.MIN_VALUE）。
示例：

java

运行

Math.abs(-3); // 3
Math.abs(Integer.MIN_VALUE); // Integer.MIN_VALUE（溢出）

2. `Math.max(a, b)`与`Math.min(a, b)`

说明：返回两数最大值 / 最小值，支持int、long、float、double。
示例：

java

运行

Math.max(3, 5); // 5
Math.min(2.1, 1.9); // 1.9

3. `Math.ceil(double a)`与`Math.floor(double a)`

说明：ceil向上取整（>=a 的最小整数），floor向下取整（<=a 的最大整数）。
示例：

java

运行

Math.ceil(2.3); // 3.0
Math.floor(2.7); // 2.0

4. `Math.round(double a)`

说明：四舍五入（对小数部分 >=0.5 向上取整，否则向下）。
示例：

java

运行

Math.round(2.3); // 2（long）
Math.round(2.6); // 3（long）

5. `Math.pow(double a, double b)`

说明：计算a^b，返回double，注意精度问题。
示例：

java

运行

Math.pow(2, 3); // 8.0
Math.pow(2, 0.5); // 根号2（约1.414）

6. `Math.sqrt(double a)`

说明：计算平方根，a为负时返回NaN。
示例：

java

运行

Math.sqrt(4); // 2.0
Math.sqrt(-1); // NaN

7. `Math.random()`

说明：返回[0.0, 1.0)的随机数，需转换为指定范围整数。
示例：

java

运行

// 生成[1, 10]的随机整数
int random = (int)(Math.random() * 10) + 1;

8. `BigInteger`

说明：处理大整数（超出long范围），支持加减乘除等运算。
示例：

java

运行

BigInteger a = new BigInteger("12345678901234567890");
BigInteger b = new BigInteger("98765432109876543210");
BigInteger sum = a.add(b); // 加法

9. `BigDecimal`

说明：高精度小数计算，避免double精度误差。
易错点：使用new BigDecimal(double)仍可能有精度问题，应使用new BigDecimal(String)。
示例：

java

运行

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b); // 0.3

10. 取模运算（`%`）

说明：返回余数，结果符号与被除数一致。
示例：

java

运行

5 % 3; // 2
-5 % 3; // -2
5 % -3; // 2

六、异常处理（5 条）

1. `try-catch-finally`

说明：try执行可能异常的代码，catch捕获处理，finally必执行（除非 JVM 退出）。
易错点：finally中修改返回值会覆盖try/catch的返回值。
示例：

java

运行

int test() {
    try {
        return 1;
    } finally {
        return 2; // 覆盖try的返回值
    }
}
// 调用test()返回2

2. `NullPointerException`（NPE）

说明：调用null对象的方法或属性时抛出，算法题中最常见异常。
预防：调用方法前判断对象是否为null。
示例：

java

运行

String s = null;
// s.length(); // 抛NPE
if (s != null) {
    // 安全操作
}

3. `IndexOutOfBoundsException`

说明：数组或集合索引越界（如arr[-1]、list.get(10)当size=5）。
预防：操作索引前检查是否在[0, length-1]或[0, size-1]范围内。

4. `ClassCastException`

说明：类型强制转换失败（如Object o = "str"; Integer i = (Integer)o）。
预防：转换前用instanceof判断。
示例：

java

运行

Object o = "hello";
if (o instanceof Integer) {
    Integer i = (Integer)o; // 不会执行，避免异常
}

5. `try-with-resources`

说明：自动关闭实现AutoCloseable的资源（如流），无需手动close。
示例：

java

运行

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    br.readLine();
} catch (IOException e) {
    e.printStackTrace();
} // br自动关闭

七、其他实用 API（5 条）

1. `System.currentTimeMillis()`

说明：返回当前时间戳（毫秒级），用于计时。
示例：

java

运行

long start = System.currentTimeMillis();
// 执行代码
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - start) + "ms");

2. `Collections.reverse(List<?> list)`

说明：反转列表元素顺序。
示例：

java

运行

List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
Collections.reverse(list); // [3,2,1]

3. `Collections.shuffle(List<?> list)`

说明：随机打乱列表元素。
示例：

java

运行

List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
Collections.shuffle(list); // 随机顺序（如[2,1,3]）

4. `Objects.equals(Object a, Object b)`

说明：安全比较两个对象是否相等（处理null，避免 NPE）。
示例：

java

运行

Objects.equals(null, "a"); // false
Objects.equals("a", "a"); // true

5. `StringJoiner`（Java 8+）

说明：拼接字符串并添加分隔符、前缀、后缀。
示例：

java

运行

StringJoiner sj = new StringJoiner(",", "[", "]"); // 分隔符, 前缀[, 后缀]
sj.add("a").add("b");
System.out.println(sj.toString()); // [a,b]

以上内容覆盖了 Java 算法题中 95% 以上的常用 API 和易错点，掌握这些可显著减少语法错误，提高编码效率。

【Hot100｜先导篇 Java算法常用API的调用&易错语法点】

一、基础语法与数据类型（15 条）

1. 基本类型与包装类转换

2. 包装类缓存机制

3. final关键字

4. 三元运算符类型兼容

5. ++i与i++的区别

6. 方法参数传递

7. switch-case语句

8. 增强 for 循环（foreach）

9. 数组长度与集合大小

10. 浮点数精度问题

11. null判断

12. 字符串常量池

13. static关键字

14. 构造方法

15. 访问修饰符

二、字符串处理（15 条）

1. String不可变性

2. StringBuilder与StringBuffer

3. substring(int beginIndex, int endIndex)

4. indexOf(String str)与lastIndexOf(String str)

5. startsWith(String prefix)与endsWith(String suffix)

6. trim()与strip()（Java 11+）

7. split(String regex)

8. toCharArray()

9. valueOf()

10. compareTo(String anotherString)

11. equalsIgnoreCase(String anotherString)

12. replace(char oldChar, char newChar)与replaceAll(String regex, String replacement)

13. isEmpty()与isBlank()（Java 11+）

14. concat(String str)

15. 字符串长度length()

三、集合框架（30 条）

List 接口（10 条）

Set 接口（10 条）

Map 接口（10 条）

四、数组操作（10 条）

1. Arrays.sort()

2. Arrays.binarySearch()

3. Arrays.copyOf()与Arrays.copyOfRange()

4. Arrays.fill()

5. Arrays.equals()

6. 二维数组初始化

7. 数组遍历

8. 数组转集合

9. 集合转数组

10. 数组排序自定义比较器（对象数组）

五、数学运算（10 条）

1. Math.abs(int a)

2. Math.max(a, b)与Math.min(a, b)

3. Math.ceil(double a)与Math.floor(double a)

4. Math.round(double a)

5. Math.pow(double a, double b)

6. Math.sqrt(double a)

7. Math.random()

8. BigInteger

9. BigDecimal

10. 取模运算（%）

六、异常处理（5 条）

1. try-catch-finally

2. NullPointerException（NPE）

3. IndexOutOfBoundsException

4. ClassCastException

5. try-with-resources

七、其他实用 API（5 条）

1. System.currentTimeMillis()

2. Collections.reverse(List<?> list)

3. Collections.shuffle(List<?> list)

4. Objects.equals(Object a, Object b)

5. StringJoiner（Java 8+）

3. `final`关键字

5. `++i`与`i++`的区别

7. `switch-case`语句

11. `null`判断

13. `static`关键字

1. `String`不可变性

2. `StringBuilder`与`StringBuffer`

3. `substring(int beginIndex, int endIndex)`

4. `indexOf(String str)`与`lastIndexOf(String str)`

5. `startsWith(String prefix)`与`endsWith(String suffix)`

6. `trim()`与`strip()`（Java 11+）

7. `split(String regex)`

8. `toCharArray()`

9. `valueOf()`

10. `compareTo(String anotherString)`

11. `equalsIgnoreCase(String anotherString)`

12. `replace(char oldChar, char newChar)`与`replaceAll(String regex, String replacement)`

13. `isEmpty()`与`isBlank()`（Java 11+）

14. `concat(String str)`

15. 字符串长度`length()`

1. `Arrays.sort()`

2. `Arrays.binarySearch()`

3. `Arrays.copyOf()`与`Arrays.copyOfRange()`

4. `Arrays.fill()`

5. `Arrays.equals()`

1. `Math.abs(int a)`

2. `Math.max(a, b)`与`Math.min(a, b)`

3. `Math.ceil(double a)`与`Math.floor(double a)`

4. `Math.round(double a)`

5. `Math.pow(double a, double b)`

6. `Math.sqrt(double a)`

7. `Math.random()`

8. `BigInteger`

9. `BigDecimal`

10. 取模运算（`%`）

1. `try-catch-finally`

2. `NullPointerException`（NPE）

3. `IndexOutOfBoundsException`

4. `ClassCastException`

5. `try-with-resources`

1. `System.currentTimeMillis()`

2. `Collections.reverse(List<?> list)`

3. `Collections.shuffle(List<?> list)`

4. `Objects.equals(Object a, Object b)`

5. `StringJoiner`（Java 8+）