Análisis 2 del código fuente de LinkedList

 		LinkedList<Integer> ls = new LinkedList<>();
        ls.add(1);
        ls.add(3);
        ls.add(5);
        ls.add(7);
        Integer peek = ls.peek();//1
        Integer peekFirst = ls.peekFirst();//1
        Integer peekLast = ls.peekLast();//7

valor de retorno	función	sentido
mi	peekFirst	Devuelve el primer elemento de esta lista.
mi	ojeada()	Devuelve el primer elemento de esta lista.
mi	peekLast ()	Devuelve el último elemento de esta lista.

A juzgar por los resultados de ejecución anteriores, el primer elemento y el último elemento de la lista vinculada se obtienen respectivamente. Mire el análisis del código fuente de la siguiente manera:

// 将首结点赋值给当前结点，如果为空，返回空，否则返回元素
public E peek() {
    
    
       final Node<E> f = first;
       return (f == null) ? null : f.item;
}
//和peek()函数一样
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;
}

Siga el artículo anterior y el análisis de api actual. Las API restantes son las siguientes:

valor de retorno	función	sentido
vacío	agregar (índice int, elemento E)	Inserte el elemento especificado en la posición especificada en esta lista
booleano	addAll (índice int, Colección <? extiende E> c)	Comenzando desde la posición especificada, inserte todos los elementos de la colección especificada en esta lista
booleano	addAll (Colección <? extiende E> c)	Agrega todos los elementos de la colección especificada al final de esta lista en el orden en que los devuelve el iterador de la colección especificada

public void add(int index, E element) {
    
    
        checkPositionIndex(index);

        if (index == size)
        //如果当前插入的位置和LinkedList的长度相等，那么插入尾部
            linkLast(element);
        else
        //否则插入到固定的位置
            linkBefore(element, node(index));
}
 void linkBefore(E e, Node<E> succ) {
    
    
        // assert succ != null;
        //原来位置的结点获取前驱
        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++;
}
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) {
    
    
          //尾部插入，那么此时当前结点的前驱为原来链表的最后一个结点
            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)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
		//如果原来结点为空，那么设置当前pred为最后一个结点。
        if (succ == null) {
    
    
            last = pred;
        } else {
    
    
        //否则。将原来结点这只为待插入结点的下一个结点。当前结点为原来结点的前驱
            pred.next = succ;
            succ.prev = pred;
        }
		
        size += numNew;
        modCount++;
        return true;
    }
//直接将集合插入到原来链表的尾部
public boolean addAll(Collection<? extends E> c) {
    
    
        return addAll(size, c);
}

valor de retorno	función	sentido
mi	obtener (índice int)	Devuelve el elemento en la posición especificada.
mi	elemento()	Recupere pero no elimine el encabezado (primer elemento) de esta lista.
En t	indexOf (Objeto o)	Devuelve el índice de la primera aparición del elemento especificado en esta lista; si esta lista no contiene el elemento, devuelve -1.
En t	lastIndexOf (Objeto o)	Devuelve el índice de la última aparición del elemento especificado en esta lista; si esta lista no contiene el elemento, devuelve -1.

public E get(int index) {
    
    
        checkElementIndex(index);
        //获取指定位置的元素
        return node(index).item;
    }
//内部调用node(index)方法
Node<E> node(int index) {
    
    
       
		//如果index小于LinkedList的1/2.从头往后查找。否则从后往前查找
        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;
        }
    }
 //获取第一个元素
 public E element() {
    
    
        return getFirst();
}
//获取元素第一次出现位置的索引，没有则返回-1
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;
    }
//找出元素最后一次出现的位置。从后往前遍历
public int lastIndexOf(Object o) {
    
    
        int index = size;
        if (o == null) {
    
    
            for (Node<E> x = last; x != null; x = x.prev) {
    
    
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
    
    
            for (Node<E> x = last; x != null; x = x.prev) {
    
    
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

valor de retorno	función	sentido
mi	set (índice int, elemento E)	Reemplazar el elemento en la posición especificada en esta lista con el elemento especificado

//修改指定位置的元素
public E set(int index, E element) {
    
    
        checkElementIndex(index);
        //获取原来的结点
        Node<E> x = node(index);
        //获取原来结点的值
        E oldVal = x.item;
        //将新值赋值给原来结点值的引用
        x.item = element;
        //返回旧值
        return oldVal;
    }