java集合框架

集合框架

集合框架体系（java.util包下）

• java.util.collection:存储一个一个的数据
  • 子接口：List：存储有序的、可重复的数据（“动态”数组）
    • 实现类：ArrayList(主要),LinkedList,Vector
    • ArrayList是线程不安全的，效率高；底层使用Object[]数组进行存储
    • LinkedList底层使用双向链表方式进行存储
  • 子接口：Set：存储无序的、不可重复的数据
    • 实现类：HashSet(主要),LinkedHashSet,TreeSet
    • HashSet：底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储
    • LinkedHashSet：是HashSet的子类，在HashSet结构的基础上又添加了一组双向链表，用于记录添加元素的先后顺序。
    • TreeSet：底层使用红黑树存储。可以按照添加元素的指定的属性大小顺序进行存储
• java.util.Map:存储一对一对的数据
  • 实现类：HashMap(主要),LinkedHashMap,TreeMap,Hashtable,Properties
    • HashMap:线程不安全的，可以添加null的key和value值；底层使用数组+单向链表+红黑树结构存储
    • LinkedHashMap：是HashMap的子类；在HashMap使用的数据结构的基础上增加了一堆双向链表，用于记录添加的元素的先后顺序
    • TreeMap：底层使用红黑树存储；可以按照添加的key-value中的key元素的只当的属性的大小顺序进行遍历。需要使用自然排序或者定制排序。
    • Hashtable：古老实现类，线程安全的，效率低；可以添加null的key或value值，底层使用数组+单向链表
    • Properties：其key和value都是String类型。常用于处理属性文件

常用集合接口

Collection接口：

• 代表一组对象，可以是列表、集合或映射。它是所有集合类的根接口，定义了对集合进行基本操作的方法，如添加、删除、遍历等
• 向Collection中添加元素要求元素所属的类一定要重写equals()方法

import java.util.ArrayList;
import java.util.Collection;

public class CollectionExample {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        
        collection.add("Apple");
        collection.add("Banana");
        collection.add("Orange");
        
        System.out.println("Collection: " + collection);
        
        collection.remove("Banana");
        
        System.out.println("After removing Banana: " + collection);
        
        System.out.println("Collection size: " + collection.size());
        
        System.out.println("Is collection empty? " + collection.isEmpty());
    }
}

List接口：

• 继承自Collection接口，表示有序的集合，允许重复元素。常见的实现类有ArrayList、LinkedList等

ArrayList常用方法

• add(E element): 将指定的元素添加到列表的末尾。
• add(int index, E element): 将指定的元素插入到列表中的指定位置。
• get(int index): 返回列表中指定位置的元素。
• set(int index, E element): 替换列表中指定位置的元素。
• remove(int index): 移除列表中指定位置的元素。
• size(): 返回列表中的元素个数。
• clear(): 清空列表中的所有元素。
• contains(Object o): 判断列表是否包含指定的元素。
• indexOf(Object o): 返回指定元素在列表中第一次出现的位置。
• isEmpty(): 判断列表是否为空。
• addAll(Collection<? extends E> c): 将指定集合中的所有元素添加到列表的末尾。
• remove(Object o): 移除列表中第一次出现的指定元素。
• toArray():返回包含当前集合所有元素的数组。

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

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        
        list.add("Java");
        list.add("Python");
        list.add("C++");
        
        System.out.println("List: " + list);
        
        System.out.println("Element at index 1: " + list.get(1));
        
        list.remove(0);
        
        System.out.println("After removing element at index 0: " + list);
    }
}

Set接口：

• 继承自Collection接口，表示不允许重复元素的集合。常见的实现类有HashSet、TreeSet等。
• 比较的标准，需要判断hashCode()得到的哈希值以及equals()得到的

HashSet常用方法

• add(E e): 将指定的元素添加到 HashSet 中，如果元素已经存在，则不会添加。
• remove(Object o): 从 HashSet 中移除指定的元素。
• contains(Object o): 判断 HashSet 是否包含指定的元素。
• size(): 返回 HashSet 中元素的个数。
• isEmpty(): 判断 HashSet 是否为空。
• clear(): 清空 HashSet 中的所有元素。
• iterator(): 返回一个迭代器，可以用来遍历 HashSet 中的元素。
• addAll(Collection<? extends E> c): 将一个集合的所有元素添加到 HashSet 中。
• containsAll(Collection<?> c): 判断 HashSet 是否包含另一个集合的所有元素。
• removeAll(Collection<?> c): 移除 HashSet 中与指定集合中相同的元素。
• retainAll(Collection<?> c): 保留 HashSet 中与指定集合中相同的元素，移除其他元素。
• toArray(): 将 HashSet 转换为数组。

