Java集合18：LinkedLlist源码图解

CRUD增删改查

加final是因为一开始已经把last"浅拷贝"给了l。加入新节点，自然要把其赋值给last，加了final，l指向的就一直是原先的last地址，也就是null，后面的赋值不会影响l。

如果不加final，l的地址会随着last修改而修改

first指向这个结点，last指向这个结点，两头为空

final 定义常量，不能修改

newNode是新定义的指针

newNode的前面指向的是l

内容是e

下一个指向null

然后，last指针重新指向newNode

如果l是空

也就是之前last指针（尾指针）指向的是空

所以，现在头指针是newNode节点

不然，l节点，也就是last指针之前指向的位置的后面一个是newNode节点

这段代码的意思就是把newNode拼接到最后啊

final 定义常量，不能修改

Node  ：定义一个节点，节点包括三个部分，前指针，内容，后指针

指向的都是这个1

这个意思大概就是   new  Node<>(上一个，本体，下一个)；

 删除结点

 remove（int index）：指定删除的是哪个位置

 remove （）：默认删除第一个

 remove （Object o）：要对链表里的某一个对象进行比较，然后再删除指定对象

 removeFirst （）：删除第一个结点

可以用下标删的原因是，他会判断下标节点更靠近头节点还是尾节点，然后遍历一遍（头节点遍历index次，尾节点size-index次），找到要删除的节点

让f指向这个first，双向链表的第一个结点

不等于空，防止删除的是一个空链表

真正走的是unlinkFirst（）

 真正干活的地方

f.item 就是把内容取出来，赋给 element

next 指向 f.next

f.item就是内容空了

f.next就是向后的链接没了

first = next ：first指向next了

 next不等于空的额话就进入else

把next.pre置空

往左的线就断了

package wuyuxin.List_;
import java.util.Iterator;
import java.util.LinkedList;
@SuppressWarnings({"all"})
public class LinkedListCRUD {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList=" + linkedList);
//删除结点
linkedList.remove();//这里默认删除的是第一个结点
//linkedList.remove(2);
System.out.println("linkedList=" + linkedList);
//修改某个结点
linkedList.set(1,999);
System.out.println("linkedList=" + linkedList);
//得到某个结点对象
//get（1） 是得到双向链表的第二个对象
//源码好想没存索引，就for从0开始遍历到了index-1位置就把Node返回。从index>>2分两部分找，太秒了
Object o = linkedList.get(1);
System.out.println(o);//999
//因为LinkList 是实现了List接口，所以遍历方式
//迭代器遍历
System.out.println("===LinkList遍历迭代器===");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("next=" + next);
}
//快捷键：I（大写的i）
System.out.println("===LinkList遍历增强for===");
for (Object o1 : linkedList) {
System.out.println("o1=" + o1);
}
System.out.println("===LinkList遍历普通for===");
for (int i = 0; i System.out.println(linkedList.get(i));
}
/* 1. LinkedList linkedList = new LinkedList();
public LinkedList() {}
2. 这时 linkedList 的属性 first = null last = null 为空
3. 执行 添加
public boolean add(E e) {
linkLast(e);
return true;
}
4. 将新的结点，加入到双向链表的最后
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
*/
/*
linkedList.remove();//这里默认删除的是第一个结点
1. 执行
public E remove() {
return removeFirst();
}
2.执行
真正走的是unlinkFirst()
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3.执行unlinkFirst, 将 f 指向的双向链表第一个结点拿掉
这里面是关键，真正把双向链表第一个结点拿掉的具体代码
private E unlinkLast(Node l) {
// assert l == last && l != null;
final E element = l.item;
final Node prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
*/
}
}

LinkedList最优使用迭代器遍历，通过节点去遍历，当使用for循环时，get(i)获取某一元素时都需要对整个List重新遍历，迭代器遍历效率最高