理解Java集合（一）List :ArrayList/LinkedList

于 2018-04-05 16:06:00 发布
阅读量75 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 数据结构与算法 python
原文链接：https://my.oschina.net/ChinaHaoYuFei/blog/1790199
本文详细对比了ArrayList和LinkedList两种Java集合类的数据结构特点及核心方法实现，包括add、set、indexOf、get、remove等方法的源码分析，揭示了它们在不同场景下的优劣。

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

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

  • ArrayList

1. 数据结构：

    底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。其优点是随机读取，缺点是插入元素时需要移动大量元素，效率不太高。

2. 重要方法源码分析：

    2.1 类的继承关系

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.o.Serializable
//ArrayList继承AbstractList抽象父类，实现了List接口（规定了List的操作规范）、RandomAccess（可随机访问）、Cloneable（可拷贝）、Serializable（可序列化）。

    2.2 类的属性　

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 版本号
    private static final long serialVersionUID = 8683452581122892189L;
    // 缺省容量
    private static final int DEFAULT_CAPACITY = 10;
    // 空对象数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 缺省空对象数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 元素数组 核心的属性 用于存放实际元素，并且被标记为transient，在序列化的时候，此字段不会被序列化。
    transient Object[] elementData;
    // 实际元素大小，默认为0
    private int size;
    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

    2.3 类的构造函数

一共三个构造函数：
//1. 建立一个空的数组列表。
public ArrayList() { 
    // 无参构造函数，设置元素数组为空 
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
} 

//2. 建立一个数组列表,该数组有指定的初始容量(capacity)。容量是用于存储元素的基本数 组的大小。当元素被追加到数组列表上时,容量会自 动增加
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) { // 初始容量大于0
        this.elementData = new Object[initialCapacity]; // 初始化元素数组
    } else if (initialCapacity == 0) { // 初始容量为0
        this.elementData = EMPTY_ELEMENTDATA; // 为空对象数组
    } else { // 初始容量小于0，抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

//3.  建立一个数组列表,该数组列表由类集c中的元素初始化。
public ArrayList(Collection<? extends E> c) { // 集合参数构造函数
    elementData = c.toArray(); // 转化为数组
    if ((size = elementData.length) != 0) { // 参数为非空集合
        if (elementData.getClass() != Object[].class) // 是否成功转化为Object类型数组
            elementData = Arrays.copyOf(elementData, size, Object[].class); // 不为Object数组的话就进行复制
    } else { // 集合大小为空，则设置元素数组为空
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

    2.4 个人认为源码比较优秀有借鉴意义的方法

2.4.1 add方法

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

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 判断元素数组是否为空数组
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); // 取较大值
    }
    
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
	// 结构性修改加1
	modCount++;
	if (minCapacity - elementData.length > 0)
	    grow(minCapacity);
}	

private void grow(int minCapacity) {
    int oldCapacity = elementData.length; // 旧容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为旧容量的1.5倍
    if (newCapacity - minCapacity < 0) // 新容量小于参数指定容量，修改新容量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) // 新容量大于最大容量
        newCapacity = hugeCapacity(minCapacity); // 指定新容量
    // 拷贝扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

解释：当调用add方法时，实际上的函数调用如下：

2.4.2 set方法

public E set(int index, E element) {
    // 检验索引是否合法
    rangeCheck(index);
    // 旧值
    E oldValue = elementData(index);
    // 赋新值
    elementData[index] = element;
    // 返回旧值
    return oldValue;
}

2.4.3 indexOf方法

// 从首开始查找数组里面是否存在指定元素
public int indexOf(Object o) {
    if (o == null) { // 查找的元素为空
        for (int i = 0; i < size; i++) // 遍历数组，找到第一个为空的元素，返回下标
            if (elementData[i]==null)
                return i;
    } else { // 查找的元素不为空
        for (int i = 0; i < size; i++) // 遍历数组，找到第一个和指定元素相等的元素，返回下标
            if (o.equals(elementData[i]))
                return i;
    } 
    // 没有找到，返回空
    return -1;
}

2.4.4 get方法

public E get(int index) {
    // 检验索引是否合法
    rangeCheck(index);

    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}
//返回的值都经过了向下转型（Object -> E），这些是对我们应用程序屏蔽的小细节。

2.4.5 remove方法

public E remove(int index) {
    // 检查索引是否合法
    rangeCheck(index);
    
    modCount++;
    E oldValue = elementData(index);
    // 需要移动的元素的个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 赋值为空，有利于进行GC
    elementData[--size] = null; 
    // 返回旧值
    return oldValue;
}
//remove方法 移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用。
  • LinkedList

1. 数据结构

    LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作。

2. 重要方法源码分析

    2.1 类的继承关系

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
//继承自AbstractSequentialList，同时又实现了Deque，Deque接口表示是一个双端队列，那么也意味着LinkedList是双端队列的一种实现，基于双端队列的操作在LinkedList中全部有效。

    2.2 类的内部类

private static class Node<E> {
    E item; // 数据域
    Node<E> next; // 后继
    Node<E> prev; // 前驱
    
    // 构造函数，赋值前驱后继 Node就是实际的结点，用于存放实际元素的地方。
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

    2.3 类的属性

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 实际元素个数
    transient int size = 0;
    // 头结点
    transient Node<E> first;
    // 尾结点
    transient Node<E> last;
}

    2.4 构造方法

//建立一个空的链接列表
public LinkedList() {

}
//建立一个链接列表,该链接列 表由类集c中的元素初始化
public LinkedList(Collection<? extends E> c) {
    // 调用无参构造函数
    this();
    // 添加集合中所有的元素
    addAll(c);
}

    2.5 个人认为源码比较优秀有借鉴意义的方法

2.5.1 add()方法

//给尾部添加元素
public boolean add(E e) {
    // 添加到末尾
    linkLast(e);
    return true;
}

void linkLast(E e) {
    // 保存尾结点，l为final类型，不可更改
    final Node<E> l = last;
    // 新生成结点的前驱为l,后继为null
    final Node<E> newNode = new Node<>(l, e, null);
    // 重新赋值尾结点
    last = newNode;    
    if (l == null) // 尾结点为空
        first = newNode; // 赋值头结点
    else // 尾结点不为空
        l.next = newNode; // 尾结点的后继为新生成的结点
    // 大小加1    
    size++;
    // 结构性修改加1
    modCount++;
}

1.5.2 addAll()方法

// 添加一个集合
public boolean addAll(int index, Collection<? extends E> c) {
    // 检查插入的的位置是否合法
    checkPositionIndex(index);
    // 将集合转化为数组
    Object[] a = c.toArray();
    // 保存集合大小
    int numNew = a.length;
    if (numNew == 0) // 集合为空，直接返回
        return false;

    Node<E> pred, succ; // 前驱，后继
    if (index == size) { // 如果插入位置为链表末尾，则后继为null，前驱为尾结点
        succ = null;
        pred = last;
    } else { // 插入位置为其他某个位置
        succ = node(index); // 寻找到该结点
        pred = succ.prev; // 保存该结点的前驱
    }

    for (Object o : a) { // 遍历数组
        @SuppressWarnings("unchecked") E e = (E) o; // 向下转型
        // 生成新结点
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null) // 表示在第一个元素之前插入(索引为0的结点)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) { // 表示在最后一个元素之后插入
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }
    // 修改实际元素个数
    size += numNew;
    // 结构性修改加1
    modCount++;
    return true;
}