import java.util.HashSet;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters and setters (not shown for brevity)

    @Override
    public int hashCode() {
        return name.hashCode() + age; // Custom hash code implementation
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

public class Main {
    public static void main(String[] args) {
        HashSet<Person> personSet = new HashSet<>();

        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);
        Person person3 = new Person("Alice", 30); // Duplicate of person1

        personSet.add(person1);
        personSet.add(person2);
        personSet.add(person3); // This won't be added due to being a duplicate

        System.out.println("Size of the HashSet: " + personSet.size());
        for (Person person : personSet) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

Map接口：

• 表示键值对的集合。其中键是唯一的，每个键最多只能映射到一个值。常见的实现类有HashMap、TreeMap等
• 所有的key构成一个set集合，key所在的类要重写hashCode()和equals()
• 所有的value构成一个Collection集合，value所在的类要重写equals()
• HashMap中的一个key-value，构成了一个entry
• HashMap中的所有的entry彼此之间是不可重复的，无序的。所有的entry构成了一个Set集合

HashMap常用方法

• put(key, value): 将指定的键值对存储在HashMap中。
• get(key): 返回指定键所映射的值，如果该键不存在，则返回null。
• containsKey(key): 判断HashMap中是否包含指定的键。
• containsValue(value): 判断HashMap中是否包含指定的值。
• remove(key): 删除HashMap中指定键对应的键值对。
• size(): 返回HashMap中键值对的数量。
• isEmpty(): 判断HashMap是否为空。
• keySet(): 返回HashMap中所有键的集合。
• values(): 返回HashMap中所有值的集合。
• entrySet(): 返回HashMap中所有键值对的集合。

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        
        System.out.println("Map: " + map);
        
        System.out.println("Value for key 'Two': " + map.get("Two"));
        
        map.remove("Three");
        
        System.out.println("After removing key 'Three': " + map);
    }
}

迭代器遍历集合

• 在Java中，可以使用迭代器（Iterator）来遍历集合（Collection）中的元素。迭代器提供了一种通用的方法来访问集合中的元素，而不需要了解集合的内部结构。
• boolean hasNext(): 判断是否还有下一个元素。
• E next(): 迭代器下移并返回迭代器中的下一个元素。
• void remove(): 从底层集合中移除迭代器返回的最后一个元素（可选操作）

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

public class Main {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 获取集合的迭代器
        Iterator<String> iterator = list.iterator();

        // 使用迭代器遍历集合元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

foreach循环

• foreach循环也被称为增强型for循环，用于遍历数组或集合中的元素。foreach循环提供了一种简洁的方式来遍历数组或集合，而不需要使用传统的for循环和索引。

public class ForEachExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        // 使用foreach循环遍历数组
        for (int number : numbers) {
            System.out.println(number);
        }

        // 使用foreach循环遍历集合
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

Collections工具类

• Java中的Collections工具类提供了一系列静态方法，用于操作集合类（Collection）和Map类
• 这些方法包括排序、查找、同步等功能，能够方便地对集合进行操作。

工具类方法

• sort(List list)：对List集合进行排序。
• reverse(List<?> list)：反转List集合中元素的顺序。
• shuffle(List<?> list)：随机打乱List集合中元素的顺序。
• binarySearch(List<? extends Comparable<? super T>> list, T key)：在已排序的List中使用二分查找算法查找指定元素。
• synchronizedCollection(Collection c)：返回一个线程安全的集合。
• unmodifiableCollection(Collection<? extends T> c)：返回一个不可修改的集合。
• singleton(T o)：返回一个只包含指定对象的不可变集合。
• emptyList()：返回一个空的、不可修改的List。
• frequency(Collection<?> c, Object o)：返回指定元素在集合中出现的次数。
• disjoint(Collection<?> c1, Collection<?> c2)：检查两个集合是否没有共同元素。