List集合源码深度解析

最新推荐文章于 2023-08-02 19:13:40 发布
最新推荐文章于 2023-08-02 19:13:40 发布
阅读量220 收藏
点赞数
分类专栏： 集合源码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ctycsdn/article/details/106653868
版权

ArrayList源码分析

自定义List集合接口

package com.mayikt.ext;

/**
 * @Description: 自定义List集合
 * @Author: ChenYi
 * @Date: 2020/06/09 20:43
 **/

public interface MayiktList<E> {
    /**
     * 集合的大小
     *
     * @return
     */
    int size();

    /**
     * 往集合中添加元素
     *
     * @param e
     * @return
     */
    boolean add(E e);

    /**
     * 通过索引获取集合的元素
     *
     * @param index
     * @return
     */
    E get(int index);
}

自定义ArrayList类

package com.mayikt.ext.impl;

import com.mayikt.ext.MayiktList;

import java.util.Arrays;

/**
 * @Description: 自定义ArrayList
 * @Author: ChenYi
 * @Date: 2020/06/09 20:46
 **/

public class MayiktArrayList<E> implements MayiktList<E> {
    /**
     * 初始化空的数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
     * 数组的容量，transient代表该变量不能被序列化
     */
    transient Object[] elementData;
    /**
     * 集合的大小
     */
    private int size;
    /**
     * ArrayList默认的初始容量
     */
    private static final int DEFAULT_CAPACITY = 10;


    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    protected transient int modCount = 0;

    public MayiktArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public boolean add(E e) {
        //初始化集合的大小
        ensureCapacityInternal(size + 1);
        //赋值
        elementData[size++] = e;
        return true;
    }

    @Override
    public E get(int index) {
        return (E) elementData[index];
    }

    @Override
    public E remove(int index) {
        //检测数组是否越界
        rangeCheck(index);
        //保证线程安全性
        modCount++;
        E oldValue = get(index);
        int numMoved = size - index - 1;
        //检测如果是删除最后一位的话直接把最后一位置空
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        }
        //最后索引位置置空
        elementData[--size] = null;

        return oldValue;
    }

    private void ensureCapacityInternal(int minCapacity) {

        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //没有指定集合容量的大小并且是第一次添加元素的时候进来
            //minCapacity=0+1   DEFAULT_CAPACITY=10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //第一次初始化的集合的大小为10
        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        //保证线程的安全性，如果同时写入的话就可能报错
        modCount++;
        //判断数组是否需要扩容
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }

    /**
     * 判断数组是否越界
     *
     * @param index
     */
    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    private void grow(int minCapacity) {
        // 第一次elementData为空数组 0
        int oldCapacity = elementData.length;
        /**
         *  >>位运算  向右移动相当于/2  左移相当于*2
         *   0+0/2=0
         */
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 0-10
        if (newCapacity - minCapacity < 0) {
            //第一次扩容的时候才进来 10
            newCapacity = minCapacity;
        }
        //集合的最大容量是2 的21次方
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            newCapacity = hugeCapacity(minCapacity);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) {
            throw new OutOfMemoryError();
        }
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }
}

总结：

  • 使用无参构建函数new出ArrayList集合的时候，数组的容量是0，elementData是一个空的数组
  • 第一次添加的时候才会初始化数组的大小，会调用grow方法进行扩容，初始化的大小为10
  • 每次扩容的时候，数组的长度增加0.5倍
  • 数组最大的长度是Interger的最大值
  • 集合删除元素之后，数组是不会缩容的，对应的位置置为null
  • 由于ArrayList是线程不安全的，在高并发的情况下会出现Fail-Fast，所以里面用了一个modCount来保证线程的安全。

CopyOnWriteArrayList源码分析

自定义的CopyOnWriteArrayList类

package com.mayikt.ext.impl;

import com.mayikt.ext.MayiktList;

