java 常用的一些数据结构

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

核心特性：

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

创建方法：

java 复制代码

// 直接初始化
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（属性，无括号）

遍历：

java 复制代码

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

类型转换：

数组 ↔ List ：

java 复制代码

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→数组

字符串 ↔ 字符数组 ：

java 复制代码

String s = "abc";
char[] chars = s.toCharArray(); // 字符串→字符数组

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

2. List 接口（ArrayList / LinkedList）

核心特性：

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

创建方法：

java 复制代码

// 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 ：

java 复制代码

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 可变（线程安全，低效）。

创建方法：

java 复制代码

// 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）

类型转换：

字符串 ↔ 基本类型 ：

java 复制代码

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

String ↔ StringBuilder ：

java 复制代码

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

4. HashMap<K, V>

核心特性：

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

创建方法：

java 复制代码

// 空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)

遍历：

java 复制代码

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

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

类型转换：

提取键/值集合：

java 复制代码

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

5. HashSet

核心特性：

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

创建方法：

java 复制代码

// 空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 是双端队列（支持两端操作，可作栈用）。

创建方法：

java 复制代码

// 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：

java 复制代码

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)（原地反转）

算法题高频场景：

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