我是廖志伟

【深入探究Java集合框架】从List到Map的完整指南

文章目录

Java集合框架
- Collection
- - List
  - Set
  - Map
- 集合的选择
- - 1. 有序并允许重复元素的集合 List
  - 2. 无序并且不允许重复元素的集合 Set
  - 3. 维护映射关系的集合 Map
  - 4. 高效的随机访问和修改元素 ArrayList
  - 5. 高效的添加和删除元素 LinkedList
  - 6. 维护元素的插入顺序 LinkedHashSet
  - 7. 元素的自然排序或者指定的比较器进行排序 TreeSet
  - 8. 线程安全 Vector
  - 9. 线程安全 HashTable

我是廖志伟，一名Java开发工程师、Java领域优质创作者、CSDN博客专家、51CTO专家博主、阿里云专家博主、清华大学出版社签约作者、产品软文创造者、技术文章评审老师、问卷调查设计师、个人社区创始人、开源项目贡献者。跑过十五公里、徒步爬过衡山、有过三个月减肥20斤的经历、是个喜欢躺平的狠人。

拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、Spring MVC、SpringCould、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RockerMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。有从0到1的高并发项目经验，利用弹性伸缩、负载均衡、报警任务、自启动脚本，最高压测过200台机器，有着丰富的项目调优经验。

经过多年在CSDN创作上千篇文章的经验积累，我已经拥有了不错的写作技巧。同时，我还与清华大学出版社签下了四本书籍的合约，并将陆续在明年出版。这些书籍包括了基础篇、进阶篇、架构篇的《Java项目实战—深入理解大型互联网企业通用技术》，以及《解密程序员的思维密码–沟通、演讲、思考的实践》。具体出版计划会根据实际情况进行调整，希望各位读者朋友能够多多支持！

希望各位读者大大多多支持用心写文章的博主，现在时代变了，信息爆炸，酒香也怕巷子深，博主真的需要大家的帮助才能在这片海洋中继续发光发热，所以，赶紧动动你的小手，点波关注❤️，点波赞，点波收藏⭐，甚至点波评论✍️，都是对博主最好的支持和鼓励！

博客主页：我是廖志伟
开源项目：java_wxid
哔哩哔哩：我是廖志伟
个人社区：幕后大佬
个人微信号： SeniorRD

在这个美好的时刻，本人不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。

Java集合框架

Java集合框架是Java编程语言提供的一组类和接口，用于表示集合，并提供了相关的操作和算法。在Java集合框架中，集合分为三种类型：List、Set和Map。其中，List是有序的集合，允许重复元素；Set是无序且不允许重复元素的集合；而Map是一种映射关系，它将一个键与一个值相关联。这些集合提供了非常多的操作，比如添加、删除、查找、排序等。

Collection

Java集合框架中的根接口是Collection，它提供了基本的集合操作。在Collection接口中有两个子接口：List和Set。

List

List接口是有序的集合，允许重复元素。List接口有三个主要的实现类：ArrayList、Vector和LinkedList。其中，ArrayList底层是一个数组，使用空间较少，线程不安全，因此性能较高。默认情况下，ArrayList的初始容量为10，当添加元素时，如果当前容量不足，则会进行扩容，扩容为原来的1.5倍。Vector是一个线程安全的List实现，它的底层也是一个数组，但是比ArrayList慢。LinkedList底层是双向链表，因此添加和删除元素的性能非常高，但是查找元素的性能较低。
示例代码如下：

import java.util.List;
import java.util.ArrayList;
import java.util.Vector;
import java.util.LinkedList;

public class ListExample {
    public static void main(String[] args) {

        // ArrayList示例
        List<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a"); // 允许重复元素
        System.out.println("ArrayList示例：" + arrayList);

        // Vector示例
        List<String> vector = new Vector<>();
        vector.add("d");
        vector.add("e");
        vector.add("f");
        System.out.println("Vector示例：" + vector);

        // LinkedList示例
        List<String> linkedList = new LinkedList<>();
        linkedList.add("g");
        linkedList.add("h");
        linkedList.add("i");
        linkedList.add("g"); // 允许重复元素
        System.out.println("LinkedList示例：" + linkedList);
    }
}

Set

