往期回顾
目录
ArrayList 和 LinkedList 的区别是什么？
Java集合框架（Java Collections Framework, JCF）是Java中用于处理数据集合的一套标准接口和类。它提供了多种数据结构和算法，使得开发者可以高效地管理和操作数据。以下是Java集合框架的主要组成部分及其对应的数据结构、最佳实践和实战代码示例。
List 接口
数据结构
- ArrayList：基于动态数组实现，适合随机访问，插入和删除效率较低。
- LinkedList：基于双向链表实现，适合频繁的插入和删除操作。
- Vector：类似于
ArrayList，但线程安全（方法级别synchronized），性能较低。
最佳实践
- 随机访问：如果需要频繁进行随机访问操作，建议使用
ArrayList。 - 插入和删除：如果需要频繁进行插入和删除操作，建议使用
LinkedList。 - 线程安全：在多线程环境中，如果需要线程安全的
List，建议使用Vector或Collections.synchronizedList。 - 初始化容量：创建
ArrayList时，如果已知元素数量，可以指定初始容量以减少扩容次数，提高性能。
实战代码
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
public class ListExample {
public static void main(String[] args) {
// ArrayList 示例
List<String> arrayList = new ArrayList<>(10); // 初始化容量
arrayList.add("Apple");
arrayList.add("Banana");
System.out.println("ArrayList: " + arrayList);
// LinkedList 示例
List<String> linkedList = new LinkedList<>();
linkedList.add("Carrot");
linkedList.add("Date");
System.out.println("LinkedList: " + linkedList);
// Vector 示例
List<String> vector = new Vector<>();
vector.add("Eggplant");
vector.add("Fig");
System.out.println("Vector: " + vector);
// 遍历
for (String fruit : arrayList) {
System.out.println(fruit);
}
// 插入和删除
linkedList.add(0, "Grape");
linkedList.remove("Carrot");
System.out.println("Updated LinkedList: " + linkedList);
}
}Set 接口
数据结构
- HashSet：基于哈希表实现，提供快速的查找速度，不保证元素的顺序。
- TreeSet：基于红黑树实现，保持元素的自然排序或定制排序。
- LinkedHashSet：基于哈希表和链表实现，保持元素的插入顺序。
最佳实践
- 唯一性：如果需要确保元素的唯一性，建议使用
Set。 - 排序：如果需要保持元素的自然排序，建议使用
TreeSet。 - 插入顺序：如果需要保持元素的插入顺序，建议使用
LinkedHashSet。
实战代码
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetExample {
public static void main(String[] args) {
// HashSet 示例
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // 重复元素不会被添加
System.out.println("HashSet: " + hashSet);
// TreeSet 示例
Set<String> treeSet = new TreeSet<>();
treeSet.add("Carrot");
treeSet.add("Date");
treeSet.add("Apple");
System.out.println("TreeSet: " + treeSet); // 自然排序
// LinkedHashSet 示例
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("Eggplant");
linkedHashSet.add("Fig");
linkedHashSet.add("Grape");
System.out.println("LinkedHashSet: " + linkedHashSet); // 插入顺序
}
}Queue 接口
数据结构
- LinkedList：可以作为队列使用。
- PriorityQueue：基于优先级堆实现，元素按优先级排序。
- ArrayDeque：基于循环数组实现，性能优于
LinkedList。
最佳实践
- FIFO：如果需要实现先进先出（FIFO）的行为，建议使用
LinkedList或ArrayDeque。 - 优先级：如果需要按优先级处理元素，建议使用
PriorityQueue。
实战代码
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
public class QueueExample {
public static void main(String[] args) {
// LinkedList 作为队列
Queue<String> queue = new LinkedList<>();
queue.offer("Apple");
queue.offer("Banana");
System.out.println("Queue (LinkedList): " + queue);
System.out.println("Dequeue: " + queue.poll());
System.out.println("Queue after dequeue: " + queue);
// PriorityQueue 示例
Queue<String> priorityQueue = new PriorityQueue<>();
priorityQueue.offer("Carrot");
priorityQueue.offer("Apple");
priorityQueue.offer("Date");
System.out.println("PriorityQueue: " + priorityQueue);
System.out.println("Dequeue: " + priorityQueue.poll());
System.out.println("PriorityQueue after dequeue: " + priorityQueue);
}
}Map 接口
数据结构
- HashMap：基于哈希表实现，线程不安全。
- TreeMap：基于红黑树实现，保持键的自然排序或定制排序。
- LinkedHashMap：基于哈希表和链表实现，保持键值对的插入顺序。
- Hashtable：线程安全，性能稍差。
- ConcurrentHashMap：线程安全，性能较好。
最佳实践
- 线程安全：在多线程环境中，建议使用
ConcurrentHashMap。 - 排序：如果需要保持键的排序，建议使用
TreeMap。 - 插入顺序：如果需要保持键值对的插入顺序，建议使用
LinkedHashMap。 - 线程安全的Map：如果需要线程安全的
Map，可以使用Hashtable或Collections.synchronizedMap或ConcurrentHashMap。
实战代码
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
public class MapExample {
public static void main(String[] args) {
// HashMap 示例
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
System.out.println("HashMap: " + hashMap);
// TreeMap 示例
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Carrot", 3);
treeMap.put("Apple", 1);
treeMap.put("Date", 2);
System.out.println("TreeMap: " + treeMap); // 自然排序
// LinkedHashMap 示例
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Eggplant", 4);
linkedHashMap.put("Fig", 5);
linkedHashMap.put("Grape", 6);
System.out.println("LinkedHashMap: " + linkedHashMap); // 插入顺序
}
}Deque 接口
数据结构
- ArrayDeque：基于循环数组实现。
- LinkedList：可以作为双端队列使用。
最佳实践
- 双端操作：如果需要从两端进行插入和删除操作，建议使用
Deque。 - 性能：
ArrayDeque的性能通常优于LinkedList。
实战代码
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
public class DequeExample {
public static void main(String[] args) {
// ArrayDeque 示例
Deque<String> deque = new ArrayDeque<>();
deque.offerFirst("Apple");
deque.offerLast("Banana");
System.out.println("Deque (ArrayDeque): " + deque);
System.out.println("Poll First: " + deque.pollFirst());
System.out.println("Deque after poll first: " + deque);
// LinkedList 作为双端队列
Deque<String> linkedDeque = new LinkedList<>();
linkedDeque.offerFirst("Carrot");
linkedDeque.offerLast("Date");
System.out.println("Deque (LinkedList): " + linkedDeque);
System.out.println("Poll Last: " + linkedDeque.pollLast());
System.out.println("Deque after poll last: " + linkedDeque);
}
}最佳实践总结
- 选择合适的集合类型：根据具体需求选择最合适的集合类型，例如需要保持元素唯一性时选择
Set。 - 初始化集合大小：对于
ArrayList和HashMap等，如果已知元素数量，初始化时指定容量可以提高性能。 - 使用泛型：使用泛型定义集合类型，避免运行时类型错误。
- 使用迭代器：在遍历集合时使用迭代器，特别是在需要修改集合时。
- 清理不再使用的对象：及时从集合中移除不再需要的对象，帮助垃圾回收。
- 同步考虑：在多线程环境中使用线程安全的集合，如
ConcurrentHashMap。 - 利用集合工具类：使用
Collections类提供的静态方法来操作集合，简化代码。
常见面试题
Java集合框架是面试中经常涉及的话题，以下是常见的面试题及其答案，帮助你更好地准备面试。
什么是Java集合框架？
- 答案：Java集合框架是一组用于表示和操作集合的标准接口和类。它提供了多种数据结构（如列表、集合、映射等）和算法，使得开发者可以高效地管理和操作数据。
Java集合框架的主要接口有哪些？
- 答案：
List：有序集合，允许重复元素。Set：无序集合，不允许重复元素。Map：键值对集合，键唯一，值可以重复。Queue：队列，支持先进先出（FIFO）行为。Deque：双端队列，支持从两端进行插入和删除操作。
ArrayList 和 LinkedList 的区别是什么？
- 答案：
- 存储结构：
ArrayList：基于动态数组实现，适合随机访问，插入和删除效率较低。LinkedList：基于双向链表实现，适合频繁的插入和删除操作，随机访问效率较低。
- 线程安全：
ArrayList：线程不安全。LinkedList：线程不安全。
- 性能：
ArrayList：随机访问快，插入和删除慢。LinkedList：插入和删除快，随机访问慢。
- 存储结构：
HashMap 和 TreeMap 的区别是什么？
- 答案：
- 存储结构：
HashMap：基于哈希表实现，线程不安全，提供快速的查找速度，不保证元素的顺序。TreeMap：基于红黑树实现，保持键的自然排序或定制排序，性能略低于HashMap。
- 线程安全：
HashMap：线程不安全。TreeMap：线程不安全。
- 性能：
HashMap：平均时间复杂度为O(1)，适用于快速查找。TreeMap：时间复杂度为O(log n)，适用于需要排序的场景。
- 存储结构：
HashSet 和 TreeSet 的区别是什么？
- 答案：
- 存储结构：
HashSet：基于哈希表实现，提供快速的查找速度，不保证元素的顺序。TreeSet：基于红黑树实现，保持元素的自然排序或定制排序。
- 线程安全：
HashSet：线程不安全。TreeSet：线程不安全。
- 性能：
HashSet：平均时间复杂度为O(1)，适用于快速查找。TreeSet：时间复杂度为O(log n)，适用于需要排序的场景。
- 存储结构：
如何实现线程安全的集合？
- 答案：
- 使用线程安全的集合类，如
Vector、Hashtable、ConcurrentHashMap。 - 使用
Collections类提供的同步包装器方法，如Collections.synchronizedList、Collections.synchronizedMap。
- 使用线程安全的集合类，如
ArrayList 和 Vector 的区别是什么？
- 答案：
- 线程安全：
ArrayList：线程不安全。Vector：线程安全，性能较低。
- 性能：
ArrayList：性能较高，适合单线程环境。Vector：性能较低，适合多线程环境。
- 扩容机制：
ArrayList：默认扩容1.5倍。Vector：默认扩容2倍。
- 线程安全：
HashMap 的工作原理是什么？
- 答案：
HashMap内部使用一个数组来存储键值对。- 当插入或查找元素时，首先计算键的哈希码，然后通过哈希码确定数组的索引位置。
- 如果发生哈希冲突（多个键的哈希码相同），则使用链地址法（链表或红黑树）来解决冲突。
- 在Java 8及以后的版本中，当链表长度超过一定阈值（默认为8）时，链表会转换为红黑树，以提高查找效率。
HashSet 的工作原理是什么？
- 答案：
HashSet内部使用HashMap来实现。HashSet中的每个元素都作为一个键存储在HashMap中，值部分总是使用一个固定的对象（通常是PRESENT）。- 由于
HashMap提供了高效的查找和插入操作，HashSet也具有类似的性能特性。
TreeMap 和 TreeSet 的内部实现是什么？
- 答案：
TreeMap和TreeSet都基于红黑树实现。- 红黑树是一种自平衡二叉搜索树，能够在O(log n)时间内完成插入、删除和查找操作。
TreeMap保持键的自然排序或定制排序，TreeSet保持元素的自然排序或定制排序。
PriorityQueue 的工作原理是什么？
- 答案：
PriorityQueue是一个基于优先堆的无界优先队列。- 元素按照其自然顺序或通过提供的
Comparator进行排序。 - 插入和删除操作的时间复杂度为O(log n)，获取头部元素的时间复杂度为O(1)。
如何遍历一个集合？
- 答案：
- 使用
for-each循环。 - 使用
Iterator。 - 使用
StreamAPI（Java 8及以上版本）。
- 使用
什么是泛型？为什么使用泛型？
- 答案：
- 泛型是在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。
- 使用泛型可以避免运行时类型错误，提高代码的可读性和安全性。
List 和 Set 的主要区别是什么？
- 答案：
List：有序集合，允许重复元素，可以通过索引访问元素。Set：无序集合，不允许重复元素。
Queue 和 Deque 的主要区别是什么？
- 答案：
Queue：队列，支持先进先出（FIFO）行为。Deque：双端队列，支持从两端进行插入和删除操作。