java 常用的一些数据结构 - 详解

1. 数组（int[] / char[] 等）

核心特性：

• 长度固定，可通过索引快速访问（O(1)），适合存储连续数据。

创建方法：

// 直接初始化
int[] arr1 = {1, 2, 3};
char[] arr2 = {'a', 'b'};
// 指定长度后赋值（默认值：数值0/布尔false/引用null）
int[] arr3 = new int[5];
for (int i = 0; i < arr3.length; i++) {
arr3[i] = i + 1;
}
// 动态长度（变量确定）
int n = 10;
int[] arr4 = new int[n];

常用方法：

• 访问/修改：arr[index]（索引从0开始）
• 长度：arr.length（属性，无括号）
• 遍历：

  for (int i = 0; i < arr.length; i++) { ... } // 可修改元素
  for (int num : arr) { ... } // 增强for（仅读取）

类型转换：

• 数组 ↔ List：

  Integer[] arr = {1, 2, 3};
  List<Integer> list = new ArrayList<>(Arrays.asList(arr)); // 数组→List（可修改）
    List<Integer> list = Arrays.asList(1, 2, 3);
      Integer[] arr = list.toArray(new Integer[0]); // List→数组

• 字符串 ↔ 字符数组：

  String s = "abc";
  char[] chars = s.toCharArray(); // 字符串→字符数组
  char[] chars = {'a', 'b'};
  String s = new String(chars); // 字符数组→字符串

2. List 接口（ArrayList / LinkedList）

核心特性：

• 动态扩容，支持增删改查，ArrayList 适合随机访问，LinkedList 适合频繁插入删除。

创建方法：

// ArrayList（最常用）
List<Integer> list1 = new ArrayList<>(); // 空列表
  List<String> list2 = new ArrayList<>(Arrays.asList("a", "b")); // 初始化元素
    List<Integer> list3 = new ArrayList<>(10); // 指定初始容量（优化性能）
      // LinkedList（兼具List和Deque特性）
      List<Integer> list4 = new LinkedList<>();
        Deque<Integer> deque = new LinkedList<>(); // 作为双端队列

常用方法：

• 增：add(E e)（末尾）、add(int index, E e)（指定位置）
• 删：remove(int index)（按索引）、remove(Object o)（按元素）
• 改：set(int index, E e)
• 查：get(int index)、contains(Object o)、indexOf(Object o)
• 长度：size()
• 其他：isEmpty()、clear()

类型转换：

• List ↔ 数组：见上文数组转换示例。
• List ↔ Set：

  List<Integer> list = Arrays.asList(1, 2, 2);
    Set<Integer> set = new HashSet<>(list); // List→Set（去重）
      Set<Integer> set = new HashSet<>(Arrays.asList(1, 2));
        List<Integer> list = new ArrayList<>(set); // Set→List

3. 字符串（String / StringBuilder / StringBuffer）

核心特性：

• String 不可变，StringBuilder 可变（非线程安全，高效），StringBuffer 可变（线程安全，低效）。

创建方法：

// String
String s1 = "abc"; // 常量池
String s2 = new String("abc"); // 堆内存
String s3 = String.valueOf(123); // 其他类型转字符串
// StringBuilder（优先使用）
StringBuilder sb1 = new StringBuilder(); // 空
StringBuilder sb2 = new StringBuilder("abc"); // 初始内容
StringBuilder sb3 = new StringBuilder(10); // 指定容量
// StringBuffer（少用）
StringBuffer sb4 = new StringBuffer();

常用方法：

• String：
  • 长度：length()
  • 访问：charAt(int index)
  • 子串：substring(int start, int end)（左闭右开）
  • 比较：equals(Object o)、startsWith(String prefix)
• StringBuilder：
  • 增：append(xxx)（拼接任意类型）
  • 删：delete(int start, int end)
  • 改：setCharAt(int index, char c)
  • 反转：reverse()（高频！如回文判断）
  • 转换：toString()（转为 String）

类型转换：

• 字符串 ↔ 基本类型：

  String s = "123";
  int num = Integer.parseInt(s); // 字符串→int
  String s2 = String.valueOf(num); // 基本类型→字符串