Node<E> node(int index) {
    // 判断插入的位置在链表前半段或者是后半段
    if (index < (size >> 1)) { // 插入位置在前半段
        Node<E> x = first; 
        for (int i = 0; i < index; i++) // 从头结点开始正向遍历
            x = x.next;
        return x; // 返回该结点
    } else { // 插入位置在后半段
        Node<E> x = last; 
        for (int i = size - 1; i > index; i--) // 从尾结点开始反向遍历
            x = x.prev;
        return x; // 返回该结点
    }
}
//在根据索引查找结点时，有一个小优化，结点在前半段则从头开始遍历，在后半段则从尾开始遍历，这样就保证了只需要遍历最多一半结点就可以找到指定索引的结点。值得注意
//在addAll方法中，传入一个集合参数和插入位置，然后将集合转化为数组，然后再遍历数组，挨个添加数组的元素，但是问题来了，为什么要先转化为数组再进行遍历，而不是直接遍历集合呢？从效果上两者是完全等价的，都可以达到遍历的效果。关于为什么要转化为数组的问题： 如果直接遍历集合的话，那么在遍历过程中需要插入元素，在堆上分配内存空间，修改指针域，这个过程中就会一直占用着这个集合，考虑正确同步的话，其他线程只能一直等待。2. 如果转化为数组，只需要遍历集合，而遍历集合过程中不需要额外的操作，所以占用的时间相对是较短的，这样就利于其他线程尽快的使用这个集合。其实就是有利于提高多线程访问该集合的效率，尽可能短时间的阻塞。

1.5.3 unlink()方法

E unlink(Node<E> x) {
    // 保存结点的元素
    final E element = x.item;
    // 保存x的后继
    final Node<E> next = x.next;
    // 保存x的前驱
    final Node<E> prev = x.prev;

    if (prev == null) { // 前驱为空，表示删除的结点为头结点
        first = next; // 重新赋值头结点
    } else { // 删除的结点不为头结点
        prev.next = next; // 赋值前驱结点的后继
        x.prev = null; // 结点的前驱为空，切断结点的前驱指针
    }

    if (next == null) { // 后继为空，表示删除的结点为尾结点
        last = prev; // 重新赋值尾结点
    } else { // 删除的结点不为尾结点
        next.prev = prev; // 赋值后继结点的前驱
        x.next = null; // 结点的后继为空，切断结点的后继指针
    }

    x.item = null; // 结点元素赋值为空
    // 减少元素实际个数
    size--; 
    // 结构性修改加1
    modCount++;
    // 返回结点的旧元素
    return element;
}

上面我列举了一些JDK中的方法源码，个人认为这些源码对我们来说是非常有借鉴意义的。因为最近也在看重构相关的内容。所以再看到这些的时候，觉得这些JDK源码中的方法职责的划分和方法的提取很值得借鉴和学习。

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/ChinaHaoYuFei/blog/1790199

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值