JDK源码阅读-集合01：List接口的设计逻辑？List接口源码解析？附上完整无注释源码

最新推荐文章于 2024-07-09 20:42:41 发布

菜鸟老文

最新推荐文章于 2024-07-09 20:42:41 发布

阅读量564

点赞数

分类专栏： JavaSE 面试文章标签： list java 链表

本文链接：https://blog.csdn.net/weixin_44242433/article/details/122006392

版权

面试同时被 2 个专栏收录

38 篇文章 0 订阅

订阅专栏

JavaSE

24 篇文章 0 订阅

订阅专栏

01-背景：

最近老文，不断在力扣上面刷数据结构，膨胀的老文想要看看Java源码集合是什么样的，看看源码实现接口怎么样的。
哔哩哔哩视频链接：应该如何去看List集合的源码？从List接口方法讲起

02-继承关系：

在这里插入图片描述

03-List是集合怎么设计：

从方法上来说，我认为List的集合可以分为三种类型，描述方法，功能方法，其他方法：

描述方法：描述List这个集合应该拥有什么样的行为，比如说长度如何？迭代？打印
功能方法：增删改查
其他方法：不知道怎么归类

逻辑总图
在这里插入图片描述

1，List描述方法：

首先我们的要明白接口是一种约束，规范。
而我所说的描述方法，则是继承这个接口，说明是一个list集合，那么这个集合应该是什么样的的呢？线下面方法一一说明：

（1）List长度是什么样的？（size）

返回这个链表长度

    int size();

（2）List的节点如何遍历（iterator）

（a）仅遍历

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     *	迭代类是继承于父类接口 Iterator
     * @return an iterator over the elements in this list in proper sequence
     */
    Iterator<E> iterator();

（b）遍历+增删改：

如果说，我想在遍历的时候顺便对List进行一些操作呢？怎么办：
参考文章：List集合ListIterator和Iterator迭代器区别与用法

i，无参数，从头开始：

    /**
     * 返回此列表中元素的列表迭代器（按正确顺序）。
     *
     * @return a list iterator over the elements in this list (in proper
     *         sequence)
     */
    ListIterator<E> listIterator();

ii，从指定位置开始：

    ListIterator<E> listIterator(int index);

（3）如果有两个List怎么比较呢？（equals）

如果说，（3）之前的描述场景是一个List，那么equals就是描述两个List的场景。

    boolean equals(Object o);

（4）如果我有好多List，怎么确定他的唯一性？（hashCode）

    int hashCode();

（5）如果想原本List的基础上，生成一个新的子List呢？（subList）

    List<E> subList(int fromIndex, int toIndex);

（6）如果我想要多线程环境下（并行）处理一个List呢？（spliterator）

分离器：
参考文章：jdk8中Spliterator的作用

@Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }

2，功能方法：增删改查。

如果说上面描述是用来描述List有什么行为更多是描述List的这个轮廓，那么下面的方法类型针对于List中的内容了。

（1）增：

（a）一次添加一个（add）

i：直接在List的后面+1个节点：

如果整个List产生变化（变长）了，那么就说明添加成功返回true

boolean add(E e);

ii：在List指定位置添加：

    void add(int index, E element);

（b）一次性添加多个（addAll）

i：将整个集合添加进来：

boolean addAll(Collection<? extends E> c);

ii:将某个集合的一部分添加进来：

boolean addAll(int index, Collection<? extends E> c);

（2）删：

（a）删一个（remove）

i：直接删除左边指定元素

    boolean remove(Object o);

ii：删除指定节点的元素：

   E remove(int index);

（b）删除多个

i：删除指定集合之外所有元素（retainAll）：

如果现在有两个List内容是相交的，那么我想要保留相交的内容，就可以使用这个方法：

    boolean retainAll(Collection<?> c);

ii：全部删掉：（clear）

    void clear();

（3）改：

（a）只改一个（set）

    E set(int index, E element);

（b）改多个（replaceAll）

    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

（4）查：

查是最多方法的。

（a）查看一个（get）

    E get(int index);

(b)查看元素是否为空（isEmpty）：

    boolean isEmpty();

（c）判断有没有指定元素（containsAll）：

    boolean containsAll(Collection<?> c);

（d）查看指定元素出现的第一个位置（indexOf）

也就说从第一个到最后一个，顺序遍历查找指定元素

    int indexOf(Object o);

（e）查看指定元素出现最后一个位置（lastIndexOf）

从最后一个到第一个，逆序查找指定元素

int lastIndexOf(Object o);

（f）查看所有元素（toArray）

i：如果是一个普通的类集合，不加任何泛型则返回一个Object[]

  Object[] toArray();

ii：如果加上泛型的约束，那么就返回 T[ ]

    <T> T[] toArray(T[] a);

3，其他方法：

这个是我认为不知道怎么划分所以放在这里：

（1）将List内部的元素排序

    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

Java源码无注释版：


package java.util;

import java.util.function.UnaryOperator;

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);
    
    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

  
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

   
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    void clear();

    boolean equals(Object o);

    int hashCode();
    
    E get(int index);

    E set(int index, E element);

    void add(int index, E element);

    E remove(int index);

    int lastIndexOf(Object o);


    ListIterator<E> listIterator();

    ListIterator<E> listIterator(int index);
    
    List<E> subList(int fromIndex, int toIndex);
    
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}