Java8 LinkedList数据结构以及源码详解

目录

 

数据结构

构造方法

字段说明

方法详解

add(E e)

add(int index, E element)

addFirst(E e)

addLast(E e)

allAll(Collection c)、addAll(int index, Collection c)

 get(int index)

getFirst()

getLast()

remove()

remove(index index)

clear()

contains(Object o)

containsAll(Collection c)

isEmpty()

size()

set(int index, E element)

push(E e)

pop()

peek()、peekFirst()、peekLast()

clone()

toArray()

iterator()

listIterator(int index)

总结


数据结构

LinkedList的数据结构也比较简单,就是一个双向链表,基本的存储结构代码如下(是LinkedList的一个内部类):

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;
    }
}

包括自己的值(item),前一个节点的信息(prev),下一个节点信息(next)。

构造方法

有两个构造方法:

无参数的构造方法:

public LinkedList() {}

带参数的构造方法:

//入参是一个集合,也就是希望在创建LinkedList的时候就把传入的这些数据放进去
public LinkedList(Collection<? extends E> c) {
        this();
        //将参数传入的数据添加进去
        addAll(c);
}


public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
}

/*
index 在哪个位置插入(可以指定插入位置,这儿传入的是size,也就是从链表的尾部插入)
c 数据
*/
public boolean addAll(int index, Collection<? extends E> c) {
        //检查参数index是否超过链表长度(这儿肯定不会超过)
        checkPositionIndex(index);

        //将传入的集合转化为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //如果传入的集合为空,则直接结束
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
       
        if (index == size) {
            //在链表尾部插入,构造方法就是在链表尾部插入
            //succ是在指定位置插入的时候使用的,
            succ = null;
            //pred记录尾节点信息
            pred = last;
        } else {
            //在链表中指定的位置插入
            //此时首先要找到index所在位置的节点
            succ = node(index);
            //先记录指定节点的前一个节点的信息(后面会用到)
            pred = succ.prev;
        }

        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //创建一个新节点,新节点的前一个节点就是pred(pred始终是链表的尾节点)
            Node<E> newNode = new Node<>(pred, e, null);
            
            if (pred == null)
                //如果链表原来就是空的,那新节点也就是第一个节点
                first = newNode;
            else
                /*如果链表不是空的,那尾节点的下一个节点就是新创建的节点(新节点的前一个节点在创建的时候已经指定了)*/
                pred.next = newNode;
            //在将pred指向新节点(新节点也就是尾节点,pred始终指向尾节点)
            pred = newNode;
        }

        if (succ == null) {
            //尾部插入,pred就是尾节点
            last = pred;
        } else {
            //指定位置插入,注意pred始终指向新创建链表的尾节点
            //此时将succ(指定位置的节点)赋给pred的next信息
            pred.next = succ;
            //succ(指定位置节点)的前一个节点就是新创建节点的最后一个节点,这样就完成了在指定位置插入的操作
            succ.prev = pred;
        }

        //链表数据量
        size += numNew;
        //链表修改次数
        modCount++;
        return true;
}

//找出index位置的节点
Node<E> node(int index) {
        // assert isElementIndex(index);
        
        //如果index小于链表大小的一半,则从头部向后遍历
        if (index < (size >> 1)) {
            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;
        }
}

字段说明

//链表中的数据量
transient int size = 0;
//链表头结点
transient Node<E> first;
//链表尾节点
transient Node<E> last;

方法详解

add(E e)

插入元素e,Appends the specified element to the end of this list(在链表的尾部插入指定的元素)

//可以看出该方法是后插(新节点链接到链表尾部)
public boolean add(E e) {
        linkLast(e);
        return true;
}

//从尾部插入
void linkLast(E e) {
        final Node<E> l = last;
        //创建一个新节点,并且指定该新节点的前一个节点信息
        final Node<E> newNode = new Node<>(l, e, null);
        //从尾部插入,新节点就是尾节点
        last = newNode;
        if (l == null)
            //如果链表原来是空的,则first和last是同一个节点
            first = newNode;
        else
            //否则,将新节点链接到原来尾节点的后面
            l.next = newNode;
        size++;
        modCount++;
}

add(int index, E element)

在index位置插入元素element

public void add(int index, E element) {
        //index是否超过链表长度
        checkPositionIndex(index);
        
        if (index == size)
            //尾部插入
            linkLast(element);
        else
            //指定位置的前面插入,首先需要获取index位置的节点(前面讲构造方法的时候有)
            linkBefore(element, node(index));
}

//校验index是否超过链表长度
private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//链表尾部插入(前面的add方法有提到)
void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
}

//找到index指定位置的节点
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;
        }
}

//在succ的前面插入e
void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        //先记录succ的前一个节点信息
        final Node<E> pred = succ.prev;
        //创建新节点,新节点的前一个节点就是succ原来的前一个节点,新节点的下一个节点就是succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        //succ的前一个节点设置为新节点
        succ.prev = newNode;
        if (pred == null)
            //如果succ的前一个节点为空的话,说明原来succ就是头结点,那么插入以后新节点就是头结点了
            first = newNode;
        else
            //succ原来前一个节点的下一个节点就变成新节点了
            pred.next = newNode;
        size++;
        modCount++;
}

addFirst(E e)

看该方法的注释就比较清楚了:Inserts the specified element at the beginning of this list.(在列表的开头插入指定的元素)

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

private void linkFirst(E e) {
        //记录旧的头结点
        final Node<E> f = first;
        //创建新节点,因为是在头部插入,所以前一个节点信息是null,后一个节点就是f(原来的头结点)
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            //如果链表原来是空的,则新节点即是头结点,又是尾节点
            last = newNode;
        else
            //如果队列不为空,则原来的头结点的前一个节点就是新节点
            f.prev = newNode;
        size++;
        modCount++;
}

addLast(E e)

Appends the specified element to the end of this list.(在链表的尾部插入指定元素)

和add(E e)方法除了返回值不同外,其他都相同

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

void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
}

allAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)

将指定集合中的元素加入到链表中,第一个方法是在尾部插入,第二个方法是在指定位置插入。

这两个方法和带参数的构造方法逻辑是一样的,第一个方法里面调了第二个方法。

public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
}

 get(int index)

Returns the element at the specified position in this list.(返回列表上指定位置的元素)

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

//是否超过链表元素个数
private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

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

//前面在指定位置插入的时候都是先找到指定位置的元素,就是通过该方法的
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;
        }
}

getFirst()

返回链表第一个元素值

/*返回链表中第一个元素的值,如果链表为空则抛出异常NoSuchElementException*/
public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
}

getLast()

返回链表最后一个元素

//返回链表最后一个元素值,如果列表为空则抛出异常NoSuchElementException
public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
}

remove()

Retrieves and removes the head (first element) of this list.(检索并删除链表的头)

不带参数,删除的是链表的头部

public E remove() {
        return removeFirst();
}

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;
        //将要删除的节点的信息都置为null,帮助垃圾回收
        f.item = null;
        f.next = null; // help GC

        //指定新的头结点
        first = next;
        if (next == null)
            //如果链表只有一个节点,则删除头节点以后链表就为空了,所以last节点就是null了
            last = null;
        else
            //链表有至少两个节点,next节点也就是新的头结点,头节点的前一个节点信息肯定就是null了
            next.prev = null;
        size--;
        modCount++;
        return element;
}

remove(index index)

删除链表中指定位置的元素,返回值是删去的元素。

public E remove(int index) {
        checkElementIndex(index);
        //先找到要删除的节点
        return unlink(node(index));
}

//找到要删除的节点
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;
        }
}

//执行删除,要删除的节点为x
E unlink(Node<E> x) {
        // assert x != null;
        //记录x节点的值、后一个节点信息和前一个节点信息
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            //x节点是头结点,则删除以后,x结点的后一个节点就是头结点了
            first = next;
        } else {
            //x节点不是头结点,将x节点前一个节点的next信息置为x节点的后一个节点
            prev.next = next;
            //X节点的prev信息置为null
            x.prev = null;
        }

        if (next == null) {
            //x节点是尾节点,则删除以后x节点的前一个节点就是尾节点了
            last = prev;
        } else {
            //x节点不是尾节点,将x节点后一个节点的prev信息置为x节点前一个节点
            next.prev = prev;
            //x节点的next信息置为null
            x.next = null;
        }
        //将x节点的值也置为null
        x.item = null;
        size--;
        modCount++;
        return element;
}

clear()

将链表中所有的元素都删除

public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        //通过循环将链表中每一个节点的所有信息都置为null,帮助垃圾回收
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        //头尾节点也置为null
        first = last = null;
        //元素个数置为0
        size = 0;
        modCount++;
}

contains(Object o)

返回指定元素在链表中的索引值

