Java集合——1.Java集合简介

目录

• Java集合
  • • 为什么需要集合框架？
  • Java集合框架的体系结构
    • 1. List：有序可重复的列表
    • 2. Set：无序不可重复的集合
    • 3. Map：键值对映射表
  • 集合框架的设计特点
    • 1. 接口与实现分离
    • 2. 泛型支持
    • 3. 统一的遍历方式
  • 应避免使用的遗留集合类
  • 集合框架的应用场景
  • 总结

---

Java集合

为什么需要集合框架？

数组作为最基本的集合形式，存在以下局限性：

• 固定大小：初始化后长度不可改变，无法动态调整
• 操作繁琐：添加、删除元素需要手动移动其他元素
• 功能单一：缺乏排序、查找等常用操作的内置支持

集合框架解决了这些问题，提供了：

• 动态大小：自动调整容量以适应元素数量变化
• 丰富操作：内置添加、删除、查找、排序等方法
• 多种实现：针对不同场景提供多种数据结构选择
• 类型安全：通过泛型支持编译时类型检查

Java集合框架的体系结构

Java集合框架主要包含三大类核心接口，它们分别对应不同的数据结构：

1. List：有序可重复的列表

List接口代表有序、可重复的集合，元素可以通过索引访问，类似于动态数组。常用实现类包括：

• ArrayList：基于动态数组实现，随机访问效率高
• LinkedList：基于双向链表实现，插入和删除效率高

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

public class ListExample {
    public static void main(String[] args) {
        // 创建只能存储String类型的List
        List<String> fruits = new ArrayList<>();

        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");
        fruits.add("苹果"); // 允许重复元素

        // 按索引访问
        System.out.println("第一个元素：" + fruits.get(0));

        // 遍历元素
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 修改元素
        fruits.set(1, "葡萄");

        // 删除元素
        fruits.remove(2);

        System.out.println("修改后的数据：" + fruits);
    }
}

2. Set：无序不可重复的集合

Set接口代表无序、不可重复的集合，适合存储需要去重的数据。常用实现类包括：

• HashSet：基于哈希表实现，查找效率高
• TreeSet：基于红黑树实现，元素自动排序
• LinkedHashSet：继承自HashSet，保留插入顺序

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

public class SetExample {
    public static void main(String[] args) {
        // 创建只能存储Integer类型的Set
        Set<Integer> numbers = new HashSet<>();

        // 添加元素
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(20); // 重复元素，不会被添加

        // 遍历元素（无序）
        for (int num : numbers) {
            System.out.println(num);
        }

        // 检查元素是否存在
        System.out.println("是否包含20：" + numbers.contains(20));

        // 删除元素
        numbers.remove(30);

        System.out.println("修改后的数据：" + numbers);
    }
}

3. Map：键值对映射表

Map接口代表键值对（key-value）的集合，允许通过键快速查找值。常用实现类包括：

• HashMap：基于哈希表实现，查找效率高
• TreeMap：基于红黑树实现，键自动排序
• LinkedHashMap：保留键的插入顺序

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

public class MapExample {
    public static void main(String[] args) {
        // 创建键为String类型，值为Integer类型的Map
        Map<String, Integer> scores = new HashMap<>();

        // 添加键值对
        scores.put("张三", 90);
        scores.put("李四", 85);
        scores.put("王五", 95);
        scores.put("张三", 88); // 相同键会覆盖原有值

        // 通过键获取值
        System.out.println("李四的分数：" + scores.get("李四"));

        // 遍历键值对
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + "：" + entry.getValue());
        }

        // 检查键是否存在
        System.out.println("是否包含王五：" + scores.containsKey("王五"));

        // 删除键值对
        scores.remove("王五");

        System.out.println("修改后的数据：" + scores);
    }
}

Map的特点：

• 元素以键值对形式存在
• 键（key）不允许重复，值（value）可以重复
• 支持通过键快速查找值（O(1)时间复杂度 for HashMap）

集合框架的设计特点

Java集合框架的设计体现了面向对象的优秀思想，主要有以下特点：

1. 接口与实现分离

集合框架采用"接口-实现"的分离设计：

• 接口（如List、Set、Map）定义了集合的行为规范
• 实现类（如ArrayList、HashSet、HashMap）提供具体实现

// 面向接口编程，可轻松替换为其他实现
List<String> list = new ArrayList<>();
// List<String> list = new LinkedList<>(); // 只需修改实现类

2. 泛型支持

集合框架全面支持泛型，允许指定集合中元素的类型：

• 编译时检查元素类型，避免类型转换错误
• 无需手动类型转换，代码更简洁安全

// 声明只能存储String类型的集合
List<String> strList = new ArrayList<>();
strList.add("hello"); // 正确
// strList.add(123); // 编译错误，不允许添加整数

3. 统一的遍历方式

所有集合都可以通过迭代器（Iterator）进行遍历，提供了统一的访问方式：

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("Python");
        languages.add("C++");

        // 使用迭代器遍历
        Iterator<String> iterator = languages.iterator();
        while (iterator.hasNext()) {
            String lang = iterator.next();
            System.out.println(lang);
            // 可以安全删除元素
            if (lang.equals("C++")) {
                iterator.remove();
            }
        }

        System.out.println("删除后：" + languages);
    }
}

对于List和Set，还可以使用增强for循环（foreach）简化遍历：

for (String lang : languages) {
    System.out.println(lang);
}

应避免使用的遗留集合类

Java集合框架经过多年发展，一些早期的集合类已被更优的实现取代，应避免在新代码中使用：

遗留类/接口	替代方案	说明
Hashtable	HashMap	线程安全的Map，性能较差
Vector	ArrayList	线程安全的List，性能较差
Stack	Deque	基于Vector实现的栈，推荐使用ArrayDeque
Enumeration	Iterator	迭代器接口，功能被Iterator替代

这些遗留类主要存在性能问题或设计缺陷，现代Java程序应优先使用新的集合实现。

集合框架的应用场景

选择合适的集合类型对程序性能至关重要，以下是常见场景的选择建议：

• 需要按索引访问元素：选择List，随机访问频繁用ArrayList，插入删除频繁用LinkedList
• 需要存储不重复的元素：选择Set，无序用HashSet，排序用TreeSet，需保留顺序用LinkedHashSet
• 需要通过键查找值：选择Map，一般情况用HashMap，需要排序用TreeMap
• 需要栈或队列操作：使用Deque（双端队列），推荐ArrayDeque

总结

Java集合框架是处理对象集合的强大工具，它提供了丰富的数据结构和操作方法，主要特点包括：

• 三大核心接口：List（有序可重复）、Set（无序不可重复）、Map（键值对映射）
• 接口与实现分离，便于灵活替换具体实现
• 全面支持泛型，确保类型安全
• 提供统一的遍历方式（迭代器）