• String ↔ StringBuilder：

  String s = "abc";
  StringBuilder sb = new StringBuilder(s); // String→StringBuilder
  String s2 = sb.toString(); // StringBuilder→String

4. HashMap<K, V>

核心特性：

• 存储键值对，键唯一，查询效率高（O(1)），适合计数、映射场景。

创建方法：

// 空map
Map<String, Integer> map1 = new HashMap<>();
  // 初始化元素（JDK9+）
  Map<String, Integer> map2 = Map.of("a", 1, "b", 2); // 不可修改
    Map<String, Integer> map3 = new HashMap<>(Map.of("a", 1)); // 可修改
      // 指定初始容量（减少扩容）
      Map<Integer, String> map4 = new HashMap<>(16);

常用方法：

• 增/改：put(K key, V value)（覆盖已有键）
• 查：get(K key)、containsKey(K key)
• 删：remove(K key)
• 遍历：

  for (K key : map.keySet()) { ... } // 遍历键
  for (Map.Entry<K, V> entry : map.entrySet()) { ... } // 遍历键值对

• 其他：size()、isEmpty()、values()（获取所有值）

类型转换：

• 提取键/值集合：

  Set<String> keys = map.keySet();
    Collection<Integer> values = map.values();

5. HashSet

核心特性：

• 存储唯一元素（去重），查询效率高（O(1)），无序。

创建方法：

// 空set
Set<Integer> set1 = new HashSet<>();
  // 初始化元素
  Set<String> set2 = new HashSet<>(Arrays.asList("a", "b"));
    // 从其他集合创建
    List<Integer> list = Arrays.asList(1, 2);
      Set<Integer> set3 = new HashSet<>(list);

常用方法：

• 增：add(E e)（存在则返回false）
• 删：remove(E e)
• 查：contains(E e)（高频！判断存在性）
• 其他：size()、isEmpty()、clear()

类型转换：

• Set ↔ List：见上文 List 转换示例。

6. Queue 与 Deque

核心特性：

• Queue 是单端队列（FIFO），Deque 是双端队列（支持两端操作，可作栈用）。

创建方法：

// Queue（推荐ArrayDeque，效率高于LinkedList）
Queue<Integer> queue1 = new LinkedList<>();
  Queue<String> queue2 = new ArrayDeque<>();
    // Deque（常用ArrayDeque）
    Deque<Integer> deque1 = new ArrayDeque<>();
      Deque<String> deque2 = new LinkedList<>();

常用方法：

• Queue：
  • 入队：offer(E e)（推荐，失败返回false）
  • 出队：poll()（推荐，空返回null）
  • 查看队首：peek()
• Deque（双端操作）：
  • 队首：offerFirst(E e)、pollFirst()、peekFirst()
  • 队尾：offerLast(E e)、pollLast()、peekLast()
  • 栈操作：push(E e)（等价于 offerFirst）、pop()（等价于 pollFirst）

类型转换：

• 转为 List：

  Queue<Integer> queue = new LinkedList<>();
    List<Integer> list = new ArrayList<>(queue);

7. Arrays 工具类

常用方法：

• 数组转字符串：Arrays.toString(arr)（打印数组）
• 排序：Arrays.sort(arr)（原地排序）
• 复制：Arrays.copyOf(arr, newLength)、Arrays.copyOfRange(arr, start, end)
• 填充：Arrays.fill(arr, val)（全量填充）
• 比较：Arrays.equals(arr1, arr2)（内容比较）
• 反转：Arrays.reverse(arr)（原地反转）

算法题高频场景：

1. 字符串处理：用 StringBuilder 拼接/反转，charAt 访问字符。
2. 去重/判重：HashSet.contains()（O(1) 效率）。
3. 键值映射：HashMap 统计频率（如两数之和、字符计数）。
4. BFS：Queue.offer()/poll() 实现层次遍历。
5. 栈操作：Deque.push()/pop() 处理括号匹配、单调栈。
6. 数组操作：Arrays.sort() 排序、Arrays.copyOf() 扩容。