LinkedList与ArrayDeque的使用与源码分析

格墙996

已于 2024-01-05 21:33:07 修改

阅读量259

点赞数

文章标签： java 算法前端

于 2022-08-02 17:46:20 首次发布

本文链接：https://blog.csdn.net/y95628/article/details/126127122

版权

今天我们学习LinkedList，后文代码皆为jdk1.8源码

首先，学习一个类，先看Diagrams

可以看出，LinkedList集成了AbstractList也实现类Deque，即具有集合的特性，也具有队列的特性。

LinkedList其实就是这两个组合起来，我们大部分使用的时候，都是使用List的特性，因为jdk1.6出了ArrayDeque，实现了Deque接口，当你要用Deque特性时，推荐使用ArrayDeque。

AbstractList

咱们先看AbstractList这个抽象类

add：此方法默认抛出异常，LinkedList重写了该方法

//以下为AbstractList代码
public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
//以下为LinkedList代码，该方法默认添加在节点尾部，与addLast方法一样
public boolean add(E e) {
        linkLast(e);
        return true;
    }

get：是一个抽象方法，LinkedList中重写了，其中有个小心思，该方法判断了index属于左半边还是右半边，以此来提高效率

//以下为LinkedList代码
Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }

set：此方法默认抛出异常，LinkedList重写了该方法

//以下为AbstractList代码
public E set(int index, E element) {
        throw new UnsupportedOperationException();
    }
//以下为LinkedList代码
public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

add：与上一个add方法不同的是，此方法多了一个index，即要插入的位置。添加指定元素到指定位置，原该位置处及该位置后的元素，皆往后移一位，即索引+1

//以下为AbstractList代码
public void add(int index, E element) {    throw new UnsupportedOperationException();}
//以下为LinkedList代码
public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

remove：移除指定位置元素

//以下为AbstractList代码
public E remove(int index) {    throw new UnsupportedOperationException();}
//以下为LinkedList代码
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));//此处是通过index获取对应的元素，然后unlink该元素
}

indexOf：AbstractList是用迭代器来遍历，LinkedList使用增强for，两者都可以获取到null的索引，且都是从头开始遍历，返回第一次遇到对应元素的索引，同时也说明，LinkedList是可以存储null元素

	//以下为AbstractList代码
	public int indexOf(Object o) {
        ListIterator<E> it = listIterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return it.previousIndex();
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return it.previousIndex();
        }
        return -1;
    }
    //以下为LinkedList代码
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

lastIndexOf：从后往前找到第一次遇到对应元素的索引，与indexOf类似，代码就省略
clear：AbstractList是通过迭代器删除元素，LinkedList是把节点都变为null，方便gc

	//以下为AbstractList代码
	public void clear() {
        removeRange(0, size());
    }
    protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
    }
    //以下为LinkedList代码
    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

addAll：从指定位置，将指定集合插入到该集合，如果是中间位置，则该位置后面元素后移。这样解释还是直接看测试方法把

public void testAddAll() {
            LinkedList<String> list = new LinkedList<>();
            list.add("1");
            list.add("2");
            list.add("3");
            list.add("4");
            list.add("5");

            LinkedList<String> objects = new LinkedList<>();
            objects.add("6");
            objects.add("7");
            objects.add("8");
            objects.add("9");
            list.addAll(3, objects);
			//可以很清晰的看到，从索引为3的位置，开始插入目标集合，原集合元素都往后移
            list.forEach(System.out::print);//123678945
        }


	//以下为AbstractList代码
	public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) {
            //该add方法还是调用自身AbstractList的抽象方法，默认还是抛出异常
            add(index++, e);
            modified = true;
        }
        return modified;
    }
    //以下为LinkedList代码
    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;
        //如果index等于size，说明是在尾部插入
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            //如果不等于size，则在中间插入，其中succ为对应index的元素
            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)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
		//如果index等于size，则需要修改last值
        if (succ == null) {
            last = pred;
        } else {
            //如果index不等于size，则把该链表串起来即可
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }