Java集合框架

一、集合概述

集合是Java中用于存储和管理对象的重要数据结构，可以看作是动态数组的增强版，提供了丰富的操作方法。

集合与数组的区别

• 长度特性：数组长度固定，集合长度可动态变化
• 数据类型：数组可以存储基本类型和引用类型，集合只能存储引用类型

集合位于java.util.*包中，构成了Java集合框架的核心部分。

二、集合体系结构

Java集合框架以Collection接口为根，主要分为两大分支：List和Set。

Collection接口
List接口		Set接口
ArrayList类	LinkedList类	Vector类	HashSet类	SortedSet接口
				TreeSet类

接口特点对比

• List接口：有序集合，允许重复元素，支持下标访问
• Set接口：无序集合，不允许重复元素，不支持下标访问

三、Collection接口详解

Collection是集合框架的根接口，代表一组对象，具有以下特点：无序、无下标、元素不能重复。

常用方法

// 添加元素
boolean add(Object obj)
boolean addAll(Collection c)

// 删除元素
void clear()
boolean remove(Object o)

// 查询操作
boolean contains(Object o)
boolean isEmpty()
int size()

// 转换操作
Object[] toArray()

使用示例

// 创建集合实例
Collection<String> fruitCollection = new ArrayList<>();

// 添加元素
fruitCollection.add("苹果");
fruitCollection.add("香蕉");
fruitCollection.add("橙子");

System.out.println("集合大小: " + fruitCollection.size());
System.out.println("集合内容: " + fruitCollection);

// 遍历集合方式1：增强for循环
for (String fruit : fruitCollection) {
    System.out.println("水果: " + fruit);
}

// 遍历集合方式2：迭代器
System.out.println("使用迭代器遍历:");
Iterator<String> iterator = fruitCollection.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println("获取的水果: " + fruit);
}

// 判断操作
System.out.println("是否包含苹果: " + fruitCollection.contains("苹果"));
System.out.println("集合是否为空: " + fruitCollection.isEmpty());

四、List接口及其实现类

List接口特点

有序集合，允许重复元素，支持下标访问，提供额外的基于索引的操作方法。

// 基于索引的操作
void add(int index, Object o)
Object get(int index)
List subList(int fromIndex, int toIndex)

ArrayList实现类

特点：基于数组实现，查询效率高，增删效率低，非线程安全。

内部结构：

• 默认容量：10
• 扩容机制：每次扩容为原容量的1.5倍
• 核心数组：elementData
• 元素计数：size

// 使用示例
ArrayList<Product> productList = new ArrayList<>();

// 创建商品对象
Product p1 = new Product("笔记本电脑", 5999);
Product p2 = new Product("智能手机", 3999);
Product p3 = new Product("平板电脑", 2999);

// 添加商品
productList.add(p1);
productList.add(p2);
productList.add(0, p3); // 在指定位置插入

System.out.println("商品列表: " + productList);

// 基于索引遍历
for (int i = 0; i < productList.size(); i++) {
    Product product = productList.get(i);
    System.out.println("商品" + i + ": " + product);
}

// 使用列表迭代器
ListIterator<Product> listIterator = productList.listIterator();
while (listIterator.hasNext()) {
    System.out.println("下一个索引: " + listIterator.nextIndex() + 
                      ", 商品: " + listIterator.next());
}

Vector实现类

特点：基于数组实现，线程安全，但性能较低，属于早期JDK版本。

// 使用示例
Vector<String> vector = new Vector<>();
vector.add("元素1");
vector.add("元素2");

// 使用枚举遍历
Enumeration<String> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
    System.out.println(enumeration.nextElement());
}

LinkedList实现类

特点：基于链表实现，增删效率高，查询效率低，适合频繁插入删除的场景。

五、泛型与工具类

泛型概述

泛型是Java SE 5.0引入的特性，本质是参数化类型，提高了代码的类型安全性和复用性。

泛型类

public class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

泛型接口

public interface Service<T> {
    void process(T item);
}

// 实现方式1：指定具体类型
public class StringServiceImpl implements Service<String> {
    @Override
    public void process(String item) {
        System.out.println("处理字符串: " + item);
    }
}

// 实现方式2：保持泛型
public class GenericServiceImpl<T> implements Service<T> {
    @Override
    public void process(T item) {
        System.out.println("处理泛型对象: " + item);
    }
}

泛型方法

public class Util {
    // 泛型方法
    public <T> T identity(T obj) {
        return obj;
    }
    
    // 限制泛型类型
    public <T extends Comparable> T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }
}

六、Set接口及其实现类

Set接口特点

无序集合，不允许重复元素，不支持下标访问。

HashSet实现类

特点：基于哈希表实现，元素存储位置由哈希码决定，当哈希码相同时使用equals方法判断是否重复。

// 使用示例
HashSet<Student> studentSet = new HashSet<>();

// 创建学生对象
Student s1 = new Student("张三", 20);
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 22);

// 添加学生
studentSet.add(s1);
studentSet.add(s2);
studentSet.add(s3);
studentSet.add(new Student("张三", 20)); // 不会添加，因为重写了equals和hashCode

System.out.println("学生数量: " + studentSet.size());

// 遍历学生集合
for (Student student : studentSet) {
    System.out.println(student);
}

// 重写equals和hashCode方法
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

TreeSet实现类

特点：基于树结构实现，自动排序，元素必须实现Comparable接口或提供自定义比较器。

// 使用示例
TreeSet<Book> bookSet = new TreeSet<>();

// 创建书籍对象
Book b1 = new Book("Java编程思想", 120);
Book b2 = new Book("Effective Java", 90);
Book b3 = new Book("设计模式", 80);

// 添加书籍
bookSet.add(b1);
bookSet.add(b2);
bookSet.add(b3);

System.out.println("书籍集合: " + bookSet);

// 自定义比较器
TreeSet<String> stringSet = new TreeSet<>((s1, s2) -> {
    int lengthCompare = Integer.compare(s1.length(), s2.length());
    return lengthCompare != 0 ? lengthCompare : s1.compareTo(s2);
});

stringSet.add("hello");
stringSet.add("hi");
stringSet.add("world");
stringSet.add("java");

System.out.println("按长度排序的字符串: " + stringSet);

七、Map接口及其实现类

Map接口特点

存储键值对(Key-Value)映射关系，键唯一且不允许重复，值可以重复。

Map接口
HashMap类	SortedMap接口
	TreeMap类

常用方法

// 添加/更新元素
V put(K key, V value)

// 获取元素
V get(Object key)

// 删除元素
V remove(Object key)

// 查询操作
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()

// 判断操作
boolean containsKey(Object key)
boolean containsValue(Object value)

HashMap实现类

特点：基于哈希表实现，键值存储无序，允许null键和null值，非线程安全。

内部结构：

• 初始容量：16
• 加载因子：0.75
• 扩容机制：容量翻倍
• JDK 1.8优化：链表长度超过8且数组长度≥64时转换为红黑树

// 使用示例
HashMap<Integer, String> countryMap = new HashMap<>();

// 添加国家信息
countryMap.put(1, "中国");
countryMap.put(2, "美国");
countryMap.put(3, "日本");

System.out.println("国家数量: " + countryMap.size());

// 遍历方式1：遍历键
System.out.println("遍历键:");
for (Integer key : countryMap.keySet()) {
    System.out.println(key + " - " + countryMap.get(key));
}

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

TreeMap实现类

特点：基于红黑树实现，按键排序，键必须实现Comparable接口或提供比较器。

// 使用示例
TreeMap<Integer, String> sortedMap = new TreeMap<>();

// 添加数据
sortedMap.put(3, "C");
sortedMap.put(1, "A");
sortedMap.put(2, "B");

System.out.println("排序后的映射: " + sortedMap);

// 使用自定义比较器
TreeMap<Employee, Integer> salaryMap = new TreeMap<>((e1, e2) -> {
    int salaryCompare = Integer.compare(e1.getSalary(), e2.getSalary());
    return salaryCompare != 0 ? salaryCompare : e1.getName().compareTo(e2.getName());
});

// 添加员工数据
salaryMap.put(new Employee("张三", 8000), 8000);
salaryMap.put(new Employee("李四", 10000), 10000);
salaryMap.put(new Employee("王五", 6000), 6000);

System.out.println("按薪资排序的员工: " + salaryMap);

Hashtable实现类

特点：古老的Map实现，线程安全，不允许null键和null值，性能较低。

Properties实现类

特点：Hashtable的子类，专门用于处理配置文件，键和值都是String类型。

八、Collections工具类

Collections是集合工具类，提供了大量静态方法用于操作集合。

常用方法

// 排序
static <T extends Comparable<? super T>> void sort(List<T> list)

// 反转
static void reverse(List<?> list)

// 随机排序
static void shuffle(List<?> list)

// 二分查找
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

// 复制
static void copy(List<? super T> dest, List<? extends T> src)

// 填充
static void fill(List<?> list, Object obj)

使用示例

// 创建列表
List<Integer> numbers = new ArrayList<>();
numbers.add(30);
numbers.add(10);
numbers.add(20);

// 排序
Collections.sort(numbers);
System.out.println("排序后: " + numbers); // [10, 20, 30]

// 反转
Collections.reverse(numbers);
System.out.println("反转后: " + numbers); // [30, 20, 10]

// 随机排序
Collections.shuffle(numbers);
System.out.println("随机排序后: " + numbers);

// 二分查找
int index = Collections.binarySearch(numbers, 20);
System.out.println("20的索引: " + index);

// 列表复制
List<Integer> destList = new ArrayList<>();
for (int i = 0; i < numbers.size(); i++) {
    destList.add(0);
}
Collections.copy(destList, numbers);
System.out.println("复制后的列表: " + destList);

// 数组与集合转换
String[] array = {"A", "B", "C"};
List<String> list = Arrays.asList(array); // 注意：此列表大小固定

// 基本类型数组转集合
int[] intArray = {1, 2, 3};
List<Integer> intList = Arrays.stream(intArray).boxed().collect(Collectors.toList());

九、集合框架总结

Java集合框架是Java语言的重要组成部分，提供了丰富的数据结构实现，适用于不同场景：

• List集合：有序、可重复、支持下标访问，实现类包括ArrayList、LinkedList和Vector
• Set集合：无序、不可重复、不支持下标访问，实现类包括HashSet和TreeSet
• Map集合：存储键值对映射，键唯一、值可重复，实现类包括HashMap、TreeMap和Hashtable
• 工具类：Collections提供集合操作工具方法，Arrays提供数组操作工具方法

正确选择集合实现类，能够有效提高程序的性能和可维护性。