零基础学Java：Java常用集合基础-CSDN博客

本文链接：https://blog.csdn.net/m0_61118741/article/details/141908902

现在立刻马上学！！！明日复明日明日何其多

部分源于整合如有错漏缺不懂之处欢迎留言！！！

1. ArrayList

特点：ArrayList 是一个动态数组，允许存储重复元素，适合频繁读取操作。
底层实现：基于动态数组，初始容量为 10。当元素数量超过当前容量时，ArrayList 会扩容，通常扩容为当前容量的 1.5 倍。
扩容机制：扩容时，创建一个更大的数组并将旧数组中的元素复制到新数组中。频繁的扩容可能会影响性能，因此在大数据量时建议提前设置合适的初始容量。

代码示例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        System.out.println("Fruits: " + fruits);

        // 扩容前容量
        System.out.println("Initial Capacity: " + ((ArrayList<String>) fruits).size());
        
        // 添加更多元素以触发扩容
        for (int i = 0; i < 15; i++) {
            fruits.add("Fruit" + i);
        }

        System.out.println("Fruits after expansion: " + fruits);
    }
}

练习：
- 编写一个程序，初始化一个 ArrayList 并添加 20 个整数元素，观察扩容过程。
- 修改初始容量，比较不同初始容量下的性能差异。

2. LinkedList

特点：LinkedList 是基于双向链表实现的集合，允许存储重复元素，插入和删除操作速度较快，适合频繁增删的场景。
底层实现：每个节点包含元素及指向前后节点的引用，遍历时需要从头到尾逐个节点查找，因此查找操作相对较慢。
扩容机制：LinkedList 不存在扩容问题，因为它基于链表结构，每次添加元素时，只需增加一个节点即可。

代码示例：

import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo {
    public static void main(String[] args) {
        List<String> fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        System.out.println("Fruits: " + fruits);

        // 添加元素到开头和末尾
        ((LinkedList<String>) fruits).addFirst("Strawberry");
        ((LinkedList<String>) fruits).addLast("Grapes");

        System.out.println("Fruits after additions: " + fruits);

        // 删除元素
        ((LinkedList<String>) fruits).removeFirst();
        ((LinkedList<String>) fruits).removeLast();

        System.out.println("Fruits after removals: " + fruits);
    }
}

练习：
- 实现一个队列结构，并使用 LinkedList 进行入队和出队操作。
- 对比 LinkedList 和 ArrayList 的增删操作性能，思考应用场景。

3. HashSet

特点：HashSet 是无序集合，不允许重复元素，基于哈希表实现，查找和插入速度较快。
底层实现：底层使用 HashMap 实现，每个元素作为 HashMap 的 key 存储，value 为固定的常量对象。哈希冲突时通过链表或红黑树解决。
扩容机制：初始容量为 16，负载因子为 0.75。达到 75% 的容量时，HashSet 会扩容为当前容量的 2 倍，并重新哈希所有元素。

代码示例：

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> items = new HashSet<>();
        items.add("A");
        items.add("B");
        items.add("C");
        items.add("A"); // 尝试添加重复元素

        System.out.println("Items: " + items);
    }
}

练习：
- 编写一个程序，读取用户输入的单词，并使用 HashSet 存储去重后的单词列表。
- 观察 HashSet 在插入大量元素后的性能表现，并比较扩容前后的内存使用情况。

4. TreeSet

特点：TreeSet 是有序集合，不允许重复元素，元素按自然顺序或自定义比较器排序，适合需要排序的集合场景。
底层实现：底层使用 TreeMap 实现，结构为红黑树。插入元素时，保持树的平衡性，确保数据的有序性和查找效率。
扩容机制：TreeSet 基于红黑树实现，不存在扩容问题，操作效率由树的高度决定。

代码示例：

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Integer> numbers = new TreeSet<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(9);
        numbers.add(1);

        System.out.println("Numbers (Sorted): " + numbers);
    }
}

练习：
- 使用 TreeSet 存储一组字符串，并按字母顺序排序。
- 对比 HashSet 和 TreeSet 的查找和插入性能，讨论各自的应用场景。

5. HashMap

特点：HashMap 是键值对集合，每个键最多只能对应一个值，允许 null 键和 null 值。
底层实现：基于哈希表实现，初始容量为 16，负载因子为 0.75。当键值对数量达到容量的 75% 时，HashMap 会扩容为当前容量的 2 倍，并重新哈希所有键值对。
扩容机制：扩容时，新建一个更大的哈希表，并将旧表中的所有键值对重新哈希到新表中。

代码示例：

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, String> capitals = new HashMap<>();
        capitals.put("USA", "Washington D.C.");
        capitals.put("UK", "London");
        capitals.put("France", "Paris");

        System.out.println("Capitals: " + capitals);

        // 访问和更新值
        capitals.put("France", "Lyon"); // 更新值
        System.out.println("Updated Capitals: " + capitals);
    }
}

练习：
- 编写一个程序，模拟字典功能，用户可以输入单词并获取对应的定义（提示：使用 HashMap）。
- 测试在大规模数据下 HashMap 的查找和插入性能，尝试调整初始容量和负载因子。

6. TreeMap

特点：TreeMap 是有序的键值对集合，键按自然顺序或自定义比较器排序，适合需要排序的场景。
底层实现：基于红黑树实现，每次插入元素时保持树的平衡性，确保键的有序性。
扩容机制：TreeMap 基于红黑树实现，不存在扩容问题，树的高度决定了操作效率。

代码示例：

import java.util.Map;
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        Map<String, String> capitals = new TreeMap<>();
        capitals.put("USA", "Washington D.C.");
        capitals.put("UK", "London");
        capitals.put("France", "Paris");

        System.out.println("Capitals (Sorted by Country): " + capitals);

        // 添加新国家和首都
        capitals.put("Germany", "Berlin");
        System.out.println("Updated Capitals: " + capitals);
    }
}