public boolean contains(Object o) {
        return indexOf(o) != -1;
}


public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            //如果传入元素为null,则返回链表中出现第一个null的位置索引
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            //通过equals方法比较是否相等
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
}

containsAll(Collection<?> c)

链表中是否包含集合c中的所有元素,只有有一个元素不包含,就返回false

public boolean containsAll(Collection<?> c) {
        for (Object e : c) //遍历参数传入的集合
            if (!contains(e)) //调前一个contains方法
                return false;
        return true;
}

isEmpty()

链表是否为空

public boolean isEmpty() {
        //size记录的是链表中元素的个数
        return size() == 0;
    }

size()

链表中元素的数量

public int size() {
        return size;
    }

set(int index, E element)

将指定位置的元素值设置为传入的值

public E set(int index, E element) {
        checkElementIndex(index);
        //先找到index所在位置的节点
        Node<E> x = node(index);
        //记录旧值,方法返回值为旧值
        E oldVal = x.item;
        //将index所在位置的节点的值设置为传入的值
        x.item = element;
        return oldVal;
}

push(E e)

在链表的头部插入元素e,里面调了addFirst(E e)方法

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

pop()

删除链表中的第一个元素,和remove()方法的实现是一样的

public E pop() {
        return removeFirst();
    }

peek()、peekFirst()、peekLast()

从代码可以看出前两个方法的实现是一模一样的,都是返回链表中第一个元素的值

peekLast返回链表最后一个元素的值

public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
}

clone()

方法注解:Returns a shallow copy of this {@code LinkedList}. (The elements themselves are not cloned.)

从注解可以看出是浅克隆

public Object clone() {
        LinkedList<E> clone = superClone();

        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);

        return clone;
}

toArray()

转为数组

public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
}

iterator()

LinkedList中的普通迭代器是从AbstractSequentialList继承来的,可以从前向后遍历。

public Iterator<E> iterator() {
        return listIterator();
}

listIterator(int index)

从指定位置开始向前/向后遍历

//ListItr是LinkedList的一个内部类
public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
}

//内部类只列出了其中的字段可方法
private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {}

        public boolean hasPrevious() {}

        public E previous() {}

        public int nextIndex() {}

        public int previousIndex() {}

        public void remove() {}

        public void set(E e) {}

        public void add(E e) {}

        public void forEachRemaining(Consumer<? super E> action) {}

        final void checkForComodification() {}
}

使用方法:

public static void main(String[] args) {
	LinkedList<Integer> linkedList = new LinkedList<>();
	linkedList.add(5);
	linkedList.add(4);
	linkedList.add(3);

	//普通迭代器
	System.out.println("普通迭代器:");
	Iterator<Integer> iterator = linkedList.iterator();
	while (iterator.hasNext()) {
		Integer i = iterator.next();
		System.out.println(i);
	}
	//从索引为2的位置开始向前
	System.out.println("==================");
	System.out.println("从索引为2的位置开始向前遍历:");
	ListIterator<Integer> listIterator = linkedList.listIterator(2);
	while (listIterator.hasPrevious()) {
		Integer i = listIterator.previous();
		System.out.println(i);
	}
	System.out.println("==================");
	//从索引为1的位置开始向后遍历
	System.out.println("从索引为1的位置开始向后遍历:");
	listIterator = linkedList.listIterator(1);
	while (listIterator.hasNext()) {
		Integer i = listIterator.next();
		System.out.println(i);
	}
}

执行结果:

有一点需要注意,从运行结果可以看出,向前遍历的时候,遍历结果是不包含索引所在位置的值(索引从0开始);

但是从指定位置开始向后遍历的时候,遍历结果却是包含索引指定位置元素的。

总结

LinkedList是一个双向列表,ArrayList是数组。

比如要获取指定位置的元素,LinkedList在查询的时候需要一个一个的元素去遍历,直到遍历到指定的位置;但是ArrayList却可以直接通过下标获取到某个元素,很明显获取指定位置的元素ArrayList效率要比LinkedList高。

如果要删除指定位置的元素,LinkedList需要首先通过遍历获取到指定元素所在节点,然后修改一下相关元素的后一个节点信息以及前一个节点信息即可;但是ArrayList却没这么简单,是通过数组复制实现的,如果数据量比较大的话,这是个比较耗时的过程,所以如果要删除的话LinkedList的效率是比较高的。

在使用的时候可以根据具体情况,选择合适的存储结构。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值