import java.util.Arrays;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Description: 自定义CopyOnWriteArrayList
 * @Author: ChenYi
 * @Date: 2020/06/11 07:46
 **/

public class MayiktCopyOnWriteArrayList<E> implements MayiktList<E> {
    final transient ReentrantLock lock = new ReentrantLock();
    private transient volatile Object[] array;

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        //加lock能够保证线程的安全
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //每次添加都要把之前的数组复制到新的数组中
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

    final Object[] getArray() {
        return array;
    }


    public MayiktCopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    final void setArray(Object[] a) {
        array = a;
    }

    @Override
    public E get(int index) {
        return get(getArray(), index);
    }

    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    @Override
    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            int numMoved = len - index - 1;
            if (numMoved == 0) {
                setArray(Arrays.copyOf(elements, len - 1));
            } else {
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                        numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }
}

总结:

  • 使用无参构建对象的时候，默认的数组也是空的
  • 每次添加元素的时候都会加Lock锁，原来的数组长度加1，创建出新的数组，然后把之前的值放进去，没有存在扩容的操作。
  • 读的时候是没有加Lock锁的，所以读取的时候效率比较快。

Vector源码解析

自定义的Vector类

package com.mayikt.ext.impl;

import com.mayikt.ext.MayiktList;

import java.util.Arrays;

/**
 * @Description: 自定义Vector集合
 * @Author: ChenYi
 * @Date: 2020/06/11 08:19
 **/

public class MayiktVector<E> implements MayiktList<E> {
    protected int capacityIncrement;
    protected Object[] elementData;

    protected transient int modCount = 0;

    protected int elementCount;

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    public MayiktVector() {
        this(10);
    }

    public MayiktVector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    public MayiktVector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            newCapacity = hugeCapacity(minCapacity);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) {
            throw new OutOfMemoryError();
        }
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

    @Override
    public synchronized E get(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        return elementData(index);
    }

    E elementData(int index) {
        return (E) elementData[index];
    }

    @Override
    public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        }
        elementData[--elementCount] = null;
        return oldValue;
    }
}

总结：

  • 使用无参构建创建对象的时候默认创建容量为10的数组
  • 存在扩容的原理，跟ArrayList一样，只是线程是安全的，在修改或者读取数据的时候都加了synchronized关键字，效率很低，capacityIncrement没有指定的时候，扩容默认是扩大一倍的

LinkeList源码分析

自定义的LinkList类

package com.mayikt.ext.impl;

import com.mayikt.ext.MayiktList;

import java.util.Objects;

/**
 * @Description:自定义LinkList集合
 * @Author: ChenYi
 * @Date: 2020/06/20 09:11
 **/

public class MayiktLinkList<E> implements MayiktList<E> {
    transient int size = 0;
    transient MayiktLinkList.Node<E> first;
    transient MayiktLinkList.Node<E> last;
    protected transient int modCount = 0;

