Java集合

Java集合是Java中用于存储、管理和访问集合数据的容器。Java集合主要分为以下几种：

• List：列表，元素有序、可重复。
• Set：集合，元素无序、不可重复。
• Map：映射，元素是键值对，键不可重复。

Java集合的特点：

• 集合中的元素可以重复，但集合本身不允许重复。
• 集合中的元素可以按顺序访问，但集合本身不保证元素的顺序。
• 集合中的元素可以按索引访问，但集合本身不保证元素的索引。
• 集合中的元素可以动态增删，但集合本身不保证元素的动态增删。

Java集合的接口：

• Collection：集合接口，定义了集合的基本操作。
• List：列表接口，继承于Collection接口，定义了列表的基本操作。
• Set：集合接口，继承于Collection接口，定义了集合的基本操作。
• Map：映射接口，继承于Collection接口，定义了映射的基本操作。

List接口

List接口是Java集合框架中最常用的接口之一，它代表一个有序的集合，元素可以重复。List接口提供了对元素进行增删改查的各种方法，包括：

• add(E e)：在列表的末尾添加一个元素。
• add(int index, E element)：在指定位置添加一个元素。
• remove(int index)：删除指定位置的元素。
• set(int index, E element)：修改指定位置的元素。
• get(int index)：获取指定位置的元素。
• size()：获取列表的大小。
• contains(Object o)：判断列表中是否包含指定元素。
• indexOf(Object o)：获取指定元素在列表中的索引。
• isEmpty()：判断列表是否为空。
• clear()：清空列表。

List接口的实现类

List接口有很多实现类，常用的有：

• ArrayList：ArrayList是List接口的主要实现类，它是一个动态数组，可以自动扩容。
• LinkedList：LinkedList是List接口的另一个实现类，它是一个双向链表，可以快速地插入、删除元素。
• Vector：Vector是ArrayList的线程安全版本，它是List接口的古老实现类。
• Stack：Stack是Vector的子类，它是一个栈，可以模拟堆栈的操作。

代码示例

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

public class ListExample {
    public static void main(String[] args) {
        // 创建ArrayList
        List<String> list = new ArrayList<>();
        // 添加元素
        list.add("apple");
        list.add("banana");
        list.add("orange");
        list.add("grape");
        // 遍历元素
        for (String fruit : list) {
            System.out.println(fruit);
        }
        // 遍历元素（索引）
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        // 遍历元素（迭代器）
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        // 删除元素
        list.remove(1);
        // 修改元素
        list.set(2, "pear");
        // 判断元素是否存在
        System.out.println(list.contains("banana"));
        // 获取元素索引
        System.out.println(list.indexOf("orange"));
        // 清空列表
        list.clear();
    }
}

Set接口

Set接口是Java集合框架中另一个常用的接口，它代表一个无序的集合，元素不可重复。Set接口提供了对元素进行增删查的各种方法，包括：

• add(E e)：在集合中添加一个元素。
• remove(E e)：从集合中删除一个元素。
• contains(Object o)：判断集合中是否包含指定元素。
• size()：获取集合的大小。
• isEmpty()：判断集合是否为空。
• clear()：清空集合。

Set接口的实现类

Set接口有很多实现类，常用的有：

• HashSet：HashSet是Set接口的主要实现类，它是一个哈希表，可以快速地查找元素。
• LinkedHashSet：LinkedHashSet是HashSet的子类，它是一个有序的哈希表，可以快速地查找元素。
• TreeSet：TreeSet是SortedSet接口的主要实现类，它是一个有序的集合，可以快速地查找元素。

代码示例

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

public class SetExample {
    public static void main(String[] args) {
        // 创建HashSet
        Set<String> set = new HashSet<>();
        // 添加元素
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("grape");
        // 遍历元素
        for (String fruit : set) {
            System.out.println(fruit);
        }
        // 删除元素
        set.remove("banana");
        // 判断元素是否存在
        System.out.println(set.contains("orange"));
        // 清空集合
        set.clear();
    }
}

Map接口

Map接口是Java集合框架中最复杂的接口，它代表一个键值对的集合，键不可重复。Map接口提供了对键值对进行增删查的各种方法，包括：

• put(K key, V value)：添加一个键值对。
• remove(K key)：删除指定键的键值对。
• get(K key)：获取指定键的键值对。
• containsKey(Object key)：判断是否包含指定键。
• containsValue(Object value)：判断是否包含指定值。
• size()：获取映射的大小。
• isEmpty()：判断映射是否为空。
• clear()：清空映射。
• keySet()：获取映射中的所有键。
• values()：获取映射中的所有值。
• entrySet()：获取映射中的所有键值对。
• equals(Object obj)：判断两个映射是否相等。
• hashCode()：获取映射的哈希值。
• toString()：获取映射的字符串表示。
• clone()：复制映射。
• putAll(Map<? extends K,? extends V> m)：将指定映射中的所有键值对添加到当前映射中。
• replace(K key, V value)：替换指定键的键值对。
• replace(K key, V oldValue, V newValue)：替换指定键的键值对，并返回旧值。
• replaceAll(BiFunction<? super K,? super V,? extends V> function)：使用指定的函数替换映射中的所有键值对。

Map接口的实现类

Map接口有很多实现类，常用的有：

• HashMap：HashMap是Map接口的主要实现类，它是一个哈希表，可以快速地查找键值对。
• LinkedHashMap： LinkedHashMap是HashMap的子类，它是一个有序的哈希表，可以快速地查找键值对。
• TreeMap：TreeMap是SortedMap接口的主要实现类，它是一个有序的映射，可以快速地查找键值对。
• ConcurrentHashMap：ConcurrentHashMap是HashMap的线程安全版本，它是一个线程安全的哈希表，可以快速地查找键值对。

代码示例

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

public class MapExample {
    public static void main(String[] args) {
        // 创建HashMap
        Map<String, Integer> map = new HashMap<>();
        // 添加键值对
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("orange", 3);
        map.put("grape", 4);
        // 遍历键值对
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        // 删除键值对
        map.remove("banana");
        // 获取键值对
        System.out.println(map.get("orange"));
        // 判断键是否存在
        System.out.println(map.containsKey("grape"));
        // 判断值是否存在
        System.out.println(map.containsValue(3));
        // 清空映射
        map.clear();
    }
}