Java中List集合的介绍

最新推荐文章于 2025-03-09 09:15:00 发布

于嗟鸠兮

最新推荐文章于 2025-03-09 09:15:00 发布

阅读量3.8k

点赞数 2

分类专栏： java 学习 SpringBoot 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_37282601/article/details/125149462

版权

学习同时被 3 个专栏收录

17 篇文章

订阅专栏

SpringBoot

4 篇文章

订阅专栏

java

2 篇文章

订阅专栏

本文介绍了Java中的List集合，包括ArrayList和LinkedList的实现原理和特性。ArrayList基于数组，适合随机访问，而LinkedList基于链表，擅长元素新增。在实际性能测试中，ArrayList的新增性能因JDK优化而提升，但在元素获取上优于LinkedList。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

List 是什么
JavaList集合是指由JavaList接口以及List接口的所有实现类组成的集合。
List集合中的元素允许重复,各元素的顺序放是对象插入的顺序.类似Java中的数组,用户可通过使用索引(元素在集合中的位置)来访问集合中的元素.

1.Java集合介绍

Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象。在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java.util包中。

Java集合主要由2大体系构成，分别是Collection体系和Map体系，其中Collection和Map分别是2大体系中的顶层接口。

Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复。

List中主要有ArrayList、LinkedList两个实现类；Set中则是有HashSet实现类；而Queue是在JDK1.5后才出现的新集合，主要以数组和链表两种形式存在。

Map同属于java.util包中，是集合的一部分，但与Collection是相互独立的，没有任何关系。Map中都是以key-value的形式存在，其中key必须唯一，主要有HashMap、HashTable、treeMap三个实现类。
在这里插入图片描述

2.List介绍

在Collection中，List集合是有序的，可对其中每个元素的插入位置进行精确地控制，可以通过索引来访问元素，遍历元素。

在List集合中，我们常用到ArrayList和LinkedList这两个类

2.1 ArrayList集合

ArrayList底层通过数组实现，随着元素的增加而动态扩容。
ArrayList是Java集合框架中使用最多的一个类，是一个数组队列，线程不安全集合。
它继承于AbstractList，实现了List, RandomAccess, Cloneable, Serializable接口。
ArrayList实现List，得到了List集合框架基础功能；
ArrayList实现RandomAccess，获得了快速随机访问存储元素的功能，RandomAccess是一个标记接口，没有任何方法；
ArrayList实现Cloneable，得到了clone()方法，可以实现克隆功能；
ArrayList实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。

ArrayList集合的特点：

容量不固定，随着容量的增加而动态扩容（阈值基本不会达到）
有序集合（插入的顺序==输出的顺序）
插入的元素可以为null
增删改查效率更高（相对于LinkedList来说）
线程不安全

ArrayList的底层数据结构：

2.2 LinkedList集合

LinkedList底层通过链表来实现，随着元素的增加不断向链表的后端增加节点。
LinkedList是一个双向链表，每一个节点都拥有指向前后节点的引用。相比于ArrayList来说，LinkedList的随机访问效率更低。
它继承AbstractSequentialList，实现了List, Deque, Cloneable, Serializable接口。
LinkedList实现List，得到了List集合框架基础功能；
LinkedList实现Deque，Deque 是一个双向队列，也就是既可以先入先出，又可以先入后出，说简单点就是既可以在头部添加元素，也可以在尾部添加元素；
LinkedList实现Cloneable，得到了clone()方法，可以实现克隆功能；
LinkedList实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。

LinkedList集合的底层数据结构：

LinkedList集合的底层数据结构

3.List常用方法

A:添加功能
boolean add(E e):向集合中添加一个元素
void add(int index, E element):在指定位置添加元素
boolean addAll(Collection<? extends E> c)：向集合中添加一个集合的元素。

B:删除功能
void clear()：删除集合中的所有元素
E remove(int index)：根据指定索引删除元素，并把删除的元素返回
boolean remove(Object o)：从集合中删除指定的元素
boolean removeAll(Collection<?> c):从集合中删除一个指定的集合元素。

C:修改功能
E set(int index, E element):把指定索引位置的元素修改为指定的值，返回修改前的值。

D:获取功能
E get(int index)：获取指定位置的元素
Iterator iterator():就是用来获取集合中每一个元素。

E:判断功能
boolean isEmpty()：判断集合是否为空。
boolean contains(Object o)：判断集合中是否存在指定的元素。
boolean containsAll(Collection<?> c)：判断集合中是否存在指定的一个集合中的元素。

F:长度功能
int size():获取集合中的元素个数

G:把集合转换成数组
Object[] toArray():把集合变成数组。

3.1 ArrayList 基本操作

