学习 List

最新推荐文章于 2021-10-20 00:01:46 发布

是否_

最新推荐文章于 2021-10-20 00:01:46 发布

阅读量110

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_42409478/article/details/103441407

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

学习 List

List 是开发中最常用的类，了解 List 可以提高我们编程效率，今天就来了解一下 List 的常用 API 以及 ArrayList 是如何实现的。

迭代器

学习 List 之前，我们有必要先了解一下 Iterable， Iterator 和 ListIterator 这三个接口， 它们与 List 的迭代息息相关。

Iterable

Iterable 源码：

public interface Iterable<T> {
    Iterator<T> iterator();
}

Iterable（可迭代）：故名思议，实现了这个接口的集合类支持迭代，是可迭代的。able 结尾表示能…样，可以做…。

我们可以看到 Iterable 接口非常简单，只有一个 iterator() 方法，用于返回一个迭代器[1]

[1]：在 Java 8 中，还新增了 default 方法 forEach() 和 Spliterator()，为了使文章简明，展示在这里。

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

default Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

Iterator

Iterator 源码：

public interface Iterator<E> {
    boolean hasNext();
    E next();
}

Iterator（迭代器）：英语中 or 结尾表示…样的人或…者，如 creator （创作者）这里也一样，Iterator 就是迭代者，我们一般叫迭代器。它是提供迭代机制的对象，具体如何迭代，都是 Iterator 接口规范的。

我们可以看到 Iterator 中有两个方法， hasNext() 是否还有元素可迭代，next() 返回一个元素。

使用 Iterator 打印 List 的元素

public void printList() {
    List<Integer> list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);

    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

[2]：在 Java 8 中，还新增了 default 方法 forEach() 和 Spliterator()，为了使文章简明，展示在这里。

default void remove() {
    throw new UnsupportedOperationException("remove");
}

default void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    while (hasNext())
        action.accept(next());
}

ListIterator

ListIterator 源码：

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations
    boolean hasNext(); // @Override
    E next(); // @Override
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();

    // Modification Operations
    void remove(); // @Override
    void set(E e);
    void add(E e);
}

ListIterator 可以理解为 Iterator 的增强版，在 Iterator 的基础上增加 hasPrevious()，previous()，nextIndex() ，previousIndex()，set(E e)，add(E e) 方法，实现向前遍历，修改元素，插入元素的功能。

我们需要理解一下游标这个概念，如图，游标总是处于元素之间。初始位于第 0 个元素之前，调用 next() 加一，调用 previous() 减一。

boolean hasPrevious() 游标前面是否有元素
E previous()  返回游标前面的元素，同时游标减一
int nextIndex() 返回游标后面元素的下标，也就是迭代器最后一次操作元素的下标。[3]
int previousIndex() 返回游标前面元素的下标，也就是迭代器最后一次操作元素的下标加一。
void set(E e) 修改迭代器最后一次操作的元素为 e
void add(E e) 插入元素

[3]：迭代器最后一次操作的元素，也就是最后一次调用 next() 或者 previous() 返回的元素。
注意，调用 set()，add()，remove() 时，当没有迭代，也就是没有调用 next() 或者 previous() 时会报 java.lang.IllegalStateException 错;

使用 ListIterator 打印 List

public void useListIterator() {
    List<Integer> list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);

    ListIterator<Integer> iterator = list.listIterator();

    iterator.next();  // 1
    iterator.next();  // 2
    iterator.next();  // 3

    System.out.println(iterator.previousIndex());  // 2
    iterator.remove();
    System.out.println(iterator.nextIndex());  // 2

    System.out.println(list); // [1, 2, 4, 5, 6, 7]

    iterator.add(3);
    System.out.println(list); // [1, 2, 3, 4, 5, 6, 7]
}

了解完迭代器，我们可以看一下 Collection 和 AbstractCollection 了。

Collection 和 AbstractCollection

Collection

Collection 源码[4]：

public interface Collection<E> extends Iterable<E> {
    // Query Operations
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);

    // Modification Operations
    boolean add(E e);
    boolean remove(Object o);

    // Bulk Operations
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
}

