当前位置： 首页 > news >正文

【零碎小知识点 】（三）Java集合框架深入与实践

news 2025/9/2 19:41:22

Java集合框架深入与实践

下面我将提供详细的Java集合框架代码示例，涵盖List、Set、Map等核心接口及其实现类，并包含底层原理的模拟实现和高级用法。

1. List接口及其实现类

ArrayList 示例与原理模拟

import java.util.*;public class ListPractice {public static void main(String[] args) {// ArrayList - 基于动态数组List<String> arrayList = new ArrayList<>();// 添加元素arrayList.add("Java");arrayList.add("Python");arrayList.add("C++");arrayList.add(1, "JavaScript"); // 在指定位置插入System.out.println("ArrayList: " + arrayList);// 访问元素System.out.println("第一个元素: " + arrayList.get(0));System.out.println("包含Java吗? " + arrayList.contains("Java"));// 修改元素arrayList.set(2, "Go");System.out.println("修改后: " + arrayList);// 删除元素arrayList.remove("C++");arrayList.remove(0);System.out.println("删除后: " + arrayList);// 遍历System.out.println("=== 遍历ArrayList ===");// 1. for循环for (int i = 0; i < arrayList.size(); i++) {System.out.println("索引 " + i + ": " + arrayList.get(i));}// 2. 增强for循环for (String language : arrayList) {System.out.println("语言: " + language);}// 3. 迭代器Iterator<String> iterator = arrayList.iterator();while (iterator.hasNext()) {System.out.println("迭代器: " + iterator.next());}// 4. forEach方法 (Java 8+)arrayList.forEach(lang -> System.out.println("forEach: " + lang));// ArrayList扩容机制演示demonstrateArrayListResizing();// LinkedList - 基于双向链表List<String> linkedList = new LinkedList<>();linkedList.add("Apple");linkedList.add("Banana");linkedList.addFirst("Orange"); // 链表头部添加linkedList.addLast("Grape");   // 链表尾部添加System.out.println("LinkedList: " + linkedList);// LinkedList的特有方法LinkedList<String> ll = (LinkedList<String>) linkedList;System.out.println("第一个元素: " + ll.getFirst());System.out.println("最后一个元素: " + ll.getLast());ll.removeFirst();ll.removeLast();System.out.println("删除首尾后: " + ll);// Vector - 线程安全的ArrayList (已过时，不推荐使用)Vector<String> vector = new Vector<>();vector.add("Element1");vector.add("Element2");System.out.println("Vector: " + vector);}// 模拟ArrayList的扩容机制private static void demonstrateArrayListResizing() {System.out.println("\n=== ArrayList扩容机制演示 ===");// 创建一个初始容量为3的ArrayListList<Integer> list = new ArrayList<>(3);System.out.println("初始容量: 3");for (int i = 1; i <= 5; i++) {list.add(i);// 使用反射获取实际容量（仅供演示，生产环境不推荐）try {java.lang.reflect.Field field = ArrayList.class.getDeclaredField("elementData");field.setAccessible(true);Object[] elementData = (Object[]) field.get(list);System.out.println("添加元素 " + i + "后, 大小: " + list.size() + ", 容量: " + elementData.length);} catch (Exception e) {System.out.println("无法获取内部数组容量");}}}
}

自定义简化版ArrayList实现

// 自定义简化版ArrayList，理解底层数组实现
class MyArrayList<E> {private static final int DEFAULT_CAPACITY = 10;private Object[] elementData;private int size;public MyArrayList() {this.elementData = new Object[DEFAULT_CAPACITY];}public MyArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];} else {throw new IllegalArgumentException("初始容量必须大于0");}}public void add(E e) {// 确保容量足够ensureCapacityInternal(size + 1);elementData[size++] = e;}public void add(int index, E element) {checkRangeForAdd(index);ensureCapacityInternal(size + 1);// 将index及之后的元素向后移动一位System.arraycopy(elementData, index, elementData, index + 1, size - index);elementData[index] = element;size++;}@SuppressWarnings("unchecked")public E get(int index) {checkRange(index);return (E) elementData[index];}public E remove(int index) {checkRange(index);E oldValue = get(index);int numMoved = size - index - 1;if (numMoved > 0) {System.arraycopy(elementData, index + 1, elementData, index, numMoved);}elementData[--size] = null; // 帮助垃圾回收return oldValue;}public int size() {return size;}private void ensureCapacityInternal(int minCapacity) {if (minCapacity - elementData.length > 0) {grow(minCapacity);}}private void grow(int minCapacity) {int oldCapacity = elementData.length;// 新容量 = 旧容量 * 1.5int newCapacity = oldCapacity + (oldCapacity >> 1);if (newCapacity - minCapacity < 0) {newCapacity = minCapacity;}elementData = Arrays.copyOf(elementData, newCapacity);System.out.println("扩容: " + oldCapacity + " -> " + newCapacity);}private void checkRange(int index) {if (index >= size || index < 0) {throw new IndexOutOfBoundsException("索引: " + index + ", 大小: " + size);}}private void checkRangeForAdd(int index) {if (index > size || index < 0) {throw new IndexOutOfBoundsException("索引: " + index + ", 大小: " + size);}}@Overridepublic String toString() {if (size == 0) {return "[]";}StringBuilder sb = new StringBuilder();sb.append('[');for (int i = 0; i < size; i++) {sb.append(elementData[i]);if (i == size - 1) {sb.append(']');} else {sb.append(',').append(' ');}}return sb.toString();}
}public class CustomArrayListDemo {public static void main(String[] args) {MyArrayList<String> myList = new MyArrayList<>(3);myList.add("A");myList.add("B");myList.add("C");System.out.println("初始列表: " + myList);// 触发扩容myList.add("D");System.out.println("扩容后: " + myList);myList.add(2, "E");System.out.println("插入后: " + myList);myList.remove(1);System.out.println("删除后: " + myList);System.out.println("索引2的元素: " + myList.get(2));}
}

2. Set接口及其实现类

import java.util.*;public class SetPractice {public static void main(String[] args) {// HashSet - 基于HashMap，无序Set<String> hashSet = new HashSet<>();hashSet.add("Apple");hashSet.add("Banana");hashSet.add("Orange");hashSet.add("Apple"); // 重复元素，不会被添加System.out.println("HashSet: " + hashSet);System.out.println("包含Apple? " + hashSet.contains("Apple"));// 遍历HashSetSystem.out.println("=== 遍历HashSet ===");for (String fruit : hashSet) {System.out.println(fruit);}// LinkedHashSet - 维护插入顺序Set<String> linkedHashSet = new LinkedHashSet<>();linkedHashSet.add("First");linkedHashSet.add("Second");linkedHashSet.add("Third");linkedHashSet.add("First"); // 重复System.out.println("LinkedHashSet: " + linkedHashSet);// TreeSet - 基于TreeMap，有序Set<String> treeSet = new TreeSet<>();treeSet.add("Orange");treeSet.add("Apple");treeSet.add("Banana");System.out.println("TreeSet(自然排序): " + treeSet);// 自定义排序Set<String> reverseTreeSet = new TreeSet<>(Comparator.reverseOrder());reverseTreeSet.add("Orange");reverseTreeSet.add("Apple");reverseTreeSet.add("Banana");System.out.println("TreeSet(逆序): " + reverseTreeSet);// 对象去重示例demonstrateObjectDeduplication();}// 演示对象如何正确实现去重private static void demonstrateObjectDeduplication() {System.out.println("\n=== 对象去重演示 ===");// 未正确实现equals和hashCode的类Set<BadStudent> badStudents = new HashSet<>();badStudents.add(new BadStudent(1, "Alice"));badStudents.add(new BadStudent(1, "Alice")); // 应该去重但不会System.out.println("BadStudent去重失败: " + badStudents.size());// 正确实现equals和hashCode的类Set<GoodStudent> goodStudents = new HashSet<>();goodStudents.add(new GoodStudent(1, "Alice"));goodStudents.add(new GoodStudent(1, "Alice")); // 成功去重System.out.println("GoodStudent成功去重: " + goodStudents.size());}
}// 未正确实现equals和hashCode的类
class BadStudent {private int id;private String name;public BadStudent(int id, String name) {this.id = id;this.name = name;}// 缺少equals和hashCode方法
}// 正确实现equals和hashCode的类
class GoodStudent {private int id;private String name;public GoodStudent(int id, String name) {this.id = id;this.name = name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;GoodStudent that = (GoodStudent) o;return id == that.id && Objects.equals(name, that.name);}@Overridepublic int hashCode() {return Objects.hash(id, name);}
}

3. Map接口及其实现类

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;public class MapPractice {public static void main(String[] args) {// HashMap - 最常用的Map实现Map<String, Integer> hashMap = new HashMap<>();// 添加键值对hashMap.put("Apple", 10);hashMap.put("Banana", 5);hashMap.put("Orange", 8);hashMap.put("Apple", 15); // 更新已有键的值System.out.println("HashMap: " + hashMap);// 访问值System.out.println("Apple的数量: " + hashMap.get("Apple"));System.out.println("包含Banana键? " + hashMap.containsKey("Banana"));System.out.println("包含值10? " + hashMap.containsValue(10));// 遍历HashMapSystem.out.println("=== 遍历HashMap ===");// 1. 遍历键for (String key : hashMap.keySet()) {System.out.println("Key: " + key + ", Value: " + hashMap.get(key));}// 2. 遍历值for (Integer value : hashMap.values()) {System.out.println("Value: " + value);}// 3. 遍历键值对for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {System.out.println("Entry: " + entry.getKey() + " => " + entry.getValue());}// 4. forEach方法 (Java 8+)hashMap.forEach((k, v) -> System.out.println("ForEach: " + k + " => " + v));// LinkedHashMap - 维护插入顺序Map<String, Integer> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("Zebra", 1);linkedHashMap.put("Apple", 2);linkedHashMap.put("Banana", 3);System.out.println("LinkedHashMap(插入顺序): " + linkedHashMap);// 访问顺序的LinkedHashMap (LRU缓存基础)Map<String, Integer> accessOrderMap = new LinkedHashMap<>(16, 0.75f, true);accessOrderMap.put("A", 1);accessOrderMap.put("B", 2);accessOrderMap.put("C", 3);// 访问元素B，它会被移动到末尾accessOrderMap.get("B");System.out.println("访问顺序LinkedHashMap: " + accessOrderMap);// TreeMap - 基于红黑树，按键排序Map<String, Integer> treeMap = new TreeMap<>();treeMap.put("Orange", 3);treeMap.put("Apple", 1);treeMap.put("Banana", 2);System.out.println("TreeMap(按键排序): " + treeMap);// 自定义排序Map<String, Integer> reverseTreeMap = new TreeMap<>(Comparator.reverseOrder());reverseTreeMap.put("Orange", 3);reverseTreeMap.put("Apple", 1);reverseTreeMap.put("Banana", 2);System.out.println("TreeMap(逆序): " + reverseTreeMap);// ConcurrentHashMap - 线程安全的HashMapMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();concurrentMap.put("A", 1);concurrentMap.put("B", 2);concurrentMap.put("C", 3);System.out.println("ConcurrentHashMap: " + concurrentMap);// HashMap原理演示demonstrateHashMapMechanism();}// 演示HashMap的工作原理private static void demonstrateHashMapMechanism() {System.out.println("\n=== HashMap原理演示 ===");// 创建一个小的HashMap以便观察Map<String, Integer> smallMap = new HashMap<>(4);// 添加一些元素，观察哈希冲突smallMap.put("Aa", 1); // "Aa"和"BB"有相同的哈希值smallMap.put("BB", 2);smallMap.put("CC", 3);smallMap.put("DD", 4);System.out.println("小HashMap: " + smallMap);// 使用反射查看内部结构（仅供教学，生产环境不推荐）try {java.lang.reflect.Field tableField = HashMap.class.getDeclaredField("table");tableField.setAccessible(true);Object[] table = (Object[]) tableField.get(smallMap);if (table != null) {System.out.println("哈希表长度: " + table.length);for (int i = 0; i < table.length; i++) {if (table[i] != null) {System.out.println("桶 " + i + ": 有元素");// 遍历链表/树java.lang.reflect.Field nextField = table[i].getClass().getDeclaredField("next");nextField.setAccessible(true);Object node = table[i];int chainLength = 0;while (node != null) {chainLength++;// 获取键和值java.lang.reflect.Field keyField = node.getClass().getDeclaredField("key");keyField.setAccessible(true);Object key = keyField.get(node);java.lang.reflect.Field valueField = node.getClass().getDeclaredField("value");valueField.setAccessible(true);Object value = valueField.get(node);System.out.println("  链节点 " + chainLength + ": " + key + "=" + value);node = nextField.get(node);}if (chainLength > 1) {System.out.println("  哈希冲突! 链长度: " + chainLength);}}}}} catch (Exception e) {System.out.println("无法查看HashMap内部结构: " + e.getMessage());}}
}

自定义简化版HashMap实现

// 自定义简化版HashMap，理解底层实现
class MyHashMap<K, V> {private static final int DEFAULT_CAPACITY = 16;private static final float DEFAULT_LOAD_FACTOR = 0.75f;static class Node<K, V> {final K key;V value;Node<K, V> next;final int hash;Node(int hash, K key, V value, Node<K, V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;}}private Node<K, V>[] table;private int size;private int threshold;private final float loadFactor;@SuppressWarnings("unchecked")public MyHashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR;this.table = (Node<K, V>[]) new Node[DEFAULT_CAPACITY];this.threshold = (int) (DEFAULT_CAPACITY * DEFAULT_LOAD_FACTOR);}public V put(K key, V value) {int hash = hash(key);int index = (table.length - 1) & hash;// 检查是否已存在该键Node<K, V> node = table[index];while (node != null) {if (node.hash == hash && (node.key == key || (key != null && key.equals(node.key)))) {V oldValue = node.value;node.value = value;return oldValue;}node = node.next;}// 添加新节点addNode(hash, key, value, index);return null;}private void addNode(int hash, K key, V value, int index) {Node<K, V> newNode = new Node<>(hash, key, value, table[index]);table[index] = newNode;if (++size > threshold) {resize();}}public V get(K key) {int hash = hash(key);int index = (table.length - 1) & hash;Node<K, V> node = table[index];while (node != null) {if (node.hash == hash && (node.key == key || (key != null && key.equals(node.key)))) {return node.value;}node = node.next;}return null;}@SuppressWarnings("unchecked")private void resize() {System.out.println("HashMap扩容: " + table.length + " -> " + (table.length * 2));int newCapacity = table.length * 2;threshold = (int) (newCapacity * loadFactor);Node<K, V>[] newTable = (Node<K, V>[]) new Node[newCapacity];// 重新哈希所有节点for (Node<K, V> head : table) {while (head != null) {Node<K, V> next = head.next;int newIndex = (newCapacity - 1) & head.hash;head.next = newTable[newIndex];newTable[newIndex] = head;head = next;}}table = newTable;}private int hash(K key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}public int size() {return size;}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();sb.append('{');for (int i = 0; i < table.length; i++) {Node<K, V> node = table[i];while (node != null) {sb.append(node.key).append('=').append(node.value).append(',');node = node.next;}}if (sb.length() > 1) {sb.setLength(sb.length() - 1); // 移除最后一个逗号}sb.append('}');return sb.toString();}
}public class CustomHashMapDemo {public static void main(String[] args) {MyHashMap<String, Integer> myMap = new MyHashMap<>();myMap.put("Apple", 10);myMap.put("Banana", 5);myMap.put("Orange", 8);myMap.put("Apple", 15); // 更新System.out.println("自定义HashMap: " + myMap);System.out.println("获取Apple: " + myMap.get("Apple"));System.out.println("大小: " + myMap.size());// 触发扩容for (int i = 0; i < 20; i++) {myMap.put("Key" + i, i);}System.out.println("扩容后: " + myMap);System.out.println("大小: " + myMap.size());}
}

4. Collections工具类

import java.util.*;public class CollectionsPractice {public static void main(String[] args) {List<Integer> numbers = new ArrayList<>();numbers.add(5);numbers.add(2);numbers.add(8);numbers.add(1);numbers.add(9);System.out.println("原始列表: " + numbers);// 排序Collections.sort(numbers);System.out.println("排序后: " + numbers);// 逆序Collections.reverse(numbers);System.out.println("逆序后: " + numbers);// 随机排序Collections.shuffle(numbers);System.out.println("随机排序后: " + numbers);// 二分查找 (需要先排序)Collections.sort(numbers);int index = Collections.binarySearch(numbers, 5);System.out.println("5的索引: " + index);// 最大值和最小值System.out.println("最大值: " + Collections.max(numbers));System.out.println("最小值: " + Collections.min(numbers));// 填充Collections.fill(numbers, 0);System.out.println("填充后: " + numbers);// 创建线程安全的集合List<String> syncList = Collections.synchronizedList(new ArrayList<>());Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());// 不可修改的集合List<String> unmodifiableList = Collections.unmodifiableList(Arrays.asList("A", "B", "C"));Set<String> unmodifiableSet = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("A", "B", "C")));Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(new HashMap<String, Integer>() {{put("A", 1);put("B", 2);}});// 尝试修改会抛出UnsupportedOperationExceptiontry {unmodifiableList.add("D");} catch (UnsupportedOperationException e) {System.out.println("不能修改不可修改集合: " + e.getMessage());}// 单元素集合List<String> singletonList = Collections.singletonList("OnlyOne");Set<String> singletonSet = Collections.singleton("OnlyOne");Map<String, Integer> singletonMap = Collections.singletonMap("key", 1);System.out.println("单元素列表: " + singletonList);System.out.println("单元素集合: " + singletonSet);System.out.println("单元素映射: " + singletonMap);}
}

5. 综合练习与应用

import java.util.*;public class CollectionExercises {public static void main(String[] args) {// 练习1: 统计单词频率String text = "java is a programming language java is widely used java is popular";Map<String, Integer> wordFrequency = countWordFrequency(text);System.out.println("单词频率: " + wordFrequency);// 练习2: 找出两个列表的共同元素List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);List<Integer> list2 = Arrays.asList(4, 5, 6, 7, 8);List<Integer> commonElements = findCommonElements(list1, list2);System.out.println("共同元素: " + commonElements);// 练习3: 实现LRU缓存LRUCache<Integer, String> lruCache = new LRUCache<>(3);lruCache.put(1, "A");lruCache.put(2, "B");lruCache.put(3, "C");System.out.println("初始缓存: " + lruCache);lruCache.get(1); // 访问1，使其成为最近使用的lruCache.put(4, "D"); // 添加新元素，应该淘汰最久未使用的2System.out.println("添加第四个元素后: " + lruCache);// 练习4: 对学生按成绩排序List<Student> students = new ArrayList<>();students.add(new Student("Alice", 85));students.add(new Student("Bob", 92));students.add(new Student("Charlie", 78));students.add(new Student("Diana", 92)); // 相同成绩// 按成绩降序，成绩相同按姓名升序students.sort((s1, s2) -> {int scoreCompare = Integer.compare(s2.score, s1.score); // 降序if (scoreCompare != 0) {return scoreCompare;}return s1.name.compareTo(s2.name); // 升序});System.out.println("按成绩排序的学生:");students.forEach(System.out::println);}// 统计文本中单词频率public static Map<String, Integer> countWordFrequency(String text) {Map<String, Integer> frequencyMap = new HashMap<>();String[] words = text.split("\\s+");for (String word : words) {frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);}return frequencyMap;}// 找出两个列表的共同元素public static List<Integer> findCommonElements(List<Integer> list1, List<Integer> list2) {Set<Integer> set1 = new HashSet<>(list1);Set<Integer> commonSet = new HashSet<>();for (Integer num : list2) {if (set1.contains(num)) {commonSet.add(num);}}return new ArrayList<>(commonSet);}
}// 简单的LRU缓存实现
class LRUCache<K, V> extends LinkedHashMap<K, V> {private final int capacity;public LRUCache(int capacity) {super(capacity, 0.75f, true);this.capacity = capacity;}@Overrideprotected boolean removeEldestEntry(Map.Entry<K, V> eldest) {return size() > capacity;}
}// 学生类
class Student {String name;int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return name + ":" + score;}
}

6. 性能比较与最佳实践

import java.util.*;public class PerformanceComparison {public static void main(String[] args) {final int SIZE = 100000;// ArrayList vs LinkedList 性能比较List<Integer> arrayList = new ArrayList<>();List<Integer> linkedList = new LinkedList<>();// 添加元素性能long startTime = System.nanoTime();for (int i = 0; i < SIZE; i++) {arrayList.add(i);}long arrayListAddTime = System.nanoTime() - startTime;startTime = System.nanoTime();for (int i = 0; i < SIZE; i++) {linkedList.add(i);}long linkedListAddTime = System.nanoTime() - startTime;System.out.println("添加" + SIZE + "个元素:");System.out.println("ArrayList: " + arrayListAddTime / 1000000 + "ms");System.out.println("LinkedList: " + linkedListAddTime / 1000000 + "ms");// 随机访问性能startTime = System.nanoTime();for (int i = 0; i < 1000; i++) {arrayList.get(SIZE / 2);}long arrayListAccessTime = System.nanoTime() - startTime;startTime = System.nanoTime();for (int i = 0; i < 1000; i++) {linkedList.get(SIZE / 2);}long linkedListAccessTime = System.nanoTime() - startTime;System.out.println("\n随机访问中间元素1000次:");System.out.println("ArrayList: " + arrayListAccessTime / 1000 + "μs");System.out.println("LinkedList: " + linkedListAccessTime / 1000 + "μs");// HashMap vs TreeMap 性能比较Map<Integer, String> hashMap = new HashMap<>();Map<Integer, String> treeMap = new TreeMap<>();// 添加性能startTime = System.nanoTime();for (int i = 0; i < SIZE; i++) {hashMap.put(i, "Value" + i);}long hashMapPutTime = System.nanoTime() - startTime;startTime = System.nanoTime();for (int i = 0; i < SIZE; i++) {treeMap.put(i, "Value" + i);}long treeMapPutTime = System.nanoTime() - startTime;System.out.println("\n添加" + SIZE + "个元素到Map:");System.out.println("HashMap: " + hashMapPutTime / 1000000 + "ms");System.out.println("TreeMap: " + treeMapPutTime / 1000000 + "ms");// 查找性能startTime = System.nanoTime();for (int i = 0; i < 1000; i++) {hashMap.get(i);}long hashMapGetTime = System.nanoTime() - startTime;startTime = System.nanoTime();for (int i = 0; i < 1000; i++) {treeMap.get(i);}long treeMapGetTime = System.nanoTime() - startTime;System.out.println("\n查找1000个元素:");System.out.println("HashMap: " + hashMapGetTime / 1000 + "μs");System.out.println("TreeMap: " + treeMapGetTime / 1000 + "μs");// 最佳实践总结System.out.println("\n=== 集合选择最佳实践 ===");System.out.println("1. 需要快速随机访问 → ArrayList");System.out.println("2. 需要频繁在中间插入/删除 → LinkedList");System.out.println("3. 需要快速查找/去重 → HashSet/HashMap");System.out.println("4. 需要有序遍历 → TreeSet/TreeMap 或 LinkedHashSet/LinkedHashMap");System.out.println("5. 需要维护插入顺序 → LinkedHashSet/LinkedHashMap");System.out.println("6. 多线程环境 → ConcurrentHashMap, Collections.synchronizedXXX, 或CopyOnWriteArrayList");}
}

这些代码示例涵盖了Java集合框架的核心概念，从基本使用到高级特性，再到性能优化和最佳实践。通过学习和实践这些示例，你将能够：

  1. 理解各种集合类的特性和适用场景
  2. 掌握集合的常见操作和遍历方式
  3. 了解集合的底层实现原理
  4. 学会如何选择合适的集合类解决实际问题
  5. 理解集合的性能特性和优化方法

建议你不仅运行这些代码，还要尝试修改它们，创建自己的变体，并解决实际问题来加深理解。集合框架是Java编程的核心组成部分，熟练掌握它们对你的编程能力提升至关重要。

http://www.dtcms.com/a/362370.html

相关文章：

  • Vue基础知识-使用监视属性watch和计算属性computed实现列表过滤+排序
  • 【数据可视化-104】安徽省2025年上半年GDP数据可视化分析：用Python和Pyecharts打造炫酷大屏
  • 【期末复习】--软件工程
  • 基于单片机智能按摩器设计
  • IOS打包上传 出现 You do not have required contracts to perform an operation 的解决办法
  • WEEX：从某DEX代币暴涨看加密交易选择
  • 基于SpringBoot音乐翻唱平台
  • 基于FPGA+DSP数据采集处理平台的搭建
  • Docker的应用
  • OpenCV 实战：图像模板匹配与旋转处理实现教程
  • C++精选面试题集合(100份大厂面经提取的200+道真题)
  • Android入门到实战（六）：Android主流图片加载框架
  • ANTD-TABLE表格字段明细展示
  • （Redis）Redis 分布式锁及改进策略详解
  • UE5 为啥原生的NotifyState写逻辑会有问题
  • Java异常处理详解：掌握try-catch-finally与try-with-resources，避开空指针等踩坑点
  • 20250901的学习笔记
  • 全栈智算系列直播回顾 | 智算中心对网络的需求与应对策略（下）
  • 【LeetCode】3670. 没有公共位的整数最大乘积 (SOSDP)
  • 笔记：人工神经网络
  • Vue基础知识-Vue中:class与:style动态绑定样式
  • DiffusionGPT-LLM驱动的文本生成图像系统
  • OpenStack网络类型解析
  • Markdown 语法全面指南
  • EXPLAIN 和 EXPLAIN ANALYZE
  • 【AI报表】JimuReport 积木报表 v2.1.3 版本发布，免费可视化报表和大屏
  • Python 爬虫案例：爬取豆瓣电影 Top250 数据
  • 【开题答辩全过程】以 基于SSM的高校疫情防控管理系统为例，包含答辩的问题和答案
  • docker中的命令（六）
  • 轻量实现 OCPP 1.6 JSON 协议（欧洲版）的充电桩调试平台