public class ArrayListTest {
    public static void main(String[] agrs){
        //创建ArrayList集合：
        List<String> list = new ArrayList<String>();
        System.out.println("ArrayList集合初始化容量："+list.size());
		// ArrayList集合初始化容量：0
        
        //添加功能：
        list.add("Hello");
        list.add("world");
        list.add(2,"!");
        System.out.println("ArrayList当前容量："+list.size());
        // ArrayList当前容量：3

        //修改功能：
        list.set(0,"my");
        list.set(1,"name");
        System.out.println("ArrayList当前内容："+list.toString());
        // ArrayList当前内容：[my, name, !]

        //获取功能：
        String element = list.get(0);
        System.out.println(element);
        // my

        //迭代器遍历集合：(ArrayList实际的跌倒器是Itr对象)
        Iterator<String> iterator =  list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**  
        	my
            name
            !
        */

        //for循环迭代集合：
        for(String str:list){
            System.out.println(str);
        }
        /**  
        	my
            name
            !
        */

        //判断功能：
        boolean isEmpty = list.isEmpty();
        boolean isContain = list.contains("my");

        //长度功能：
        int size = list.size();

        //把集合转换成数组：
        String[] strArray = list.toArray(new String[]{});

        //删除功能：
        list.remove(0);
        list.remove("world");
        list.clear();
        System.out.println("ArrayList当前容量："+list.size());
        // ArrayList当前容量：0
    }
}

3.2 LinkedList 基本操作

public class LinkedListTest {
    public static void main(String[] agrs){
        List<String> linkedList = new LinkedList<String>();
        System.out.println("LinkedList初始容量："+linkedList.size());
        // LinkedList初始容量：0

        //添加功能：
        linkedList.add("my");
        linkedList.add("name");
        linkedList.add("is");
        linkedList.add("jiaboyan");
        System.out.println("LinkedList当前容量："+ linkedList.size());
        // LinkedList当前容量：4

        //修改功能:
        linkedList.set(0,"hello");
        linkedList.set(1,"world");
        System.out.println("LinkedList当前内容："+ linkedList.toString());
        // LinkedList当前内容：[hello, world, is, jiaboyan]

        //获取功能：
        String element = linkedList.get(0);
        System.out.println(element);
        // hello

        //遍历集合：(LinkedList实际的迭代器是ListItr对象)
        Iterator<String> iterator =  linkedList.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */
        
        //for循环迭代集合：
        for(String str:linkedList){
            System.out.println(str);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */

        //判断功能：
        boolean isEmpty = linkedList.isEmpty();
        boolean isContains = linkedList.contains("jiaboyan");

        //长度功能：
        int size = linkedList.size();

        //删除功能：
        linkedList.remove(0);
        linkedList.remove("jiaboyan");
        linkedList.clear();
        System.out.println("LinkedList当前容量：" + linkedList.size());
        // LinkedList当前容量：0
    }
}

4.ArrayList和LinkedList比较

元素新增性能比较

网上很多说的是，在做新增操作时，ArrayList的效率远不如LinkedList，因为Arraylist底层时数组实现的，在动态扩容时，性能会有所损耗，而LinkedList不存在数组扩容机制，所以LinkedList的新增性能较好。究竟时哪个好呢，我们用实践得到结果。

public class ListTest{
    // 迭代次数
    public static int ITERATION_NUM = 100000;

    public static void main(String[] args) {
        try{
            insertPerformanceCompare();
        }catch (Exception e){}
    }

    //新增性能比较：
    public static void insertPerformanceCompare() throws InterruptedException {
        Thread.sleep(5000);

        long start = System.nanoTime();
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }
        long end = System.nanoTime();
        System.out.println("LinkedList获取测试开始 " + (end - start));

        start = System.nanoTime();
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }
        end = System.nanoTime();
        System.out.println("ArrayList获取测试开始 " + (end - start));
    }
}

测试结果：

第一次：
LinkedList新增测试开始 10873720
ArrayList新增测试开始 5535277
第二次：
LinkedList新增测试开始 13097503
ArrayList新增测试开始 6046139
第三次：
LinkedList新增测试开始 12004669
ArrayList新增测试开始 6509783

结果与预想的有些不太一样，ArrayList的新增性能并不低。

原因：

可能是经过JDK近几年的更新发展，对于数组复制的实现进行了优化，以至于ArrayList的性能也得到了提高。

元素获取比较

由于LinkedList是链表结构，没有角标的概念，没有实现RandomAccess接口，不具备随机元素访问功能，所以在get方面表现的差强人意，ArrayList再一次完胜。

public class ListTest {
    //迭代次数，集合大小：
    public static int ITERATION_NUM = 100000;

    public static void main(String[] agrs) {
       try{
            getPerformanceCompare();
        }catch (Exception e){}
    }

    //获取性能比较：
    public static void getPerformanceCompare()throws InterruptedException {
        Thread.sleep(5000);

        //填充ArrayList集合：
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }

        //填充LinkedList集合：
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }

        //创建随机数对象：
        Random random = new Random();

        long start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = linkedList.get(j);
        }
        long end = System.nanoTime();
        System.out.println("LinkedList获取测试开始 " + (end - start));

        start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = arrayList.get(j);
        }
        end = System.nanoTime();
        System.out.println("ArrayList获取测试开始 " + (end - start));
    }
}

测试结果：

第一次：
LinkedList获取测试开始 8190063123
ArrayList获取测试开始 8590205
第二次：
LinkedList获取测试开始 8100623160
ArrayList获取测试开始 11948919
第三次：
LinkedList获取测试开始 8237722833
ArrayList获取测试开始 6333427