Java数据结构详解：从基础到高级应用

1. Java数据结构概述

在软件开发中，数据结构的选择直接影响程序的性能和可维护性。Java作为一门成熟的编程语言，在java.util包中提供了丰富的数据结构实现，帮助开发者高效地组织和处理数据。这些数据结构可以分为线性结构（如数组、列表、队列）和非线性结构（如树、图）两大类，每种结构都有其特定的应用场景和性能特征。

提示：选择数据结构时，首先要明确数据的访问模式（随机访问还是顺序访问）、数据量大小以及是否需要排序等特性。

2. 线性数据结构详解

2.1 数组(Array)的实现与应用

数组是最基础的数据结构，Java中的数组具有以下特点：

java复制// 声明并初始化一个整型数组
int[] scores = new int[5]; 
// 直接初始化数组
String[] names = {"Alice", "Bob", "Charlie"};

数组在内存中是连续存储的，这使得它的随机访问时间复杂度为O(1)。但数组的大小一旦确定就不能改变，这是它的主要局限性。在实际开发中，数组常用于：

• 存储固定数量的元素
• 需要频繁随机访问的场景
• 作为其他复杂数据结构的基础

注意：数组越界是常见错误，访问数组元素时务必确保索引在0到length-1范围内。

2.2 动态数组实现：ArrayList

ArrayList是Java中最常用的动态数组实现，它解决了普通数组大小固定的问题：

java复制List<String> fruits = new ArrayList<>();
fruits.add("Apple");  // 添加元素
fruits.add(0, "Banana");  // 在指定位置插入
String first = fruits.get(0);  // 获取元素
fruits.remove(1);  // 删除元素

ArrayList内部使用Object数组存储数据，当容量不足时会自动扩容（通常增加50%）。这使得：

• 尾部添加元素平均时间复杂度为O(1)
• 随机访问保持O(1)复杂度
• 但在中间插入/删除元素需要移动后续元素，时间复杂度为O(n)

2.3 链表实现：LinkedList

LinkedList基于双向链表实现，特别适合频繁插入删除的场景：

java复制List<Integer> numbers = new LinkedList<>();
numbers.add(10);
numbers.addFirst(5);  // 头部插入
numbers.addLast(15);  // 尾部插入
int first = numbers.getFirst();  // 获取头部元素

LinkedList的每个元素（节点）都包含指向前后节点的引用，这使得：

• 在任意位置插入/删除元素时间复杂度为O(1)（如果已知位置）
• 但随机访问需要从头遍历，时间复杂度为O(n)
• 比ArrayList占用更多内存（每个元素需要存储前后指针）

3. 集合框架核心实现

3.1 HashSet原理与实现

HashSet是基于HashMap实现的集合，它使用哈希表来存储元素：

java复制Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Alice");  // 重复元素不会被添加
boolean exists = uniqueNames.contains("Bob");  // 检查存在性

HashSet的特点包括：

• 元素唯一性（基于equals()和hashCode()方法）
• 无序存储
• 添加、删除、查找操作平均时间复杂度为O(1)
• 性能受负载因子影响（默认0.75，当元素填满75%容量时会扩容）

3.2 TreeSet的有序特性

TreeSet基于红黑树实现，保持元素有序：

java复制Set<Integer> sortedNumbers = new TreeSet<>();
sortedNumbers.add(3);
sortedNumbers.add(1);
sortedNumbers.add(2);
// 元素将自动排序：[1, 2, 3]

TreeSet的特性：

• 元素按照自然顺序或Comparator指定的顺序排序
• 添加、删除、查找操作时间复杂度为O(log n)
• 提供了一系列有序操作如first(), last(), headSet(), tailSet()等

4. 键值对映射结构

4.1 HashMap的工作原理

HashMap是最常用的Map实现，基于哈希表+链表/红黑树：

java复制Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
int aliceAge = ageMap.get("Alice");  // 获取值
ageMap.remove("Bob");  // 删除键值对

HashMap的关键特性：

• 使用键的hashCode()确定存储位置
• Java 8后，当链表长度超过8时会转为红黑树
• 默认初始容量16，负载因子0.75
• 允许null键和null值
• 非线程安全

4.2 TreeMap的有序映射

TreeMap基于红黑树实现，保持键的有序性：

java复制Map<String, Integer> sortedMap = new TreeMap<>();
sortedMap.put("Orange", 2);
sortedMap.put("Apple", 5);
// 键将按字母顺序排列

TreeMap的特点：

• 键按照自然顺序或Comparator排序
• 查找、插入、删除操作时间复杂度O(log n)
• 提供了一系列有序视图方法如firstKey(), lastKey(), subMap()等

5. 栈与队列实现

5.1 Stack类的使用

Stack类实现后进先出(LIFO)结构：

