文章40 | 阅读 10558 | 点赞0
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
@java.io.Serial
private static final long serialVersionUID = 876323262645176354L; // 序列化版本号
transient int size = 0; // 当前元素个数0
transient Node<E> first; // 指向第一个节点数据
transient Node<E> last; // 指向最后一个节点
/** * 存储数据的 * Node数据结构 */
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;
}
}
/** * LinkedList构造方法 */
public LinkedList() {} // 构造一个空集合
public LinkedList(Collection<? extends E> c) {} // 构造一个带有c集合所有元素的集合
/** * 添加元素 */
public void addFirst(E e) {} // 将节点e加入作为第一个节点
public void addLast(E e) { } // 将节点e加入作为尾节点
public boolean add(E e) {} // 添加元素,会加入到链表末尾
public boolean offer(E e) {} // 添加元素,调用的是add(e);就是上面一个方法
public void add(int index, E element) {}// index位置加入元素element
public boolean addAll(Collection<? extends E> c) {} // 添加集合元素
public boolean addAll(int index, Collection<? extends E> c) {} // 指定位置后添加元素
public boolean offerFirst(E e) {} // 添加e成为首元素
public boolean offerLast(E e) {} // 添加e成为尾元素元素
public void push(E e) {} // 添加e并成为首元素
/** * 移除元素 */
public E removeFirst() {} // 移除首元素
public E removeLast() {} // 移除最后一个节点
public E pollFirst() {} // 返回并移除首元素
public E pollLast() {} // 返回并移除尾元素
public E remove() {} // 移除首元素
public E pop() {} // 移除首元素并返回首元素
public E poll() {} // 返回首元素并从链表中剔除首元素,或者返回null
public boolean remove(Object o) {} // 移除元素o,如果成功返回true,失败(说明不存在)返回false
public E remove(int index) {} // 移除index位置的元素
public boolean removeFirstOccurrence(Object o) {} // 从头开始找元素o,并移除元素o
public boolean removeLastOccurrence(Object o) {} // 从尾往前找元素o,并移除元素
/** * 修改元素 */
public E set(int index, E element) {} // 替换index索引元素存的内容
/** * 查询元素 */
public E getFirst() {} // 获取第一个节点
public E getLast() {} // 获取最后一个节点
public E peek() {} // 返回表头元素或者null
public E element() {} // 返回表头元素,如果为null则抛异常,不会返回null元素
public E peekLast() {} // 返回尾元素,可以返回null
public E get(int index) {} // 获得index索引下的元素
public int indexOf(Object o) {} // 从首元素往后找,返回元素o的索引值,如果不存在则返回-1
public int lastIndexOf(Object o) {} // 从尾元素往前找,返回元素索引
public boolean contains(Object o) {} // 是否包含o
/** * 其它对集合操作的方法 * 链表转数组 * 集合大小、清空集合、克隆集合、迭代器 */
public Object[] toArray() {} // 链表转数组,不带泛型
public <T> T[] toArray(T[] a) {} // 链表转数组,传入泛型
public int size() {} // 返回链表长度
public void clear() {} // 清除所有元素
private LinkedList<E> superClone() {} // 克隆一个LinkedList对象
public Object clone() {} // 将所有元素都克隆一份,并返回
public Spliterator<E> spliterator() {} // 迭代器,允许并行处理
public ListIterator<E> listIterator(int index) {} // 迭代器
/** * 后面的可以不用看,主要需要掌握前面对外提供的方法 * * 不对外使用的方法 */
E unlink(Node<E> x) {} // 移除节点x
Node<E> node(int index) {} // 返回index下的节点
void linkLast(E e) {} // 链接到最后一个节点上
void linkBefore(E e, Node<E> succ) {} // 链接到succ节点的上一个节点
private void linkFirst(E e) {} // 链接到第一个节点上
private E unlinkFirst(Node<E> f) {} // 移除第一个节点
private E unlinkLast(Node<E> l) {} // 移除最后一个节点
private boolean isElementIndex(int index) {} // 判断index是否在链表长度内
private boolean isPositionIndex(int index) {} // 判断index是否是正向索引
private String outOfBoundsMsg(int index) {} // 返回超出索引范围的提示字符串:"Index: "+index+", Size: "+size;
private void checkElementIndex(int index) {} // 检查元素索引index是否在链表长度以内,不是则抛异常
private void checkPositionIndex(int index) {} // 检查正向索引
/** * 序列化 */
@java.io.Serial
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {}
/** * 反序列化 */
@SuppressWarnings("unchecked")
@java.io.Serial
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {}
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {} // 是否有下一个元素
public E next() {} // 返回下一个元素
public void remove() {} // 移除当前迭代器返回的元素
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned; // 上一个元素节点
private Node<E> next; // 下一个节点元素
private int nextIndex; // 上一个元素索引值
private int expectedModCount = modCount;// 并发修改异常计数
ListItr(int index) {} // 构造器
public void add(E e) {} // 添加
public void remove() {} // 删除
public void set(E e) {} // 修改
public boolean hasNext() {} // 判断是否有下一个元素
public E next() {} // 返回下一个元素
public boolean hasPrevious() {} // 是否有上一个值
public E previous() {} // 返回上一个元素
public int nextIndex() {} // 下一个元素的索引值
public int previousIndex() {} // 上一个元素的索引值
public void forEachRemaining(Consumer<? super E> action) {} // 遍历迭代器剩余元素
final void checkForComodification() {} // 检查并发修改异常
}
static final class LLSpliterator<E> implements Spliterator<E> {
static final int BATCH_UNIT = 1 << 10; // batch array size increment
static final int MAX_BATCH = 1 << 25; // max batch array size;
final LinkedList<E> list; // null OK unless traversed
Node<E> current; // current node; null until initialized
int est; // size estimate; -1 until first needed
int expectedModCount; // initialized when est set
int batch; // batch size for splits
LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {} // 构造方法
public void forEachRemaining(Consumer<? super E> action) {} // 遍历剩余元素
public boolean tryAdvance(Consumer<? super E> action) {} // 尝试获取剩余元素,如果没有剩余元素返回false
final int getEst() {}
public long estimateSize() {}
public Spliterator<E> trySplit() {}
public int characteristics() {}
}
}
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://yumbo.blog.csdn.net/article/details/108810955
内容来源于网络,如有侵权,请联系作者删除!