java 数据结构 - 技术栈

很好，你这个基础已经非常接近「面试笔记级别」了 👍

我不会丢掉你现有的内容 ，而是在每一节下面做"深度补全 + 面试细节 + 源码级补充"，让它从「复习提纲」升级成「面试通关文档」。

下面是 ✅ 在原结构基础上的详细补全版（老内容全部保留）。

一、Java 数据结构体系（必背 · 补全版）

复制代码

Java 数据结构
├── 数组（Array）
│   ├── 一维数组
│   ├── 多维数组
│   └── 动态数组（ArrayList）
├── 字符串（String）
│   ├── String
│   ├── StringBuilder
│   └── StringBuffer
├── 集合框架（Collection / Map）
│   ├── List
│   │   ├── ArrayList（重点）
│   │   ├── LinkedList（重点）
│   │   └── Vector（了解）
│   ├── Set
│   │   ├── HashSet
│   │   ├── LinkedHashSet
│   │   └── TreeSet
│   ├── Queue / Deque
│   │   ├── PriorityQueue
│   │   ├── ArrayDeque（重点）
│   │   └── LinkedList
│   └── Map（重点）
│       ├── HashMap（★★★★★）
│       ├── LinkedHashMap
│       ├── TreeMap
│       ├── Hashtable
│       └── ConcurrentHashMap（★★★★★）
└── 工具类
    ├── Arrays
    └── Collections

✅ 面试提示：

List / Map / Set 是三大核心
HashMap / ConcurrentHashMap 几乎是必问

二、数组（Array · 深度补全）

1️⃣ 特点（不变）

特性	说明
连续内存	✅
随机访问	O(1)
插入删除	O(n)
长度固定	✅

2️⃣ 补充重点（面试爱问）

✅ 数组为什么快？

连续内存
CPU 缓存友好
下标直接计算地址

✅ Java 数组是对象

java 复制代码

int[] arr = new int[10];

在堆中分配
有 length 属性
不是基本类型

✅ 数组扩容方式（你前面问过）

方式	推荐度
Arrays.copyOf	✅✅✅
System.arraycopy	✅✅✅
手动 for	❌

三、字符串（String · 深度补全）

1️⃣ String 不可变（重点）

java 复制代码

String s = "abc";
s = s + "d";

✅ 不是修改原对象

✅ 是新创建对象

2️⃣ 为什么不可变？

final class
final char[]
线程安全
常量池复用
hash 缓存

3️⃣ StringBuilder vs StringBuffer（面试标准答案）

对比	线程安全	性能	使用场景
StringBuilder	❌	✅	单线程
StringBuffer	✅	❌	几乎不用

✅ 99% 场景用 StringBuilder

四、List（重点 · 深度补全）

1️⃣ ArrayList（★★★★★）

✅ 扩容机制（你前面问的）

初始容量：0（懒加载）
第一次 add → 10
满了才扩容
扩容：1.5 倍
扩容方式：Arrays.copyOf

📌 面试标准答案：

ArrayList 是满了才扩容，不是提前扩容。

✅ 增删慢的原因

数组整体移动
扩容成本高

✅ 适合场景

查询多
随机访问
数据量可预估

2️⃣ LinkedList（★★★★）

✅ 底层结构

java 复制代码

class Node<E> {
    E item;
    Node<E> prev;
    Node<E> next;
}

✅ 不只是 List

List
Queue
Deque

✅ 可做：

栈
队列
双端队列

✅ 增删一定快吗？

操作	是否快
头插	✅
尾插	✅
中间插	❌（要遍历）

3️⃣ Vector（了解即可）

方法级 synchronized
性能差
已被淘汰

五、Set（不可重复 · 深度补全）

1️⃣ HashSet（★★★★）

✅ 如何保证不重复？

java 复制代码

hashCode() -> equals()

流程：

计算 hash
定位桶
equals 判断

✅ 允许 null？

✅ 允许一个 null

2️⃣ LinkedHashSet

✅ 插入顺序

✅ 性能略低于 HashSet

3️⃣ TreeSet

✅ 自然排序 / 自定义排序

❌ 不允许 null（除非 comparator 支持）

六、Map（★★★★★ · 深度补全）