java复制Stack<Integer> stack = new Stack<>();
stack.push(10);  // 压栈
stack.push(20);
int top = stack.peek();  // 查看栈顶元素(不移除)
int popped = stack.pop();  // 出栈

Stack的常用场景：

• 函数调用栈
• 表达式求值
• 括号匹配检查
• 回溯算法

5.2 Queue接口及其实现

Queue表示先进先出(FIFO)队列：

java复制Queue<String> queue = new LinkedList<>();
queue.offer("First");  // 入队
queue.offer("Second");
String head = queue.peek();  // 查看队首
String removed = queue.poll();  // 出队

Java中还提供了：

• PriorityQueue：优先级队列
• ArrayDeque：双端队列，可作为栈或队列使用
• BlockingQueue：线程安全的阻塞队列

6. 树与图结构实现

6.1 二叉树的Java实现

二叉树通常需要自定义节点类：

java复制class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

// 创建二叉树
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);

二叉树常用算法包括：

• 深度优先遍历（前序、中序、后序）
• 广度优先遍历
• 查找、插入、删除操作
• 平衡检查等

6.2 图的表示方法

Java标准库没有内置图结构，通常有以下实现方式：

1. 邻接矩阵：

java复制int[][] graph = new int[V][V];
graph[0][1] = 1;  // 0和1之间有边

2. 邻接表：

java复制List<List<Integer>> adjList = new ArrayList<>();
adjList.add(Arrays.asList(1, 2));  // 节点0的邻居
adjList.add(Arrays.asList(0, 2));  // 节点1的邻居

3. 使用第三方库如JGraphT

7. 遗留类与现代替代方案

7.1 Vector与ArrayList对比

Vector是线程安全的动态数组，但性能较低：

java复制Vector<String> vec = new Vector<>();
vec.add("Element");

与ArrayList的主要区别：

• Vector方法同步，线程安全
• ArrayList性能更好
• Vector有枚举器，ArrayList有迭代器
• 现代代码通常使用ArrayList+Collections.synchronizedList()替代Vector

7.2 Hashtable与HashMap

Hashtable是早期的键值对实现：

java复制Hashtable<String, Integer> table = new Hashtable<>();
table.put("key", 123);

与HashMap的主要区别：

• Hashtable线程安全
• HashMap性能更好
• Hashtable不允许null键值
• 现代代码通常使用HashMap+ConcurrentHashMap替代Hashtable

8. 数据结构选择指南

8.1 根据场景选择数据结构

选择数据结构时考虑以下因素：

1. 访问模式：

• 频繁随机访问：数组、ArrayList
• 顺序访问：LinkedList
• 键值查找：HashMap、TreeMap

2. 数据量：

• 小数据集：任何结构均可
• 大数据集：考虑O(1)或O(log n)复杂度的结构

3. 线程安全需求：

• 单线程：ArrayList、HashMap
• 多线程：Vector、ConcurrentHashMap

8.2 性能比较表

9. 实战经验与优化技巧

9.1 初始化容量优化

对于已知大小的集合，指定初始容量避免扩容开销：

java复制// 已知有1000个元素
List<String> list = new ArrayList<>(1000); 
Map<String, Integer> map = new HashMap<>(1024);

9.2 迭代器使用注意事项

使用迭代器时避免结构性修改：

java复制List<String> names = new ArrayList<>(Arrays.asList("A", "B", "C"));
Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    if (name.equals("B")) {
        it.remove();  // 正确方式
        // names.remove(name);  // 错误！会抛出ConcurrentModificationException
    }
}

9.3 线程安全替代方案

替代传统同步集合的现代方案：

1. 使用Collections工具类：

java复制List<String> syncList = Collections.synchronizedList(new ArrayList<>());

2. 使用java.util.concurrent包：

java复制ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> threadSafeList = new CopyOnWriteArrayList<>();

10. 常见问题排查

10.1 ConcurrentModificationException

这个异常通常发生在遍历集合时修改集合：

java复制List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if (s.equals("B")) {
        list.remove(s);  // 抛出异常
    }
}

解决方案：

1. 使用迭代器的remove()方法
2. 使用Java 8的removeIf()
3. 创建副本进行遍历

10.2 内存泄漏问题

集合可能引起内存泄漏的常见场景：

1. 使用HashMap作为缓存但从不清理
2. 在静态集合中存储对象引用
3. 监听器未正确移除

解决方法：

1. 使用WeakHashMap
2. 定期清理无用引用
3. 使用LRU缓存策略

10.3 性能调优技巧

提升集合性能的方法：

1. 为HashMap设置合理的初始容量和负载因子
2. 对频繁查询的ArrayList考虑排序后使用二分查找
3. 大量数据考虑使用原始类型特化集合（如Trove、Eclipse Collections）
4. 并行处理使用并行流或并发集合