当前位置：首页 > article >正文

Java面试第一山！《集合》！

article 2025/2/15 17:41:00

一、引言

在 Java 编程的世界里，数据的存储和处理是非常重要的环节。Java 集合框架就像是一个功能强大的工具箱，为我们提供了各种各样的数据结构来高效地存储和操作数据。今天，跟随小编一起来深入了解 Java 集合框架，这不仅有助于你在日常开发中更加得心应手，还能在面试中脱颖而出。

二、Java 集合框架概述

Java 集合框架主要分为两大体系：Collection 和 Map。Collection 接口是存储单个元素的集合的根接口，而 Map 接口则是存储键值对的集合的根接口。它们各自有许多不同的实现类，每个实现类都有其独特的特点和适用场景。下面是 Java 集合框架的整体架构图：

三、Collection 体系

（一）List 接口

List 接口是有序的集合，允许存储重复的元素。它的主要实现类有 ArrayList，LinkedList 和 Vector。

1. 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
    }
}

2. 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.addFirst("date");
        System.out.println(list.get(0)); // 输出: date
    }
}

3. Vector

特点：与 ArrayList 类似，也是基于动态数组实现，但它是线程安全的，不过性能相对较低。
适用场景：适用于在多线程环境下需要保证线程安全的场景。
示例代码：

import java.util.Vector;
import java.util.List;

public class VectorExample {
    public static void main(String[] args) {
        List<String> list = new Vector<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
        System.out.println(list.get(1)); // 输出: banana
    }
}

（二）Set 接口

Set 接口是不允许存储重复元素的集合。它的主要实现类有 HashSet、TreeSet 和 LinkedHashSet。

1. HashSet

特点：基于哈希表实现，不保证元素的顺序，插入、删除和查找元素的效率都很高。
适用场景：适用于需要快速判断元素是否存在，且不关心元素顺序的场景。
示例代码：

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.size()); // 输出: 2
    }
}

2. 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(3);
        set.add(1);
        set.add(2);
        for (Integer num : set) {
            System.out.print(num + " "); // 输出: 1 2 3
        }
    }
}

3. LinkedHashSet

特点：基于哈希表和链表实现，既保证了元素的唯一性，又能按照元素插入的顺序进行遍历。
适用场景：适用于需要保证元素的插入顺序，同时又需要快速判断元素是否存在的场景。
示例代码：

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");
        for (String fruit : set) {
            System.out.print(fruit + " "); // 输出: apple banana cherry
        }
    }
}

四、Map 体系

Map 接口用于存储键值对，键是唯一的，值可以重复。它的主要实现类有 HashMap、TreeMap、LinkedHashMap 和 Hashtable。

（一）HashMap

特点：基于哈希表实现，不保证键值对的顺序，插入、删除和查找元素的效率都很高。
适用场景：适用于需要快速查找、插入和删除键值对，且不关心键值对顺序的场景。
示例代码：

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", 1);
        map.put("banana", 2);
        System.out.println(map.get("banana")); // 输出: 2
    }
}

（二）TreeMap

特点：基于红黑树实现，键会按照自然顺序或者指定的比较器顺序进行排序。
适用场景：适用于需要对键进行排序的场景。
示例代码：

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

public class TreeMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<>();
        map.put(3, "apple");
        map.put(1, "banana");
        map.put(2, "cherry");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
            // 输出:
            // 1: banana
            // 2: cherry
            // 3: apple
        }
    }
}

（三）LinkedHashMap

特点：基于哈希表和链表实现，既保证了键的唯一性，又能按照键的插入顺序或者访问顺序进行遍历。
适用场景：适用于需要保证键值对的插入顺序或者访问顺序的场景。
示例代码：

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", 1);
        map.put("banana", 2);
        map.put("cherry", 3);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
            // 输出:
            // apple: 1
            // banana: 2
            // cherry: 3
        }
    }
}

（四）Hashtable

特点：与 HashMap 类似，也是基于哈希表实现，但它是线程安全的，不过性能相对较低。
适用场景：适用于在多线程环境下需要保证线程安全的场景。
示例代码：

import java.util.Hashtable;
import java.util.Map;

public class HashtableExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new Hashtable<>();
        map.put("apple", 1);
        map.put("banana", 2);
        System.out.println(map.get("banana")); // 输出: 2
    }
}