JDK源码解析之java.util.AbstractCollection

栗筝i

发布于 2022-12-01 20:23:31

1760

发布于 2022-12-01 20:23:31

文章被收录于专栏：迁移内容迁移内容

AbstractCollection类提供了collection的实现类应该具有的基本方法，具有一定的普适性，可以从大局上了解collection实现类的主要功能。

java.util.AbstractCollection这个类提供了对接口Collection骨骼级的实现。

一、源码解析

1、iterator():返回一个迭代器对象

public abstract Iterator<E> iterator();

2、 size():返回集合大小

public abstract int size();

3、isEmpty():判断是否为空

public boolean isEmpty() {
        return size() == 0;
}

4、contains(Object o):是否包含指定元素

    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

5、toArray()

在函数toArray()中，首先根据collection当前的大小初始化一个数组，并根据集合大小设定期望的元素个数。而后使用迭代器依次遍历集合中的元素，如果发现集合的元素自第i个起均被删除，则直接返回r中的前i个元素。如果发现在开始转化后，集合中插入了新的元素，则会进入：扩容+复制的循环。其中扩容部分将数组容量扩展到原来的1.5倍。当复制过程中，数组容量再次填满时，则又进行扩容。最后返回数组中所有有效的元素。

注意：该算法的复制并不是100%准确的，其只能保证其数组中元素的个数与集合迭代器遍历的元素个数相同，且顺序相同，而不是保证该数组中元素与集合元素相同。

5.1、把集合转成数组

    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

5.2、把集合转换为指定数组

    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        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
                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
        return it.hasNext() ? finishToArray(r, it) : r;
    }

5.3、扩容然后赋值的操作，下标i和数组长度r.length相等时，就进行一次扩容，最后返回数组元素数量大小的一个数组

    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

6、add():子类如果可以添加元素，需要重写add方法

public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

7、remove(Object o):应用迭代器，移除某个元素

    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;
    }

8、containsAll(Collection<?> c):是否包含指定数组的所有元素

    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

9、addAll(Collection<? extends E> c):循环调用add方法

    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

10、removeAll(Collection<?> c):移除与入参集合相同的元素

    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

11、retainAll(Collection<?> c):保留与入参集合中元素相同的元素

    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

12、clear()清空集合所有元素

    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }

13、toString():重写了toString方法

    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(' ');
        }
    }

二、拓展

1、AbstractCollection的protected构造函数

抽象类AbstractCollection居然有protected构造函数

protected AbstractCollection() {}

关于抽象类的protected构造方法：

首先，抽象类不能实例化是绝对正确的，因此抽象类中并不能包含public的构造方法；
抽象类protected构造方法会被隐性调用，因此并不一定在其子类的构造方法中显示调用super()，虽然对于AbstractCollection而言是建议这么做；
抽象类的protected构造方法可以用于初始化类中的某些属性，避免一场信息的出现。

2、只读集合、可修改集合

AbstractCollection将其实现类分成两种，一种为只读集合，另一种为可修改集合。

在只读集合中，只需要实现AbstractCollection中的iterator函数和size函数即可，其它的函数可以维持不变（在对性能没要求的前提下），这保证了实现类只需要少量的工作，便可以将集合的功能基本实现。

而对于可修改集合，AbstractCollection要求不仅需要实现其中的两个抽象方法，还需要实现add方法，并保证iterator函数返回的迭代器中实现了remove方法。

对于非抽象算法，AbstractCollection的建议为：如果有更加高效的实现方法，子类可以将其重写(override)

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2020-09-29，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

编程算法

java

登录后参与评论

0 条评论

热度