Java 常用数据结构详解

一、线性数据结构

1. 数组 (Array)

• 特点：连续内存空间，固定长度，通过索引快速访问。
• 使用场景：数据量固定且需要频繁随机访问。
• 示例：

  int[] arr = new int[5]; 
  arr[0] = 10; // O(1)访问
  

2. ArrayList

• 特点：基于动态数组实现，自动扩容，线程不安全。
• 时间复杂度：
  • 查询：O(1)
  • 插入/删除：末尾 O(1)，中间 O(n)
• 示例：

  List<String> list = new ArrayList<>();
  list.add("Java"); // 添加元素
  list.get(0);      // 获取元素
  

3. LinkedList

• 特点：双向链表实现，内存不连续，支持快速插入/删除。
• 时间复杂度：
  • 查询：O(n)
  • 插入/删除：头部/尾部 O(1)，中间 O(n)
• 示例：

  LinkedList<Integer> linkedList = new LinkedList<>();
  linkedList.addFirst(1); // 头部插入
  linkedList.removeLast(); // 尾部删除
  

---

二、集合框架 (Collection)

1. HashSet

• 特点：基于 HashMap 实现，无序，元素唯一。
• 时间复杂度：插入、删除、查找均为 O(1)。
• 示例：

  Set<String> set = new HashSet<>();
  set.add("A");
  set.contains("A"); // 判断存在性
  

2. TreeSet

• 特点：基于红黑树实现，元素有序（自然顺序或自定义排序）。
• 时间复杂度：插入、删除、查找均为 O(log n)。
• 示例：

  TreeSet<Integer> treeSet = new TreeSet<>();
  treeSet.add(3);
  treeSet.first(); // 最小元素
  

3. LinkedHashSet

• 特点：继承 HashSet，维护插入顺序的链表。
• 时间复杂度：与 HashSet 相同。
• 示例：

  Set<String> linkedHashSet = new LinkedHashSet<>();
  linkedHashSet.add("B");
  linkedHashSet.add("A"); // 保持插入顺序
  

---

三、映射结构 (Map)

1. HashMap

• 特点：数组+链表/红黑树，键唯一，允许 null 键/值，线程不安全。
• 时间复杂度：插入、删除、查找 O(1)（理想情况下）。
• 示例：

  Map<String, Integer> map = new HashMap<>();
  map.put("Key", 100);
  map.get("Key"); // 获取值
  

2. LinkedHashMap

• 特点：继承 HashMap，维护插入顺序或访问顺序。
• 使用场景：需要有序的键值对（如 LRU 缓存）。
• 示例：

  LinkedHashMap<String, Integer> linkedMap = new LinkedHashMap<>();
  linkedMap.put("A", 1);
  linkedMap.get("A"); // 保持插入顺序
  

3. TreeMap

• 特点：基于红黑树，键有序（自然顺序或自定义 Comparator）。
• 时间复杂度：插入、删除、查找 O(log n)。
• 示例：

  TreeMap<String, Integer> treeMap = new TreeMap<>();
  treeMap.put("Z", 26);
  treeMap.firstKey(); // 最小键
  

4. ConcurrentHashMap

• 特点：线程安全的 HashMap，分段锁提高并发性能。
• 使用场景：高并发环境下的键值存储。
• 示例：

  ConcurrentHashMap<String, String> concurrentMap = new ConcurrentHashMap<>();
  concurrentMap.put("K", "V");
  

---

四、队列与栈

1. Queue 接口

• 实现类：LinkedList、PriorityQueue、ArrayDeque。
• 常用方法：
  • add()/offer()：入队
  • remove()/poll()：出队
  • element()/peek()：查看队首
• 示例：

  Queue<Integer> queue = new LinkedList<>();
  queue.offer(1); // 入队
  queue.poll();    // 出队
  

2. PriorityQueue

• 特点：基于堆实现，元素按优先级排序。
• 时间复杂度：插入/删除 O(log n)。
• 示例：

  PriorityQueue<Integer> pq = new PriorityQueue<>();
  pq.offer(5);
  pq.poll(); // 取出最小元素
  

3. 栈 (Stack)

• 实现类：官方推荐使用 Deque 替代 Stack 类。
• 示例：

  Deque<Integer> stack = new ArrayDeque<>();
  stack.push(1); // 压栈
  stack.pop();   // 弹栈
  

---

五、性能对比与选择指南

数据结构	特点	适用场景
ArrayList	快速随机访问，增删慢	频繁查询，数据量固定或变化小
LinkedList	增删快，查询慢	频繁插入/删除，实现队列/栈
HashMap	快速键值存取，无序	高频键值操作，无需顺序
TreeMap	键有序，速度较慢	需要排序或范围查询
HashSet	快速去重，无序	元素唯一性校验
ConcurrentHashMap	线程安全，高并发	多线程环境下的共享Map

---

六、注意事项

1. 线程安全：

   • 单线程环境：优先使用 ArrayList、HashMap。
   • 多线程环境：使用 ConcurrentHashMap、CopyOnWriteArrayList。

2. 遍历安全：

   • 使用迭代器时避免直接修改集合（ConcurrentModificationException）。

3. 初始容量：

   • 对 ArrayList、HashMap 等预设初始容量（如 new ArrayList<>(100)）避免频繁扩容。