1️⃣ HashMap（必问中的必问）

✅ JDK 1.7 vs 1.8

版本	结构
JDK 7	数组 + 链表
JDK 8	数组 + 链表 + 红黑树

✅ 核心参数（必须记住）

参数	值
默认容量	16
最大容量	2^30
负载因子	0.75
链表 → 树	8
树 → 链表	6

✅ 扩容触发

text 复制代码

size > capacity * loadFactor

✅ 线程安全吗？

❌ 线程不安全

问题：

数据覆盖
结构破坏
JDK 7：死循环

2️⃣ LinkedHashMap

✅ 插入顺序

✅ accessOrder → LRU

3️⃣ TreeMap

✅ 红黑树

✅ 有序 Map

✅ 时间复杂度 O(log n)

4️⃣ Hashtable

❌ 不推荐

✅ 被 ConcurrentHashMap 取代

5️⃣ ConcurrentHashMap（★★★★★）

✅ JDK 1.8 实现

CAS + synchronized
锁粒度小
高并发

七、Queue（队列 · 补全）

1️⃣ PriorityQueue

小顶堆
不保证 FIFO
O(log n)

2️⃣ ArrayDeque（推荐）

✅ 替代 Stack

✅ 比 Stack 快

✅ 无容量限制

八、时间复杂度（速记 · 补全）

数据结构	查询	插入	删除
ArrayList	O(1)	O(n)	O(n)
LinkedList	O(n)	O(1)	O(1)
HashMap	O(1)	O(1)	O(1)
TreeMap	O(log n)	O(log n)	O(log n)

九、遍历（面试坑点）

❌ 增强 for + remove → 抛异常

✅ 正确方式：

java 复制代码

Iterator<E> it = list.iterator();
while (it.hasNext()) {
    it.remove();
}

十、面试高频（终极版）

✅ ArrayList 什么时候扩容？

✅ HashMap 为什么线程不安全？

✅ HashMap 链表为什么转红黑树？

✅ ConcurrentHashMap 如何实现线程安全？

✅ HashSet 如何保证不重复？

✅ TreeMap 和 HashMap 区别？

✅ fail-fast 是什么？

十一、一句话终极总结（记住这句 ✅）

数组是底层基石，集合是工程核心；
ArrayList 查快改慢，LinkedList 改快查慢；
HashMap 是面试之王，ConcurrentHashMap 是并发之王。

好，这一步做完，你这份就 不再是"知识点" ，而是 "可直接写代码的 Java 数据结构速查手册" 了 ✅

我会 严格保留你前面的所有内容 ，只在 每一节后面新增「常用 API + 示例代码」，不删不改原内容。

一、Java 数据结构体系（完整版）

✅ 前面结构 完全保留

二、数组（Array · 用法补全）

1️⃣ 声明 & 初始化

java 复制代码

// 静态初始化
int[] a = {1, 2, 3};

// 动态初始化
int[] b = new int[5];

2️⃣ 基本操作

java 复制代码

a[0] = 10;              // 赋值
int x = a[1];           // 取值
int len = a.length;     // 长度

3️⃣ 数组工具类（Arrays）

java 复制代码

import java.util.Arrays;

Arrays.sort(a);                     // 排序
Arrays.fill(a, 5);                  // 填充
int[] c = Arrays.copyOf(a, 10);     // 扩容
boolean eq = Arrays.equals(a, b);   // 比较

三、字符串（String · 用法补全）

1️⃣ String 常用 API

java 复制代码

String s = " Hello World ";

s.length();         // 长度
s.charAt(0);        // 取字符
s.substring(0, 5);  // 截取
s.trim();           // 去空格
s.toUpperCase();    // 转大写
s.contains("Hello");// 是否包含
s.indexOf("o");     // 索引
s.replace("o", "O");// 替换
s.split(" ");       // 分割

2️⃣ StringBuilder / StringBuffer

java 复制代码

StringBuilder sb = new StringBuilder();

sb.append("a");
sb.insert(0, "b");
sb.delete(0, 1);
sb.reverse();
sb.toString();

✅ 循环中拼接字符串必须用 StringBuilder

四、List（用法补全）

1️⃣ ArrayList 常用 API

java 复制代码

List<String> list = new ArrayList<>();

