Java常见集合源码分析1：List

已于 2022-03-07 01:41:14 修改
阅读量386 收藏
点赞数
分类专栏： Java基础 文章标签： java list
于 2022-03-07 01:39:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dabaixiaozhu/article/details/123321227
版权

集合的分类

首先来看一下集合的整体分类。
Collection和Set中文都可以翻译成集合。但是从Java编程角度，Collection应该被翻译成容器，Set翻译成集合。
Collection和Set中文都可以翻译成集合。但是从Java编程角度，Collection应该被翻译成容器，Set翻译成集合。

ListSet
顺序性有序无序
重复性可重复不可重复
索引可通过索引操作元素，即可使用普通for循环遍历没有索引，即不可使用普通for循环遍历。

在这里插入图片描述

1.ArrayList

基本原理及优缺点

数组的长度是固定的，比如为100，当元素数量超过了100以后会扩容，把以前的数组拷贝到新的数组里。

缺点是：

  1. 数组扩容+元素拷贝的过程，会慢一些，所以不要频繁插入数据。
  2. 要是往数组的中间加一个元素，新增元素后面的全部元素需要往后面挪动一位，性能较差。

优点是：

  1. 因为基于数组来实现，可以通过内存地址来定位某个元素，所以在随机获取数组里的某个元素的时候，性能很高。

适用场景：

  1. ArrayList的元素按照插入的顺序来排列。
  2. 适用于查多插入频率低的场景。

源码分析

构造函数

默认的构造函数，会将内部的数组做成一个默认的空数组。

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

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

默认的初始化数组的大小是10，但是不是在初始化的时候进行赋值的，详看 List 数组扩容，是在第一次add中进行赋值的。

默认的值太小了，所以构造ArrayList一般会给一个大小，比如100个数据，避免数组太小。

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

add()方法的源码

会导致数组元素的移动。

每次往ArrayList中添加数据，都会判断当前数组的元素是满了。

如果满了，就会扩容数组，然后将老数组中的元素拷贝到新数组中。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

set()方法的源码

public E set(int index, E element) {
    // 检查是否越界
    rangeCheck(index);

    // 获取原本的值
    E oldValue = elementData(index);
    // 设置新值
    elementData[index] = element;
    // 返回原本的值
    return oldValue;
}


private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}


transient Object[] elementData;

@SuppressWarnings("unchecked")
E elementData(int index) {
    // 获取到i位置原本的值，李四
    return (E) elementData[index];
}

add(index, element)方法的源码

public void add(int index, E element) {
    // 判断越界
    rangeCheckForAdd(index);

    // 确保数组能添加这个元素，直接+1
    ensureCapacityInternal(size + 1);
    // 进行数据拷贝，看注释
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 上面相当于是数据向后移动一格，当前index进行赋值 
    elementData[index] = element;
    size++;
}

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

// 将elementData从第1位开始，拷贝到第二位，总共拷贝两个元素
// System.arraycopy(elementData, 1, elementData, 2, 2);

get()方法的源码

从数组中直接取出元素，是优点所在。

public E get(int index) {
    // 检查数组越界
    rangeCheck(index);

    // 直接返回
    return elementData(index);
}

remove()方法的源码

会导致数组元素的移动。

public class ArrayList<E> {
    public E remove(int index) {
        // 检查越界
        rangeCheck(index);
    
        // list长度变化的次数：增、删
        modCount++;
        E oldValue = elementData(index);
        
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 相当于把index+1位置的元素，全部往前移动一位
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 末尾那位设置为null，让垃圾回收去回收对象 
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }
}

public abstract class AbstractList<E> {
    protected transient int modCount = 0;
}

数组扩容以及元素拷贝

默认情况，第一次add()，会给数组默认赋值10。

从add()方法中进入。

假设一个数组的大小是10，且已经添加了10个元素，此时数组的size = 10，capacity = 10。

此时调用add()方法插入一个元素，无法插入第11个元素。

默认是扩大1.5倍。

transient Object[] elementData;

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}


private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// elementData已经填充了10个元素了，minCapacity = 11
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果是空数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 跟默认的10去比
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 表示是要扩大数组
    // elementData.length默认就是10
    if (minCapacity - elementData.length > 0)
        // 进行扩容
        grow(minCapacity);
}

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

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // oldCapacity >> 1 = oldCapacity / 2 = 5
    // newCapacity = 15
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 还是太小
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 新数组太大
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        // 得到一个超大的值
        newCapacity = hugeCapacity(minCapacity);
    // 完成老数组到新数组的拷贝
    elementData = Arrays.copyOf(elementData, newCapacity);
}

2.LinkedList

基本原理以及优缺点

LinkedList，底层是基于双向链表数据结构来实现的。
在这里插入图片描述

优点：

  1. 大量的插入时不需要像ArrayList那样去扩容，不断的把新的节点挂到链表上就可以了。所以适合频繁的插入和删除操作。
  2. LinkedList可以当做队列来用，先进先出，在list尾部怼进去一个元素，从头部拿出来一个元素。

