欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

AbstractCollection介绍

程序员文章站 2023-03-26 16:33:28
AbstractCollection介绍 AbstractCollection抽象类是Collection的基本实现,其实现了Collection中的大部分方法,可以通过继承此抽象类以最少的代价来自定义Collection; 如果要定义一个不可变Collection,只需要继承此类,并实现itera ......

abstractcollection介绍

  1. abstractcollection抽象类是collection的基本实现,其实现了collection中的大部分方法,可以通过继承此抽象类以最少的代价来自定义collection;

  2. 如果要定义一个不可变collection,只需要继承此类,并实现iterator和size方法,其中iterator方法返回的迭代器必须实现hasnext和next方法;
  3. 如果要定义一个可变collection,只需要继承此类,并实现iterator,size和add(默认会抛出unsupportedoperationexception)方法,其中iterator方法返回的迭代器必须实现remove方法;
  4. 按照collection接口中的规定,客户端程序员应该提供一个无参构造和以collection为参数的有参构造;
  5. 此抽象类的子类可以用更有效率的方式覆盖父类的方法;
  /**
     *从collection中继承过来的抽象方法 
     */
    public abstract iterator<e> iterator();
    public abstract int size();
    /**
     *直接返回 size() == 0,与size()的具体实现无关
     */
    public boolean isempty() {
         return size() == 0;
     }
    /**
     * 通过迭代器遍历所有元素,用equals方法比较,只要有一个符合条件的元素则返回true
     */
    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;
    }
    /**
     * 通过迭代器遍历集合中,转换为数组
     * 等价于
     * list<e> list = new arraylist<e>(size());
     * for (e e : this)
     *     list.add(e);
     * return list.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;
    }
    /**
     * 同上面的方法类似,比上面的方法常用,优点在于返回的数组不用做类型转换
     * 当参数数组容量不够时,将返回一个新的数组
     */
    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;
    }
    /**
     * 默认不支持add
     */
    public boolean add(e e) {
        throw new unsupportedoperationexception();
    }
    /**
     * 迭代器遍历集合,通过equals找到符合条件的元素,将其移除
     * 对于不可变集合,其迭代器的remove方法中会抛出unsupportedoperationexception
     */
    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方法
     */
    public boolean containsall(collection<?> c) {
        for (object e : c)
            if (!contains(e))
                return false;
        return true;
    }
    /**
     * foreach循环,调用自身add方法
     * 添加成功返回true,失败返回false
     */
    public boolean addall(collection<? extends e> c) {
        boolean modified = false;
        for (e e : c)
            if (add(e))
                modified = true;
        return modified;
    }
    /**
     * 调用迭代器遍历移除
     */
    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;
    }
    /**
     * 下面的方法类类似,都是通过迭代器操作,与迭代器的具体实现无关
     */
    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;
    }
    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(' ');
        }
    }