list.add("A");          // 添加
list.add(0, "B");       // 指定位置
list.get(0);            // 获取
list.set(0, "C");       // 修改
list.remove(0);         // 删除
list.size();            // 大小
list.isEmpty();         // 判空
list.contains("A");     // 是否存在
list.clear();           // 清空

2️⃣ LinkedList 特有 API

java 复制代码

LinkedList<String> queue = new LinkedList<>();

queue.addFirst("a");
queue.addLast("b");
queue.getFirst();
queue.getLast();
queue.poll();       // 弹出头
queue.offer("c");   // 入队
queue.push("d");    // 压栈
queue.pop();        // 弹栈

五、Set（用法补全）

1️⃣ HashSet

java 复制代码

Set<String> set = new HashSet<>();

set.add("A");
set.remove("A");
set.contains("A");
set.size();
set.isEmpty();
set.clear();

2️⃣ LinkedHashSet

java 复制代码

Set<String> set = new LinkedHashSet<>();

✅ API 同 HashSet

3️⃣ TreeSet

java 复制代码

TreeSet<Integer> tree = new TreeSet<>();

tree.add(3);
tree.add(1);
tree.add(2);

tree.first();       // 最小
tree.last();        // 最大
tree.floor(2);      // ≤2
tree.ceiling(2);    // ≥2

六、Map（★★★★★ · 用法补全）

1️⃣ HashMap 常用 API

java 复制代码

Map<String, Integer> map = new HashMap<>();

map.put("A", 1);                // 添加
map.get("A");                   // 获取
map.getOrDefault("B", 0);       // 默认值
map.containsKey("A");
map.containsValue(1);
map.remove("A");
map.size();
map.isEmpty();
map.clear();

2️⃣ Map 遍历（必会 ⭐⭐⭐⭐⭐）

java 复制代码

// 1. keySet
for (String key : map.keySet()) {
    System.out.println(key + map.get(key));
}

// 2. entrySet（推荐）
for (Map.Entry<String, Integer> e : map.entrySet()) {
    System.out.println(e.getKey() + e.getValue());
}

// 3. values
for (Integer v : map.values()) {
    System.out.println(v);
}

3️⃣ LinkedHashMap

java 复制代码

Map<String, Integer> map = new LinkedHashMap<>();

✅ API 同 HashMap

4️⃣ TreeMap

java 复制代码

TreeMap<Integer, String> tree = new TreeMap<>();

tree.put(3, "C");
tree.put(1, "A");
tree.put(2, "B");

tree.firstKey();
tree.lastKey();
tree.lowerKey(2);   // <2
tree.higherKey(2); // >2

5️⃣ Hashtable（了解）

java 复制代码

Hashtable<String, String> table = new Hashtable<>();

✅ API 同 HashMap（但线程安全）

6️⃣ ConcurrentHashMap

java 复制代码

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

map.put("A", 1);
map.get("A");
map.putIfAbsent("A", 2);
map.remove("A");

七、Queue（用法补全）

1️⃣ PriorityQueue

java 复制代码

PriorityQueue<Integer> pq = new PriorityQueue<>();

pq.offer(3);
pq.offer(1);
pq.offer(2);

pq.peek();  // 查看
pq.poll();  // 弹出

2️⃣ ArrayDeque

java 复制代码

Deque<String> deque = new ArrayDeque<>();

deque.addFirst("a");
deque.addLast("b");
deque.pollFirst();
deque.pollLast();

八、集合工具类（Collections · 用法补全）

java 复制代码

Collections.sort(list);
Collections.reverse(list);
Collections.shuffle(list);
Collections.max(list);
Collections.min(list);
Collections.frequency(list, "A");

九、遍历方式（完整示例）

java 复制代码

// fori
for (int i = 0; i < list.size(); i++) {}

// for-each
for (String s : list) {}

// iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    it.next();
}

// stream
list.stream().forEach(System.out::println);

十、完整使用示例（综合）

java 复制代码

List<String> list = new ArrayList<>();
list.add("A");

Set<String> set = new HashSet<>(list);

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);

for (Map.Entry<String, Integer> e : map.entrySet()) {
    System.out.println(e.getKey() + ":" + e.getValue());
}