Java 集合

一、集合概述

在 Java 中，集合是一组用于存储和操作对象的容器。集合框架提供了多种不同类型的集合类，以满足不同的需求。集合可以存储不同类型的对象，并且提供了方便的方法来添加、删除、查找和遍历元素。

二、主要集合接口

Collection接口：
- 这是集合框架的根接口，它定义了一组通用的操作，适用于所有的集合类型。
- 主要方法包括：add（添加元素）、remove（删除元素）、contains（判断是否包含某个元素）、size（获取集合大小）、iterator（获取迭代器）等。
List接口：
- 是一个有序的集合，可以包含重复的元素。
- 实现类有ArrayList、LinkedList等。
- 主要方法除了继承自Collection接口的方法外，还有get（获取指定位置的元素）、set（设置指定位置的元素）、addAll（添加另一个集合的所有元素到当前集合）等。
Set接口：
- 是一个不包含重复元素的集合。
- 实现类有HashSet、LinkedHashSet、TreeSet等。
- 主要方法与Collection接口类似，但由于不允许重复元素，在添加元素时会进行检查。
Map接口：
- 是一种键值对的集合，每个键只能对应一个值。
- 实现类有HashMap、LinkedHashMap、TreeMap等。
- 主要方法包括：put（添加键值对）、get（根据键获取值）、remove（根据键删除键值对）、containsKey（判断是否包含某个键）、containsValue（判断是否包含某个值）等。

三、常见集合类详解

ArrayList：
- 基于动态数组实现，允许快速随机访问元素。
- 优点：随机访问元素速度快，因为可以通过索引直接访问。添加和删除元素在末尾操作时速度较快，但在中间位置操作时需要移动其他元素，相对较慢。
- 适用场景：当需要频繁随机访问元素，并且插入和删除操作主要在末尾进行时比较适合。
- 示例：
```
import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        System.out.println(list.get(1)); // 输出：banana
    }
}
```
LinkedList：
- 基于双向链表实现，在插入和删除元素时速度较快。
- 优点：插入和删除元素在任何位置都比较高效，只需要调整链表中的指针即可。但随机访问元素相对较慢，需要从头或尾开始遍历链表。
- 适用场景：当需要频繁进行插入和删除操作，并且对随机访问元素的需求不高时比较适合。
- 示例：
```
import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        list.add(1, "orange");
        System.out.println(list); // 输出：[apple, orange, banana, cherry]
    }
}
```

HashSet：

使用哈希表实现，不保证元素的顺序。
优点：添加、删除和查找元素的速度非常快，平均时间复杂度为 O(1)。
适用场景：当需要快速存储和查找不重复的元素，并且不关心元素的顺序时比较适合。

示例：

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

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("apple"); // 重复元素不会被添加

        System.out.println(set); // 输出：[banana, apple]
    }
}

LinkedHashSet：

继承自HashSet，同时维护了元素的插入顺序。
优点：在保证元素不重复的同时，能够按照元素的插入顺序进行遍历。
适用场景：当需要不重复的元素集合，并且希望按照插入顺序遍历元素时比较适合。

示例：

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");

        System.out.println(set); // 输出：[apple, banana, cherry]
    }
}

TreeSet：
- 基于红黑树实现，元素按照自然顺序或自定义的比较器进行排序。
- 优点：可以保证元素的有序性，并且提供了高效的查找、插入和删除操作。
- 适用场景：当需要有序的元素集合，并且希望进行高效的排序操作时比较适合。
- 示例：
```
import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        set.add(5);
        set.add(3);
        set.add(7);

        System.out.println(set); // 输出：[3, 5, 7]
    }
}
```

HashMap：

使用哈希表实现，允许存储键值对，不保证元素的顺序。
优点：快速的插入、删除和查找操作，平均时间复杂度为 O(1)。
适用场景：当需要快速存储和检索键值对，并且不关心元素的顺序时比较适合。

示例：

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        System.out.println(map.get("apple")); // 输出：5
    }
}

LinkedHashMap：

继承自HashMap，同时维护了元素的插入顺序。
优点：在保证快速操作的同时，能够按照元素的插入顺序进行遍历。
适用场景：当需要存储键值对，并且希望按照插入顺序遍历元素时比较适合。

示例：

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        System.out.println(map); // 输出：{apple=5, banana=3}
    }
}

TreeMap：

基于红黑树实现，按照键的自然顺序或自定义的比较器进行排序。
优点：可以保证键的有序性，并且提供了高效的查找、插入和删除操作。
适用场景：当需要有序的键值对集合，并且希望进行高效的排序操作时比较适合。

示例：

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

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        System.out.println(map); // 输出：{apple=5, banana=3}
    }
}

四、集合的遍历方式

使用迭代器：

适用于所有的集合类型。

示例：

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

使用增强 for 循环：

简洁方便，只能用于实现了Iterable接口的集合类型。

示例：

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

public class EnhancedForLoopExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        for (String element : list) {
            System.out.println(element);
        }
    }
}

对于Map集合，可以使用以下方式遍历：

遍历键：

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

public class MapKeyIterationExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }
    }
}

遍历值：

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

public class MapValueIterationExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.println(value);
        }
    }
}

遍历键值对：

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

public class MapEntryIterationExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
    }
}

五、集合的工具类

Collections类：

提供了一系列静态方法，用于对集合进行操作。
例如：sort（对列表进行排序）、reverse（反转列表）、shuffle（随机打乱列表）等。

示例：

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

public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(3);
        list.add(7);

        Collections.sort(list);
        System.out.println(list); // 输出：[3, 5, 7]

        Collections.reverse(list);
        System.out.println(list); // 输出：[7, 5, 3]
    }
}

Arrays.asList方法：

可以将数组转换为List集合。

示例：

import java.util.Arrays;
import java.util.List;

public class ArraysAsListExample {
    public static void main(String[] args) {
        Integer[] array = {1, 2, 3};
        List<Integer> list = Arrays.asList(array);
        System.out.println(list); // 输出：[1, 2, 3]
    }
}

注意：由Arrays.asList方法返回的List集合是固定大小的，如果尝试添加或删除元素，会抛出UnsupportedOperationException异常。如果需要一个可变大小的List集合，可以使用new ArrayList<>(Arrays.asList(array))的方式进行转换。

posted @ 2026-07-29 09:45 渔樵江渚阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

渔樵江渚

Java 集合

Java 集合

公告