LinkedList的add(Object obj)和remove(Object obj)和remove(index)和get(index)的源码分析

1.add(Object obj)添加元素,底层结构为链表

//构造器
public LinkedList() {

}

		linkedList.add(1);
		linkedList.add(2);
		linkedList.add(3);
		linkedList.add(4);
		linkedList.add(5);
		linkedList.add(6);
		linkedList.add(7);
		linkedList.add(8);
		linkedList.add(9);
		linkedList.add(10);
		linkedList.add(11);

//add(Object obj)

	//把int型的值装箱
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }


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

	void linkLast(E e) {
		//transient Node<E> last;
        final Node<E> l = last;
		//三个参数的构造器,创建一个新的节点
        final Node<E> newNode = new Node<>(l, e, null);

		//把新的节点赋给last
        last = newNode;

		//此时l为null
		//所以新的节点赋给first
		// transient Node<E> first;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
		//transient int size = 0;
        size++;//记录LinkedList的元素个数
        modCount++;//计数器
    }

	//定义一个节点类
	 private static class Node<E> {
        E item;//对象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;
        }
    }

2.get(index) 得到index位置上的元素

 public E get(int index) {
		 //检查下标是否越界
        checkElementIndex(index);
		//返回下标为index的节点的item,就是要找的元素
        return node(index).item;
    }
	

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

	 Node<E> node(int index) {
       
		//分为两部分,这样能减少时间复杂度
		//如果要删除的节点的位置在链表数量一半的上半部分
        if (index < (size >> 1)) {
			//transient Node<E> first;
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
			//遍历找出index位置上的节点,并返回该节点
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
			//遍历找出index位置上的节点,并返回该节点
            return x;
        }
    }

3.remove(index),返回值为Object类型

	public E remove(int index) {
			//检查下标index是否越界
			checkElementIndex(index);
			//删除下标为index的节点
			return unlink(node(index));
		}

		private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	   }

		
	    Node<E> node(int index) {
       
		//分为两部分,这样能减少时间复杂度
		//如果要删除的节点的位置在链表数量一半的上半部分
        if (index < (size >> 1)) {
			//transient Node<E> first;
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
			//遍历找出index位置上的节点,并返回该节点
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
			//遍历找出index位置上的节点,并返回该节点
            return x;
        }
    }

	//删除该节点
	 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;
		
		//如果x节点的prev值为空,说明这个元素是第一个元素
		//
		if (prev == null) {
			first = next;//把next赋给第一个元素
		} else {
			prev.next = next;//把如果不是第一个元素,这把这个元素的前一个元素赋给这个元素的prev
			x.prev = null;
		}

		//如果x节点的next值为空,说明这个元素是最后一个元素
		if (next == null) {
			last = prev;//把prev赋给最后一个元素
		} else {
			next.prev = prev;//把如果不是最后一个元素,这把这个元素的前一个元素赋给这个元素的prev
			x.next = null;
		}
		
		x.item = null;//让其节点的item值为空
		size--;//零LinkedList的长度-1
		modCount++;
		return element;//返回这个节点
	}

4.1.remove(Object obj),当遇到要删除的对象为int类型时,把对象拆箱

public Integer(int value) {
        this.value = value;
    }

	//
	 public boolean remove(Object o) {
		 //如果对象为null值
        if (o == null) {
			//从第一个节点开始,逐一往后遍历,知道x节点为空
            for (Node<E> x = first; x != null; x = x.next) {
				//如果节点的item值为null值,调用unlink(x)方法
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
			//遍历这个链表,找出链表中的元素的item值相同的,删除掉
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
					//找到想对象的元素,删除掉
                    unlink(x);
                    return true;
                }
            }
        }
		//如果没有该元素,则返回false
        return false;
    }

	//删除该节点
	 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;
			
			//如果x节点的prev值为空,说明这个元素是第一个元素
			//
			if (prev == null) {
				first = next;//把next赋给第一个元素
			} else {
				prev.next = next;//把如果不是第一个元素,这把这个元素的前一个元素赋给这个元素的prev
				x.prev = null;
			}

			//如果x节点的next值为空,说明这个元素是最后一个元素
			if (next == null) {
				last = prev;//把prev赋给最后一个元素
			} else {
				next.prev = prev;//把如果不是最后一个元素,这把这个元素的前一个元素赋给这个元素的prev
				x.next = null;
			}
			
			x.item = null;//让其节点的item值为空
			size--;//零LinkedList的长度-1
			modCount++;
			return element;//返回这个节点
		}