【java API】leetcode常用刷题API及ACM模式

文章目录

• • • ACM输入 Scanner
  • 一、字符串高频API
  • 二、集合高频API
  • 三、栈（Stack）高频API
  • • 1. 推荐用Deque替代Stack类（更高效且线程不安全，适合算法场景）
    • 2. 核心操作
    • 3. 经典应用场景
    • 4. 避坑指南
  • 四、链表（LinkedList）高频API
  • • 1. 内置LinkedList类
    • 2. 核心操作
    • 3. 自定义链表节点（LeetCode常用）
    • 4. 经典应用场景
    • 5. 避坑指南
  • 五、实用代码片段
  • • 1. 用栈实现队列
    • 2. 快慢指针找链表中点

ACM输入 Scanner

```java
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据

        // next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}

```

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
runoob com
输入的数据为：runoob

可以看到 com 字符串并未输出

使用 nextLine 方法：

```java
 // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }

```

runoob com
输入的数据为：runoob com

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取。

以下是针对ACM模式刷题时，字符串和集合相关的高频Java API总结（按使用频率排序）：

一、字符串高频API

1. String类

   ```java
   String str = "abc";
   // 基础操作
   str.length() // 字符串长度
   str.charAt(int index) // 获取字符（高频）
   str.substring(int start) // 截取子串（含start）
   str.substring(int start, int end) // 截取[start,end)
   str.split(String regex) // 分割字符串（高频，如处理输入）
   str.toCharArray() // 转字符数组（高频用于遍历）
   str.equals(String other) // 比较内容（非地址）
   str.indexOf(String s) // 查找子串位置

   // 类型转换
   Integer.parseInt(str) // 字符串转整数（高频）
   String.valueOf(int/double...) // 其他类型转字符串（高频）
   str.toLowerCase() / toUpperCase() // 大小写转换

   // 其他
   str.trim() // 去除首尾空格
   str.replace(old, new) // 替换字符/字符串
   str.contains(String s) // 是否包含子串

   ```

2. StringBuilder（高频！线程不安全但更快）

   ```java
   StringBuilder sb = new StringBuilder();
   sb.append("a") // 追加内容（高频）
   sb.insert(index, "x") // 插入
   sb.delete(start, end) // 删除
   sb.reverse() // 反转（高频用于回文题）
   sb.toString() // 转String（最终输出）

   ```

3. Character

   ```java
   Character.isLetter()
   Character.toLowerCase()

   ```

二、集合高频API

1. List（ArrayList最常用）

   ```java
   List list = new ArrayList<>();
   // 基础操作
   list.add(element) // 添加元素（高频）
   list.get(int index) // 获取元素（高频）
   list.size() // 元素个数（高频）
   list.remove(int index) // 按索引删除
   list.remove(Object o) // 按对象删除
   list.contains(Object o) // 是否包含元素
   list.isEmpty() // 判空

   // 工具方法
   Collections.sort(list) // 排序（高频）
   Collections.reverse(list) // 反转
   Collections.max(list) / min(list) // 最大/最小值
   Collections.fill(list, val) // 填充

   // 数组互转
   Arrays.asList(T... a) // 数组转List（注意返回固定大小List）
   list.toArray(new T[0]) // List转数组

   ```

2. Map（HashMap最常用）

   ```java
   Map map = new HashMap<>();
   // 基础操作
   map.put(key, value) // 添加/覆盖键值对（高频）
   map.get(key) // 获取值（高频）
   map.containsKey(key) // 是否包含键（高频）
   map.getOrDefault(key, defaultValue) // 安全获取
   map.remove(key) // 删除键
   map.size() // 键值对数量

   // 遍历（高频）
   for (Map.Entry entry : map.entrySet())

   //PriorityQueue（优先队列）
   PriorityQueue> pq = new PriorityQueue<>(
   (a, b) -> b.getValue() - a.getValue()
   );
   pq.addAll(map.entrySet());

   ```

以下是栈（Stack）和链表（LinkedList）在ACM模式刷题时的高频Java API总结，包含核心操作和避坑指南：

三、栈（Stack）高频API

1. 推荐用Deque替代Stack类（更高效且线程不安全，适合算法场景）

```java
Deque stack = new ArrayDeque<>();

```

2. 核心操作

3. 经典应用场景

• 括号匹配 ：用栈存储左括号，遇到右括号时弹栈匹配
• 单调栈 ：维护栈内元素单调性（递增/递减）
• 表达式求值 ：处理运算符优先级

4. 避坑指南

• 空栈检查 ：pop()和peek()前必须检查栈是否为空，否则会抛出NoSuchElementException
• 性能对比 ：优先用ArrayDeque而非Stack类（后者同步操作性能差）

四、链表（LinkedList）高频API

1. 内置LinkedList类

```java
LinkedList list = new LinkedList<>();

```

2. 核心操作

3. 自定义链表节点 （LeetCode常用）

```java
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}
// 操作示例：反转链表
ListNode dummy = new ListNode(-1);
while (head != null) {
    ListNode next = head.next;
    head.next = dummy.next;
    dummy.next = head;
    head = next;
}
return dummy.next;

```

4. 经典应用场景

• 链表反转 ：迭代或递归修改指针指向
• 合并有序链表 ：双指针遍历比较
• 快慢指针 ：检测环、找中点（如判断回文链表）
• 虚拟头节点 ：简化头节点边界处理

5. 避坑指南

• 指针丢失 ：修改链表节点指针时，注意提前保存next节点
• 循环引用 ：操作链表后注意检查是否成环
• 性能陷阱 ：避免频繁调用get(index)（链表随机访问是O(n)）

五、实用代码片段

1. 用栈实现队列

```java
class MyQueue {
    Deque inStack = new ArrayDeque<>();
    Deque outStack = new ArrayDeque<>();

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop());
            }
        }
        return outStack.pop();
    }
}

```

2. 快慢指针找链表中点

```java
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
    slow = slow.next;       // 慢指针走1步
    fast = fast.next.next;  // 快指针走2步
}
// slow即为中点（偶数个节点时靠左）

```

掌握这些API和技巧后，可以高效解决栈和链表相关的算法题，注意边界条件和指针操作的细节！