Collection 接口继承了 Iterable，说明可以被迭代。其主要是定义一些子类需要实现的对集合进行操作的方法，下面我们先简单了解这些方法。

    int size(); // 元素的个数
    boolean isEmpty(); // 元素是否为 0 个
    boolean contains(Object o); // 是否包含指定元素 o
    Iterator<E> iterator(); // 返回一个迭代器
    Object[] toArray(); // 返回一个包含集合中所有元素的数组
    <T> T[] toArray(T[] a); // 返回一个包含集合中所有元素的数组，运行时根据集合元素的类型指定数组的类型

    // Modification Operations
    boolean add(E e); // 添加元素
    boolean remove(Object o); // 删除元素

    // Bulk Operations
    boolean containsAll(Collection<?> c); // 是否包含指定集合 c 中的所有元素
    boolean addAll(Collection<? extends E> c); // 添加集合 c 所有元素到本集合中，有改变返回 true
    boolean removeAll(Collection<?> c); // 删除本集合与 c 集合相等的元素，有改变返回 true
    boolean retainAll(Collection<?> c); // 保留本集合与 c 集合相等的元素（取交集），有改变返回 true
    void clear(); // 删除所有元素

[4]: Collection 还包括以下方法，为了使文章简明，展示在这里。

default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}

// Comparison and hashing
boolean equals(Object o);
int hashCode();
@Override
default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, 0);
}
default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}

stream(), parallelStream() 是 Java 8 为了集合进行操作聚合操作的方法。聚合操作通常和 lambda 表达式结合使用，让代码看起来更简洁。

输出偶数：

public void useStream(){
    List<Integer> list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    list.add(8);

    Stream<Integer> stream = list.stream();
    stream.filter(e -> e%2 == 0).forEach(System.out::println);
}

parallelStream() 与 stream() 的区别是可以获取一个并行流（parallelStream），当集合元素很多时使用并发可以提高效率。

AbstractCollection

AbstractCollection 是 Java 集合框架中 Collection 接口的一个直接实现类， Collection 下的大多数子类都继承 AbstractCollection ，比如 List 的实现类, Set的实现类。

AbstractCollection 源码：

public abstract class AbstractCollection<E> implements Collection<E> {
    
    // 请注意，默认的构造函数是 protected 的，官方推荐子类自己创建一个无参构造函数
    protected AbstractCollection() {
    }


    // 两个抽象的方法，子类必须实现
    // Query Operations
    public abstract Iterator<E> iterator();
    public abstract int size();

    // 元素个数是否为 0
    public boolean isEmpty() {
        return size() == 0;
    }
    
