java 集合框架-AbstractCollection

Posted 2022-12-03 智公博客

AbstractCollection 作为顶级接口Collection的抽象实现子类，实现了一下集合基本方法：
- isEmpty
- contains
- toArray
- add
- remove
- containsAll
- addAll
- clear
- toString

下面我们一一看下实现的源码：

一、isEmpty

判断集合是否为空

    /**
     * @inheritDoc
     *
     * <p>This implementation returns <tt>size() == 0</tt>.
     */
    public boolean isEmpty() 
        return size() == 0;
    

判断集合是否为空，使用了size是否为空判断，但是该抽象类咩有实现size()方法，改方法的正确的性，依赖于子类实现size()方法的逻辑必须集合为空是size()=0；

二、contains

判断对象是否在集合中

    /**
     * @inheritDoc
     *
     * <p>This implementation iterates over the elements in the collection,
     * checking each element in turn for equality with the specified element.
     *
     * @throws ClassCastException   @inheritDoc
     * @throws NullPointerException @inheritDoc
     */
    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;
    

判断对象是否存在于集合中，由于集合可以存在null元素，改方法入参也有Null的可能，分两种情况遍历判断是否存在相等的元素；非空情况下，该方法的正确性会依赖于对象的equal方法是否正确；

三、toArray

获取包含集合中所有元素的对象数组

    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;
    

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

返回的数组是新创建的，并不是返回集合内部的数组；
使用迭代器遍历获取元素，可以看出这代码允许在迭代中集合元素个数发送变化：当元素减少，再截断复制一个数组返回；当元素增加，再使用 finishToArray 方法补全；finishToArray方法中会保证数组最大值；从源码可以看出，这些方法不是线程安全，当获取数组时，如果集合大小不断变化会发生不可预料的错误；

    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;
    

toArray的带入参重载函数，入参为一个元素数组，在入参数组足够大容纳集合中元素是，使用这个数组返回，否则新创建数组返回；

四、add

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

还不是很清楚为什么不支持这个操作还要实现这个方法？

五、remove

从集合中移除一个元素

    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;
    

与contains方法类是，使用迭代器遍历，分null与非null两种情况判断是否存在，存在在移除，不存在返回false；

六、containsAll

判断入参集合是否全部都在集合中存在

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

遍历调用contains方法判断是否存在，如有存在的元素，这个返回false，依赖contains方法正确性；

七、addAll

添加入参集合全部元素到集合中

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

遍历入参集合，将每个元素添加到集合中，返回值在add方法不能添加时返回false会导致结果不正确，导致部分成功添加也返回true；

八、removeAll

从集合中移除所有入参中集合中存在的元素

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

遍历入参集合，元素是否存在集合中，存在则移除；

九、retainAll

保留入参集合中元素，其他移除

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

代码和removeAll方法基本一样，逻辑相反；

十、clear

清空集合所有元素

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

使用迭代器遍历所有元素并移除；

十一、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(' ');
        
    

可以看出，平时使用List和Set的toString方法打印出来的格式就是这样，这里有一点需要注意，就是当集合元素中包含集合本身时，为不无限递归，只会打印”(this Collection)”；

AbstractCollection 抽象类实现的部分基础方法都比较简单，基本全部依赖于Iterator迭代器实现，可见集合框架中迭代器的重要性；