Set接口是无序并且不允许重复元素的集合。Set接口有三个主要的实现类：HashSet、LinkedHashSet和TreeSet。其中，HashSet底层实现是基于HashMap，使用哈希表来存储元素。当向HashSet中添加元素时，会根据元素的hashCode值来计算存储位置，如果该位置已经有元素，则将其链接在链表的末尾；如果链表长度达到8，则将链表转换为红黑树，以提高查找效率。LinkedHashSet是HashSet的子类，底层实现也是基于HashMap，但是额外维护了一个链表，用于维护元素的插入顺序。TreeSet底层使用红黑树来存储元素，因此可以保证元素的有序性，并且提供了一些基于排序的操作。
示例代码如下：

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        // 创建一个HashSet集合
        HashSet<String> hashSet = new HashSet<>();

        // 添加元素到HashSet中
        hashSet.add("apple");
        hashSet.add("banana");
        hashSet.add("orange");
        hashSet.add("watermelon");
        hashSet.add("grape");
        hashSet.add("pineapple");

        // 遍历HashSet集合中所有元素
        for (String fruit : hashSet) {
            System.out.println(fruit);
        }

        // 创建一个LinkedHashSet集合
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();

        // 添加元素到LinkedHashSet中
        linkedHashSet.add("apple");
        linkedHashSet.add("banana");
        linkedHashSet.add("orange");
        linkedHashSet.add("watermelon");
        linkedHashSet.add("grape");
        linkedHashSet.add("pineapple");

        // 遍历LinkedHashSet集合中所有元素
        for (String fruit : linkedHashSet) {
            System.out.println(fruit);
        }

        // 创建一个TreeSet集合
        TreeSet<String> treeSet = new TreeSet<>();

        // 添加元素到TreeSet中
        treeSet.add("apple");
        treeSet.add("banana");
        treeSet.add("orange");
        treeSet.add("watermelon");
        treeSet.add("grape");
        treeSet.add("pineapple");

        // 遍历TreeSet集合中所有元素
        for (String fruit : treeSet) {
            System.out.println(fruit);
        }
    }
}

Map

Map是一种映射关系，它将一个键与一个值相关联。Map接口中的键是无序、不可重复的，值是无序但可重复的。Map接口有四个主要的实现类：HashMap、LinkedHashMap、TreeMap和HashTable。其中，HashMap底层实现是基于哈希表，它使用键的hashCode值来计算存储位置，并使用链表（JDK1.8之后，链表长度达到8时会自动转化为红黑树）来解决哈希冲突。LinkedHashMap是HashMap的子类，它维护了一个双向链表来维护元素的插入顺序。TreeMap底层使用红黑树来存储元素，根据键的自然排序或指定的比较器来排序键。HashTable是一个线程安全的Map实现，它的底层实现与HashMap相似，但不允许键或值为空，且操作都是同步的。
示例代码如下：

import java.util.*;

public class MapExamples {
    public static void main(String[] args) {
        // 创建HashMap示例
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("Charlie", 35);
        System.out.println("HashMap: " + hashMap);

        // 创建LinkedHashMap示例
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("Alice", 25);
        linkedHashMap.put("Bob", 30);
        linkedHashMap.put("Charlie", 35);
        System.out.println("LinkedHashMap: " + linkedHashMap);

        // 创建TreeMap示例
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Alice", 25);
        treeMap.put("Bob", 30);
        treeMap.put("Charlie", 35);
        System.out.println("TreeMap: " + treeMap);

        // 创建HashTable示例
        Hashtable<String, Integer> hashTable = new Hashtable<>();
        hashTable.put("Alice", 25);
        hashTable.put("Bob", 30);
        hashTable.put("Charlie", 35);
        System.out.println("HashTable: " + hashTable);
    }
}

集合的选择

在Java集合框架中，集合的选择应该根据集合的特点和使用场景进行选择。例如，如果需要有序并且允许重复元素的集合，则应该选择List接口；如果需要无序并且不允许重复元素的集合，则应该选择Set接口；如果需要维护映射关系，则应该选择Map接口。但是，具体的实现类的选择应该根据集合的性能需求和使用场景进行选择。例如，如果需要高效的随机访问和修改元素，则应该选择ArrayList；如果需要高效的添加和删除元素，则应该选择LinkedList。如果需要维护元素的插入顺序，则应该选择LinkedHashSet或LinkedHashMap。如果需要元素的自然排序或者指定的比较器进行排序，则应该选择TreeSet或TreeMap。如果需要线程安全，则应该选择Vector或HashTable。
Java代码示例：

1. 有序并允许重复元素的集合 List

List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("Java");
System.out.println(list);

2. 无序并且不允许重复元素的集合 Set

Set<String> set=new HashSet<String>();
set.add("Hello");
set.add("World");
set.add("Java");
System.out.println(set);

3. 维护映射关系的集合 Map

Map<String,Integer> map=new HashMap<String,Integer>();
map.put("Hello",1);
map.put("World",2);
map.put("Java",3);
System.out.println(map);

4. 高效的随机访问和修改元素 ArrayList

List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("Java");
System.out.println(list.get(1));
list.set(1,"Python");
System.out.println(list);

5. 高效的添加和删除元素 LinkedList

List<String> list=new LinkedList<String>();
list.add("Hello");
list.add("World");
list.add("Java");
System.out.println(list);
list.addFirst("Python");
list.removeLast();
System.out.println(list);

6. 维护元素的插入顺序 LinkedHashSet

Set<String> set=new LinkedHashSet<String>();
set.add("Hello");
set.add("World");
set.add("Java");
System.out.println(set);

7. 元素的自然排序或者指定的比较器进行排序 TreeSet

Set<String> set=new TreeSet<String>();
set.add("Hello");
set.add("World");
set.add("Java");
System.out.println(set);

8. 线程安全 Vector

List<String> list=new Vector<String>();
list.add("Hello");
list.add("World");
list.add("Java");
System.out.println(list);

9. 线程安全 HashTable

Map<String,Integer> map=new Hashtable<String,Integer>();
map.put("Hello",1);
map.put("World",2);
map.put("Java",3);
System.out.println(map);

如果您需要转载或者搬运这篇文章的话，非常欢迎您私信我哦~