    public MayiktLinkList() {
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    private void linkLast(E e) {
        final MayiktLinkList.Node<E> l = last;
        final MayiktLinkList.Node<E> newNode = new MayiktLinkList.Node<>(l, e, null);
        last = newNode;
        if (l == null) {
            //链表的第一个元素
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
        modCount++;
    }

    @Override
    public E get(int index) throws Exception {
        checkElementIndex(index);
        return (E) node(index).item;
    }

    private MayiktLinkList.Node node(int index) {
        //采用折半查找
        MayiktLinkList.Node x;
        if (index <= size >> 1) {
            x = first;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
        } else {
            x = last;
            for (int i = size - 1; i > index; i--) {
                x = x.prev;
            }
        }
        return x;
    }

    private void checkElementIndex(int index) throws Exception {
        if (isElementIndex(index)) {
            return;
        }
        throw new Exception("数组越界!!!");
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    @Override
    public E remove(int index) throws Exception {
        checkElementIndex(index);
        return unlink(node(index));
    }

    private E unlink(Node current) {
        //要删除节点的上节点
        Object item = current.item;
        Node prev = current.prev;
        //要删除节点的下节点
        Node next = current.next;
        //说明删除的是第一个元素
        if (Objects.isNull(prev)) {
            first = next;
        } else {
            prev.next = next;
            //设置为空给垃圾回收
            current.prev = null;
        }
        //说明删除最后一个元素
        if (Objects.isNull(next)) {
            last = prev;
        } else {
            next.prev = prev;
            //设置为空给gc回收
            current.next = null;
        }
        //设置为空
        current.item = null;
        size--;
        modCount++;
        return (E) item;
    }

    private static class Node<E> {
        E item;
        MayiktLinkList.Node<E> next;
        MayiktLinkList.Node<E> prev;

        Node(MayiktLinkList.Node<E> prev, E element, MayiktLinkList.Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}

总结：

  • 底层是采用双链表的数据结构来存储数据的，底层采用了静态内部类Node节点存放节点元素，包含指向上个节点的指针prev，当前的数据item,下个节点的指针next,链表是不需要扩容的，因为长度是可以不断变化的，数组的数据结构才需要扩容
  • add原理是一直在链表之后添加
  • get的原理是采用折半查询，查询效率比较低，时间复杂度是O(n/2)
  • remove的原理是改变上下节点的指针

参考：来自蚂蚁课堂

陈菜头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Csharp案例开发源码.zip
06-18
《C#案例开发源码深度解析》 C#是一种由微软公司推出的面向对象的编程语言，它是.NET框架的重要组成部分，广泛应用于Windows桌面应用、Web应用、游戏开发、移动应用等多个领域。本篇将深入探讨在C#案例开发中的关键...
List 源码分析
sermonlizhi的博客
12-26 1748
在Java中，List接口的继承结构图大概如图所示，其中最上层的Iterable接口和Collection接口是所有Java集合类都需要实现的接口，Iterable接口提供了iterator()方法，可以返回一个Iterator对象，而Iterator也是一个接口，所有实现了Iterable接口的集合类都需要重写iterator()方法，并且在集合类内部还需要实现Iterator接口的next()等方法用于迭代。 这篇文章就从源码的层面来看看这些常用的List接口的实现类 一、ArrayList 顾名思义
List集合源码解析
weixin_45432729的博客
01-26 144
ArrayList与LinkedList源码解析
【C++从0到王者】第十五站：list源码分析及手把手教你写一个list
最新发布
青色_忘川的博客
08-02 795
list源码分析以及手把手教你写一个简单的list
List源码浅析(java)
weixin_60257072的博客
10-17 461
-----------------------以下是摘自List源码作者介绍有序集合（也称为序列）。此界面的用户可以精确控制每个元素在列表中的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并在列表中搜索元素。与集合不同，列表通常允许重复元素。更正式地说，列表通常允许元素对e1和e2如此e1.equals(e2) ，并且如果它们完全允许 ​​null 元素，它们通常允许多个 null 元素。
c# 泛型、集合应用实例源码
03-26
SortedList, TValue>是泛型集合的一种，它是一个有序的键值对集合，键和值都是泛型类型。与Dictionary, TValue>不同，SortedList, TValue>会根据键的自然顺序进行排序。这对于需要按特定顺序访问数据的情况非常有用...
STL源码剖析_C++STL_stl源码c++_
09-29
总的来说，《STL源码剖析》是一本深度解析C++标准模板库的书籍，对于想要提升C++编程技巧，特别是对STL有深入需求的开发者来说，是不可多得的参考资料。通过阅读这本书，读者不仅可以掌握STL的基本使用，还能了解其...
C++_STL源码高清中文版
05-04
1. 容器：容器是STL中用于存储数据的对象，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（键值对映射）等。它们提供了统一的操作接口，使得我们可以方便地进行数据的...
精通Hibernate源码
05-14
《精通Hibernate源码》是孙卫琴先生的一部深度解析Hibernate框架源码的著作，旨在帮助读者深入理解这个流行的Java持久层框架的工作原理。通过学习本书，开发者可以提升对ORM(Object-Relational Mapping)技术的理解，...
Java集合List源码解读
weixin_39527237的博客
04-11 652
对Java集合List，ArrayList、Vector、LinkedList源码解读，了解它们的底层数据结构以及ArrayList、Vector的扩容机制
List源码解析
weixin_37337210的博客
09-28 348
开始看一下集合Collection，List是Collection的一个子接口，主要是看一下其下的几个类。 1、AbstractList 2、ArrayList 3、Collections.synchronizedList 4、Vector 5、LinkedList 6、CopyOnWriteArrayList 一、AbstractList 这是一个抽象类，其是实现List接口基础类，像ArrayList、LinkedList和Vector都是继承此抽象类的。 1》如果要实现一个不可变的列
java集合框架之List以及源码分析(二)
蓝色的青春_巍
08-25 451
前言:上次我们分析Collection接口的一些通用功能,还有一些源码的简单分析,接下来我们继续从上往下分析,了解每个接口的特性,以及每个接口下面的实现类底层源码是如何实现的. 一、List接口的特性 官方描述： 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。 首先List接口继承了Collection接口，是一...
List集合源码解析原理和用法
大白猿的专栏
10-31 7072
注：以下所用源码均基于JDK1.8基础（特殊说明除外） 先从源码入手解析： public interface List&lt;E&gt; extends Collection&lt;E&gt; {} An ordered collection (also known as a &lt;i&gt;sequence&lt;/i&gt;). The user of this interfa...
List集合及源码分析
Serendipity的博客
01-24 389
1. 集合体系图 Collection接口，Collection接口有两个重要的子接口 1.List 2. Set 。这俩的实现子类都是单列集合，即存放的都是单个单个的数据 Map接口的实现子类是双列集合，即存放数据的形式是以key-value的形式进行存放 2. Collection collection实现子类可以存放多个元素，每个元素可以是Object 有些Collection的实现类，可以存放重复的元素，有些不可以 有些Collection的实现类，有些是有序的（List），有些不是有序的（S
Java Collection Framework : List
Rico's Blogs
10-28 8449
List 包括 List接口以及List接口的所有实现类。因为 List 接口实现了 Collection 接口，所以 List 接口拥有 Collection 接口提供的所有方法，同时又因为 List 是列表类型，所以 List 接口还提供了一些适合自身的方法。ArrayList 是一个动态数组，实现了数组动态扩容，随机访问效率高；LinkedList是一个双向链表，随机插入、随机删除效率高，可用作队列的实现。
Java 集合之 List 详解与源码分析
程序员学习圈
04-12 1369
1.ArrayList、LinkedList、Vector的异同与使用场景  一般来说，ArrayList与Vector都是使用数组来存储，LinkedList是使用双向链表进行存储，所以，ArrayList和Vector查找元素比较快，因为数组可以直接根据位置进行定位，而双向链表还需要根据链表头或者链表尾进行遍历查询。而在插入元素时，一般来说LinkedList比较快，因为双向链表只需要找到插入...
java集合整理 List源码解析
奔波儿灞
05-19 698
数组： /** * 数组大小固定，存储有序（存和取顺序一直） * 直接打印输出对象需要重写toString()方法，否则会调用父类的toString()打印的是引用地址值 */ Student[] students = new Student[5]; students[0] = new Student(&amp;quot;张三&amp;quot;...
Java集合框架深度解析：Map、Set、List源码探秘
"这份PDF文档详细解析了Java编程中常见的集合框架——Map、Set、List的底层实现原理，并结合数据结构的基础知识，特别是树的概念，进行了深入的探讨。文档内容包括Map底层原理分析、LinkedList和ArrayList的原理分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值