    // 是否包含指定元素 o
    public boolean contains(Object o) {
        // 获取子类迭代器
        Iterator<E> it = iterator();
        if (o==null) {
            // 循环判断，相等返回
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            // 循环判断，相等返回
            // 元素需重写 equals() 方法
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }
    
    // 返回包含所有元素的数组
    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        // 初始化 size() 长度的数组
        Object[] r = new Object[size()];
        // 获取子类迭代器
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            // 元素少于预期，调用 Arrays.copyOf()，返回长度为 i 的数组
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            // 将元素放入数组    
            r[i] = it.next();
        }
        // 元素超于预取，调用 finishToArray() 方法
        // 元素符合预期，返回数组
        return it.hasNext() ? finishToArray(r, it) : r;
    }
    
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    @SuppressWarnings("unchecked")
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        // 记录数组的长度
        int i = r.length;
        while (it.hasNext()) {
            // 记录数组的长度
            int cap = r.length;
            // 比较两次数组的长度是否相等，第一次循环相等
            if (i == cap) {
                // 计算新的数组长度，cap + cap/2 + 1
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                // 检查新的数组长度是否大于 Integer 最大值减八，大于则调用 hugeCapacity 方法
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                // 数组扩容为新长度    
                r = Arrays.copyOf(r, newCap);
            }
            // 将元素放入数组中，并且 i 加一
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        // 判断数组是否放满
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }
    
    private static int hugeCapacity(int minCapacity) {
        // 小于 0 抛出异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        // 大于 Integer 最大值减八，则返回 Integer 最大值，否则返回 Integer 最大值减八
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    
    // 返回带有类型的数组
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        // 本集合元素个数
        int size = size();
        // 比较本集合元素个数 size 与传入数组 a 的长度，若本集合元素个数大则创建长度为 size 的 T 类型的数组（数组中的元素为 null）赋值给 r ，否则将传入的数组 a 赋值给 r
        T[] r = a.length >= size ? a : (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
        // 获取迭代器
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            // 不可以迭代
            if (! it.hasNext()) { // fewer elements than expected
                // 若 r 引用的就是 a，则让 a 数组 i 位标后面的值全部为null。
                // 若 r 引用不是 a，说明是根据 size 新建的新数组。
                // 如果传入数组 a 的长度小于 i，说明这些值没办法放入到 a 中，需要返回的是新建的数组而不是传入的数组 a，所有只要对 r 进行截断返回就可以了
                // a > i，这说明了传入的数组 a 是可以放入足够的参数的，这里将 r 中的所有元素复制到 a 中，并进行截断然后返回。对于 a 中大于迭代器数量的的元素全部换成 null。
                if (a == r) {
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            // 将集合元素放入数组
            r[i] = (T)it.next();
        }
        // more elements than expected
        // 若r 数组大小用完，迭代器还可迭代，调用 finishToArray() 方法
        return it.hasNext() ? finishToArray(r, it) : r;
    }
    
    // Modification Operations
    // AbstractCollection 不支持添加单个元素，调用抛出异常[5]
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    // 删除指定元素 o，删除成功返回 true
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }

    // Bulk Operations
    // 是否包含指定集合 c 的所有元素
    public boolean containsAll(Collection<?> c) {
        // 循环
        for (Object e : c)
            // 若不包含 c 中的某一元素，返回 false
            if (!contains(e))
                return false;
        return true;
    }

    // 添加集合 c 的所有元素到本集合中
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

    // 删除本集合中与指定集合 c 相等的元素
    public boolean removeAll(Collection<?> c) {
        // 判断是否为 null， 为 null 抛出异常
        Objects.requireNonNull(c);
        // 是否修改
        boolean modified = false;
        // 获取迭代器
        Iterator<?> it = iterator();
        // 循环
        while (it.hasNext()) {
            // 若集合 c 包括此元素则删除，同时修改 modified 为 true
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    // 保留本集合和指定集合 c 相等的元素（取交集）
    public boolean retainAll(Collection<?> c) {
        // 判断是否为 null， 为 null 抛出异常
        Objects.requireNonNull(c);
        // 是否修改
        boolean modified = false;
        // 获取迭代器
        Iterator<E> it = iterator();
        // 循环
        while (it.hasNext()) {
            // 若集合 c 不包括此元素则删除，同时修改 modified 为 true
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }
    
    // 删除所有元素
    public void clear() {
        // 获取迭代器
        Iterator<E> it = iterator();
        // 循环删除
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }
    
    //  String conversion
    // 重写 toString() 方法，我们能直接输出集合的全部内容，而不用挨个遍历输出，全都是 AbstractCollection 的功劳
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
}

AbstractCollection 对 Collection 接口的一些方法进行了实现，但它任然是一个抽象类。它使我们实现自己的集合变的容易:

若我们要实现一个不可更改的集合，只要继承这个类并且实现 iterator() 和 size() 方法就行。
若我们要实现一个可更改的集合，需要实现 add() 和 iterator() 的方法，当然可选的实现remove方法

注意：我们通常应该提供两个构造器，一个无参的，一个是包含集合元素的

[5]：add(E) 方法默认是抛出异常，这样会不会容易导致问题？为什么不定义为抽象方法？

答案译来自 stackoverflow :

1. 如果你想修改一个不可变的集合时，抛出 UnsupportedOperationException 是标准的行为，比如 当你用 Collections.unmodifiableXXX() 方法对某个集合进行处理后，再调用这个集合的修改方法（add,remove,set…），都会报这个错。
因此 AbstractCollection.add(E) 抛出这个错误是准从标准；

2. 之所以没有定义为抽象方法，是因为可能有很多地方用不到这个方法，用不到还必须实现，这岂不是让人很困惑么。

参考：

Java 集合源码解析

是否_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习 List

学习 ListList 是开发中最常用的类，了解 List 可以提高我们编程效率，今天就来了解一下 List 的常用 API 以及 ArrayList 是如何实现的。迭代器学习 List 之前，我们有必要先了解一下 Iterable， Iterator 和 ListIterator 这三个接口，它们与 List 的迭代息息相关。IterableIterable 源码：public ...
复制链接

扫一扫