缺点：

  1. 不适合获取元素，因为需要遍历整个链表，直到找到index = 10的这个元素。

插入元素的原理

add()

在双向链表的尾部插入一个元素。

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

/**
 * Links e as last element.
 */
void linkLast(E e) {
    // 原本的尾节点
    final Node<E> l = last;
    // 封装一个新的node 具体代表的含义如下类所示
    final Node<E> newNode = new Node<>(l, e, null);
    // 进行覆盖
    last = newNode;
    // 表示原本就是空List
    if (l == null)
        // 重新给头结点赋值
        first = newNode;
    else
        // 改变原本l的下一个指向
        l.next = newNode;
    size++;
    // list长度是有变化的
    modCount++;
}

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

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

add(index, element)

是在队列的中间插入一个元素。

public void add(int index, E element) {
    // 保证>=0 <=size，直接点进去看，很简单
    checkPositionIndex(index);

    // 插在队尾
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

// 获取index位置的node
Node<E> node(int index) {
    // 插入位置在list的前半部分
    if (index < (size >> 1)) {
        // 从头部开始遍历，得到index位置的节点
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } 
    // 插入的位置在队列的后半部分
    else {
        // 从尾部开始逆着遍历，得到index位置的节点
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // index 位置的 Node，前一位 Node 需要指向 值为e的node
    final Node<E> pred = succ.prev;
    // 新增的节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 重新指向，如上
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

addFirst()

在队列的头部插入一个元素。

public void addFirst(E e) {
    linkFirst(e);
}

private void linkFirst(E e) {
    // 得到头结点
    final Node<E> f = first;
    // 新建一个头结点
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        // 原本的头结点，指向新的头结点
        f.prev = newNode;
    size++;
    modCount++;
}

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

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

addLast()

跟add()方法是一样的，也是在尾部插入一个元素。

public void addLast(E e) {
    linkLast(e);
}

获取元素的原理

poll()，从队列头部出队

peek()，获取队列头部的元素，但是头部的元素不出队

getFirst()

getFirst() == peek()

获取头部的元素，直接返回first指针，指向的Node里的数据。

public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

transient Node<E> first;

getLast()

获取尾部的元素。

public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

get(int index)

这个方法性能差，使用node(index)这个方法（），要进行链表的遍历。

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 获取index位置的 node
Node<E> node(int index) {
    // 插入位置在list的前半部分
    if (index < (size >> 1)) {
        // 从头部开始遍历，得到index位置的节点
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } 
    // 插入的位置在队列的后半部分
    else {
        // 从尾部开始逆着遍历，得到index位置的节点
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

删除元素的原理

removeLast()

public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    
    // 让jvm的垃圾回收自动去收
    l.item = null;
    l.prev = null; // help GC
    // 链表的重新指向
    last = prev;
    
    // 原本只有一个元素
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

removeFirst()

removeFirst() == poll()
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    
    // 双向链表的重新指向
    f.item = null;
    f.next = null; // help GC
    first = next;
    
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

remove(int index)

public E remove(int index) {
    // 不越界
    checkElementIndex(index);
    return unlink(node(index));
}


E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        // 前节点的指向
        prev.next = next;
        // 要删除节点本身的前后指向，也要指向null，让垃圾回收回收掉
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        // 后节点的指向
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

注

可能一篇笔记，找了很多篇文章才解决一个问题，如有引用未贴的来源，请告知补上，水平有限，如有错误欢迎评论。

dabaixiaozhu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合源码全面分析
09-02
在本文中，我们将全面分析Java集合框架的核心概念和实现细节。 首先，Java集合框架的基础是`Collection`接口，它是所有集合类的根接口，定义了集合的基本操作。`Collection`接口有两个重要的子接口：`List`和`Set`...
java8集合源码分析-Outline:大纲
06-04
集合源码分析 JAVA： 基本语法 static 修饰变量 方法 静态块(初始化块 构造函数 ) 静态内部类() 静态导包 final() transient() foreach循环原理() volatile底层实现() equals和hashcode(, ) string,stringbuffer和...
java List集合源码
weixin_45793819的博客
03-26 381
单例集合 单个的数据 多例集合 两个的数据 迭代遍历 编译类型 是object 运行类型是 传入的类型 如果遍历完了需要重重置（重新赋值） 遍历的快捷键 itit I 大写 i 集合的API 更具索添加 编译类型 运行类型 左边是编译类型 右边是运行类型 排序 ArrayList 源码 有参构造的集合源码和无惨无参构造的一样 ，只有两点差别 第一是指定数组大小 第二点是 直接按照扩容的一点五倍 无参构造函数的源码 Vector 底层源码
java之list源代码浅析
weixin_30782331的博客
05-18 139
三大数据结构链表、树和图，顺序表作为当中的一种，能够说是平时编程中最长使用到的。List接口是顺序表在java中的实现。它有非常多子接口和实现类，平时的编程中使用起来非常方便。可是更进一步，我们有必要对事实上现和原理进行理解，并和数据结构中所学比較，并应用于平时的编程中，编写出高效率的代码。 首先看下list接口的层次关系，下图由本人依据jdk的类结构简单画的： ...
java的list源码_Java源码之各种List
weixin_33430573的博客
02-25 136
在C中，我们通常会用链表，用数组来处理顺序的结构，Java中，为了方便，通常会选用List来完成各种操作Java中常见的List有：ArrayList,LinkedList(参见Java.util.各种List)ArrayListpublic class ArrayList extends AbstractListimplements List, RandomAccess, Cloneable, ...
面试3-Java常见集合源码List
dev晴天的博客
05-31 95
一、ArrayList 自己通过动态数组模拟下ArrayList的功能，就对ArrayList了解个差不多了 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable 1、ArrayList的默认容量大小&扩容机制 在JDK1.8中，ArrayList底层Object[]
Java集合源码浅析（一） ： ArrayList
冷血之心的博客
04-12 1660
（尊重劳动成果，转载请注明出处：https://yangwenqiang.blog.csdn.net/article/details/105317442冷血之心的博客） 背景 一直都有这么一个打算，那就是将Java中常见集合的源码进行一个全面的梳理（尽管已经有很多人进行了梳理总结）。重复造轮子的意义就在于，笔者可以亲自去阅读与欣赏JDK集合源码，学习JDK设计者们那优雅的code风格。 那么，就...
Java集合List接口详解——含源码分析
秋名山码民的技术小屋
10-24 7981
在Java编程中，可以使用数组来保存多个对象，但数组长度不可变化，一旦在初始化数组时指定了数组长度，这个数组长度就是不可变的。首先我们要明白要用普通for循环，就要有索引方法，来获取元素，而List继承Collection，多出的get方法，使得我们可以获取索引，继而使用普通for循环。为啥突然换成jdk17了？前几天电脑崩了，脑子一糊涂，c盘删了10个g的文件，被迫用笔记本来看源码了，hh。不难看出，初始数组为0，只有当你添加对象的时候，才重新赋值为新的数组，且初始赋值为长度为10的数组。
Java集合学习1：Collection集合、List
10-17 3万+
什么是集合 概念：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能。 和数组的区别 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型 进行集合接口的学习时候，多看JDK的API。里面有很多方法，可以自己研究。 Collection体系集合 iterator（）是collection的元素上进行迭代的迭代器。 Collection实践 1、添加元素 2、删除元素 3、遍历元素 4、判断 首先创建一个集合，并添加元素。 删除元素、与清空元素 判
java集合框架List子接口之LinkedList源码剖析
刘跃辉的博客
09-05 9万+
LinkendList是一个双向链表 , 并且实现了Deque接口 , 可以作为一个队列来使用 , 虽然LinkendList是线性结构 , 但是数据的存储并不是按照线性的接口来存储的 , 而是在每一个节点里存数据及下一个节点的地址, 同时实现了Cloneable接口 , 支持拷贝 , 并且实现了java.io.Serializable支持序列化和反序列化Cloneable , Serializable接口直通车 : java框架集合List子接口之ArrayList源码剖析数据结构直通车 : 数据结构之
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
Java集合Set接口详解——含源码分析
秋名山码民的技术小屋
10-26 1万+
前几天我们看了Java集合List接口详解——含源码分析，今天我们看一个数据一个数据存储的另一个接口——Set。这里挖一个坑，后面我们来讲一下二叉查找树，hh，挖坑没停止。
java8集合源码分析-blog:博客
06-04
这次我们将深入探讨Java 8在集合框架上引入的新特性和源码分析。 首先，Java 8对集合框架进行了一些重大的改进，其中最引人注目的就是引入了流（Stream）API。流API允许程序员以声明式的方式处理数据，它支持串行和...
java8集合源码分析-Project:工程目录
06-04
集合源码分析 To Be Top Javaer - Java工程师成神之路 主要版本 更新时间 备注 v1.0 2019-04-10 首次发布 一、基础篇 面向对象 什么是面向对象 平台无关性 值传递 封装、继承、多态 Java基础知识 基本数据类型 自动...
java集合源码-collectionAnalysis:java集合源码解析
05-19
在"java集合源码-analysis:java集合源码解析"这个项目中，我们主要探讨的是对Java集合框架的源码进行深入理解。下面将详细阐述Java集合框架的基本概念、重要类和接口，以及其源码分析的重要性。 Java集合框架主要...
Java内存模型
最新发布
weixin_44267758的博客
07-19 314
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 581
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 846
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 897
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java集合框架深度解析：List、HashMap、HashSet等源码分析
通过对这些集合类的源码分析，开发者可以更好地理解它们的工作机制，从而在实际开发中选择最适合的数据结构，提高代码性能。这篇总结不仅适合初学者巩固基础，也对有经验的开发者有参考价值，帮助他们深入理解Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值