JDK源码之AbstractCollection

本文是基于jdk1.8下


AbstractCollection是继承于Collection,类中许多方法都是通过迭代器实现的。

AbstractCollection的构造器通过父类构造器实现,所以自己只有无方法体的构造器。以下两个方法也都是继承于Collection

protected AbstractCollection() {
    }

    //继承Collection的迭代器
    public abstract Iterator<E> iterator();
    //继承Collection的size方法,返回集合中元素个数
    public abstract int size();

    //检查是否为空,为空返回true,否则返回false
    public boolean isEmpty() {
        return size() == 0;
    }

检测集合是否包含元素o,首先需要判断元素o是否为null,然后通过迭代器实现

    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            //如果元素o为null,且集合中元素有null,则为真。
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

将集合元素改为数组形式,需区分数组长度是否少于预计的值

    public Object[] toArray() {
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // 元素少于预计值,调用Arrays.copeOf截取到i位置
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;//如果还有元素,调用finishToArray方法,否则则返回数组。
    }

与上一种方法相似,但是必须转换成与数组a相同的类型。

@SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        int size = size();
        //a数组能容纳该集合元素,则返回包含该集合元素的数组,否则,将创建一个能包含此集合元素同种类型的数组
        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()) {//没有元素 
                if (a == r) {
                    r[i] = null; 
                } 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();//迭代器赋值元素
        }
        // 集合元素多余数组的情况
        return it.hasNext() ? finishToArray(r, it) : r;
    }

设定限定值,以便下面方法使用

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//虚拟机会保存一下头文件在数组中,所以需要减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) {
                int newCap = cap + (cap >> 1) + 1;//扩充为原来2倍+1                
                if (newCap - MAX_ARRAY_SIZE > 0)//扩充超过限定值,需要调整容量
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        //扩充超过所需要,调整容量
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

超过限定值时,调整容量的方法

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // 调整的容量溢出,则抛出异常
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;//大于限定值,设为Integer.MAX_VALUE,小于或等于时,设为限定值
    }

添加元素方法,但是未实现

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

移除元素方法

public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {//判断是否为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;
    }

判断是否包含集合c中元素,只要有一个不包含则返回false

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

添加集合c中所有元素,但因add()方法未实现,所有此方法也未实现

    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) {
        Objects.requireNonNull(c);//检查集合c中是否含有null
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {//检查集合c中是否包含了迭代器中元素,只要有一个存在,就返回true
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

保留集合c中的元素

    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {//集合c中不包含迭代器中元素,则将迭代器中元素删除
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

清除集合

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

通过迭代器打印,格式为[a,b],集合元素之间有‘,’集合元素通过String.vauleOf()转换成String

    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
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值