zoukankan      html  css  js  c++  java
  • Java编程的逻辑 (52)

    本系列文章经补充和完善,已修订整理成书《Java编程的逻辑》,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接http://item.jd.com/12299018.html


    38节51节,我们介绍的都是具体的容器类,上节我们提到,所有具体容器类其实都不是从头构建的,它们都继承了一些抽象容器类。这些抽象类提供了容器接口的部分实现,方便了Java具体容器类的实现,理解它们有助于进一步理解具体容器类。

    此外,通过继承抽象类,自定义的类也可以更为容易的实现容器接口。为什么需要实现容器接口呢?至少有两个原因:

    • 容器类是一个大家庭,它们之间可以方便的协作,比如很多方法的参数和返回值都是容器接口对象,实现了容器接口,就可以方便的参与进这种协作。
    • Java有一个类Collections,提供了很多针对容器接口的通用算法和功能,实现了容器接口,就可以直接利用Collections中的算法和功能。 

    那,具体都有哪些抽象类?它们都提供了哪些基础功能?如何进行扩展?下面就来探讨这些问题。

    我们先来看都有哪些抽象类,以及它们与之前介绍的容器类的关系。

    抽象容器类

    抽象容器类与之前介绍的接口和具体容器类的关系如下图所示:

    虚线框表示接口,有Collection, List, Set, Queue, Deque和Map。

    有六个抽象容器类:

    • AbstractCollection: 实现了Collection接口,被抽象类AbstractList, AbstractSet, AbstractQueue继承,ArrayDeque也继承自AbstractCollection (图中未画出)。
    • AbstractList:父类是AbstractCollection,实现了List接口,被ArrayList, AbstractSequentialList继承。
    • AbstractSequentialList:父类是AbstractList,被LinkedList继承。
    • AbstractMap:实现了Map接口,被TreeMap, HashMap, EnumMap继承。
    • AbstractSet:父类是AbstractCollection,实现了Set接口,被HashSet, TreeSet和EnumSet继承。
    • AbstractQueue:父类是AbstractCollection,实现了Queue接口,被PriorityQueue继承。

    下面,我们分别来介绍这些抽象类。

    AbstractCollection

    功能说明

    AbstractCollection提供了Collection接口的基础实现,具体来说,它实现了如下方法:

    public boolean addAll(Collection<? extends E> c)
    public boolean contains(Object o)
    public boolean containsAll(Collection<?> c)
    public boolean isEmpty()
    public boolean remove(Object o)
    public boolean removeAll(Collection<?> c)
    public boolean retainAll(Collection<?> c)
    public void clear()
    public Object[] toArray()
    public <T> T[] toArray(T[] a)
    public String toString() 

    AbstractCollection又不知道数据是怎么存储的,它是如何实现这些方法的呢?它依赖于如下更为基础的方法:

    public boolean add(E e)
    public abstract int size();
    public abstract Iterator<E> iterator();

    add方法的默认实现是:

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

    抛出"操作不支持"异常,如果子类集合是不可被修改的,这个默认实现就可以了,否则,必须重写add方法。addAll方法的实现就是循环调用add方法。

    size方法是抽象方法,子类必须重写。isEmpty方法就是检查size方法的返回值是否为0。toArray方法依赖size方法的返回值分配数组大小。

    iterator方法也是抽象方法,它返回一个实现了迭代器接口的对象,子类必须重写。我们知道,迭代器定义了三个方法:

    boolean hasNext();
    E next();
    void remove();

    如果子类集合是不可被修改的,迭代器不用实现remove方法,否则,三个方法都必须实现。

    AbstractCollection中的大部分方法都是基于迭代器的方法实现的,比如contains方法,其代码为:

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

    通过迭代器方法循环进行比较。再比如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;
    }

    也是通过迭代器方法进行循环,通过迭代器的remove方法删除不在参数容器c中的每一个元素。

    除了接口中的方法,Collection接口文档建议,每个Collection接口的实现类都应该提供至少两个标准的构造方法,一个是默认构造方法,另一个接受一个Collection类型的参数。

    扩展例子

    具体如何通过继承AbstractCollection来实现自定义容器呢?我们通过一个简单的例子来说明。我们使用在泛型第一节自己实现的动态数组容器类DynamicArray来实现一个简单的Collection。

    DynamicArray当时没有实现根据索引添加和删除的方法,我们先来补充一下,补充代码为:

    public class DynamicArray<E> {
        //... ..
        public E remove(int index) {
            E oldValue = get(index);
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index + 1, elementData, index,
                        numMoved);
            elementData[--size] = null;
            return oldValue;
        }
        
        public void add(int index, E element) {
            ensureCapacity(size + 1);  
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            elementData[index] = element;
            size++;
        }
    }

    基于DynamicArray,我们实现一个简单的迭代器类DynamicArrayIterator,代码为:

    public class DynamicArrayIterator<E>  implements Iterator<E>{
        DynamicArray<E> darr;
        int cursor;      
        int lastRet = -1;
        
        public DynamicArrayIterator(DynamicArray<E> darr){
            this.darr = darr;
        }
        
        @Override
        public boolean hasNext() {
             return cursor != darr.size();
        }
    
        @Override
        public E next() {
            int i = cursor;
            if (i >= darr.size())
                throw new NoSuchElementException();
            cursor = i + 1;
            lastRet = i;
            return darr.get(i);
        }
    
        @Override
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            darr.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
        }
    }    

    代码很简单,就不解释了,为简单起见,我们没有实现实际容器类中的有关检测结构性变化的逻辑。

    基于DynamicArray和DynamicArrayIterator,通过继承AbstractCollection,我们来实现一个简单的容器类MyCollection,代码为:

    public class MyCollection<E> extends AbstractCollection<E> {
        DynamicArray<E> darr;
        
        public MyCollection(){
            darr = new DynamicArray<>();
        }
        
        public MyCollection(Collection<? extends E> c){
            this();
            addAll(c);
        }
    
        @Override
        public Iterator<E> iterator() {
            return new DynamicArrayIterator<>(darr);
        }
    
        @Override
        public int size() {
            return darr.size();
        }
    
        @Override
        public boolean add(E e) {
            darr.add(e);
            return true;
        }
    }      

    代码很简单,就是按建议提供了两个构造方法,并重写了size, add和iterator方法,这些方法内部使用了DynamicArray和DynamicArrayIterator。

    AbstractList

    功能说明

    AbstractList提供了List接口的基础实现,具体来说,它实现了如下方法:

    public boolean add(E e)
    public boolean addAll(int index, Collection<? extends E> c)
    public void clear()
    public boolean equals(Object o)
    public int hashCode()
    public int indexOf(Object o)
    public Iterator<E> iterator()
    public int lastIndexOf(Object o)
    public ListIterator<E> listIterator()
    public ListIterator<E> listIterator(final int index)
    public List<E> subList(int fromIndex, int toIndex)

    AbstractList是怎么实现这些方法的呢?它依赖于如下更为基础的方法:

    public abstract int size();
    abstract public E get(int index);
    public E set(int index, E element)
    public void add(int index, E element)
    public E remove(int index)

    size方法与AbstractCollection一样,也是抽象方法,子类必须重写。get方法根据索引index获取元素,它也是抽象方法,子类必须重写。

    set/add/remove方法都是修改容器内容,它们不是抽象方法,但默认实现都是抛出异常UnsupportedOperationException。如果子类容器不可被修改,这个默认实现就可以了。如果可以根据索引修改内容,应该重写set方法。如果容器是长度可变的,应该重写add和remove方法。

    与AbstractCollection不同,继承AbstractList不需要实现迭代器类和相关方法,AbstractList内部实现了两个迭代器类,一个实现了Iterator接口,另一个实现了ListIterator接口,它们是基于以上的这些基础方法实现的,逻辑比较简单,就不赘述了。

    扩展例子

    具体如何扩展AbstractList呢?我们来看个例子,也通过DynamicArray来实现一个简单的List,代码为:

    public class MyList<E> extends AbstractList<E> {
        private DynamicArray<E> darr;
        
        public MyList(){
            darr = new DynamicArray<>();
        }
        
        public MyList(Collection<? extends E> c){
            this();
            addAll(c);
        }
        
        @Override
        public E get(int index) {
            return darr.get(index);
        }
    
        @Override
        public int size() {
            return darr.size();
        }
    
        @Override
        public E set(int index, E element) {
            return darr.set(index, element);
        }
    
        @Override
        public void add(int index, E element) {
            darr.add(index, element);
        }
    
        @Override
        public E remove(int index) {
            return darr.remove(index);
        }
    }    

    代码很简单,就是按建议提供了两个构造方法,并重写了size, get, set, add和remove方法,这些方法内部使用了DynamicArray。

    AbstractSequentialList

    功能说明

    AbstractSequentialList是AbstractList的子类,也提供了List接口的基础实现,具体来说,它实现了如下方法:

    public void add(int index, E element)
    public boolean addAll(int index, Collection<? extends E> c)
    public E get(int index)
    public Iterator<E> iterator()
    public E remove(int index)
    public E set(int index, E element)

    可以看出,它实现了根据索引位置进行操作的get/set/add/remove方法,它是怎么实现的呢?它是基于ListIterator接口的方法实现的,在AbstractSequentialList中,listIterator方法被重写为了一个抽象方法:

    public abstract ListIterator<E> listIterator(int index)

    子类必须重写该方法,并实现迭代器接口。

    我们来看段具体的代码,看get/set/add/remove是如何基于ListIterator实现的,get方法代码为:

    public E get(int index) {
        try {
            return listIterator(index).next();
        } catch (NoSuchElementException exc) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }
    }

    代码很简单,其他方法也都类似,就不赘述了

    注意与AbstractList相区别,可以说,虽然AbstractSequentialList是AbstractList的子类,但实现逻辑和用法上,与AbstractList正好相反:

    • AbstractList需要具体子类重写根据索引操作的方法get/set/add/remove,它提供了迭代器,但迭代器是基于这些方法实现的。它假定子类可以高效的根据索引位置进行操作,适用于内部是随机访问类型的存储结构(如数组),比如ArrayList就继承自AbstractList。
    • AbstractSequentialList需要具体子类重写迭代器,它提供了根据索引操作的方法get/set/add/remove,但这些方法是基于迭代器实现的。它适用于内部是顺序访问类型的存储结构(如链表),比如LinkedList就继承自AbstractSequentialList。

    扩展例子

    具体如何扩展AbstractSequentialList呢?我们还是以DynamicArray举例来说明,在实际应用中,如果内部存储结构类似DynamicArray,应该继承AbstractList,这里主要是演示其用法。

    扩展AbstractSequentialList需要实现ListIterator,前面介绍的DynamicArrayIterator只实现了Iterator接口,通过继承DynamicArrayIterator,我们实现一个新的实现了ListIterator接口的类DynamicArrayListIterator,代码如下:

    public class DynamicArrayListIterator<E>  
        extends DynamicArrayIterator<E> implements ListIterator<E>{
        
        public DynamicArrayListIterator(int index, DynamicArray<E> darr){
            super(darr);
            this.cursor = index;
        }
        
        @Override
        public boolean hasPrevious() {
            return cursor > 0;
        }
    
        @Override
        public E previous() {
            if (!hasPrevious())
                throw new NoSuchElementException();
            cursor--;
            lastRet = cursor;
            return darr.get(lastRet);
        }
    
        @Override
        public int nextIndex() {
            return cursor;
        }
    
        @Override
        public int previousIndex() {
            return cursor - 1;
        }
    
        @Override
        public void set(E e) {
            if(lastRet==-1){
                 throw new IllegalStateException();
            }
            darr.set(lastRet, e);
        }
    
        @Override
        public void add(E e) {
            darr.add(cursor, e);
            cursor++;
            lastRet = -1;
        }
    }      

    逻辑比较简单,就不解释了,有了DynamicArrayListIterator,我们看基于AbstractSequentialList的List实现,代码如下:

    public class MySeqList<E> extends AbstractSequentialList<E> {
        private DynamicArray<E> darr;
        
        public MySeqList(){
            darr = new DynamicArray<>();
        }
        
        public MySeqList(Collection<? extends E> c){
            this();
            addAll(c);
        }
        
        @Override
        public ListIterator<E> listIterator(int index) {
            return new DynamicArrayListIterator<>(index, darr);
        }
    
        @Override
        public int size() {
            return darr.size();
        }
    }    

    代码很简单,就是按建议提供了两个构造方法,并重写了size和listIterator方法,迭代器的实现是DynamicArrayListIterator。

    AbstractMap

    功能说明

    AbstractMap提供了Map接口的基础实现,具体来说,它实现了如下方法:

    public void clear()
    public boolean containsKey(Object key)
    public boolean containsValue(Object value)
    public boolean equals(Object o)
    public V get(Object key)
    public int hashCode()
    public boolean isEmpty()
    public Set<K> keySet()
    public void putAll(Map<? extends K, ? extends V> m)
    public V remove(Object key)
    public int size()
    public String toString()
    public Collection<V> values()

    AbstractMap是如何实现这些方法的呢?它依赖于如下更为基础的方法:

    public V put(K key, V value)
    public abstract Set<Entry<K,V>> entrySet();

    putAll就是循环调用put。put方法的默认实现是抛出异常UnsupportedOperationException,如果Map是允许写入的,则需要重写该方法。

    其他方法都基于entrySet,entrySet是一个抽象方法,子类必须重写,它返回所有键值对的Set视图,这个Set实现类不应该支持add或remove方法,但如果Map是允许删除的,这个Set的迭代器实现类,即entrySet().iterator()的返回对象,必须实现迭代器的remove方法,这是因为AbstractMap的remove方法是通过entrySet().iterator().remove()实现的。

    除了提供基础方法的实现,AbstractMap类内部还定义了两个公有的静态内部类,表示键值对:

    AbstractMap.SimpleEntry implements Entry<K,V>
    AbstractMap.SimpleImmutableEntry implements Entry<K,V>

    SimpleImmutableEntry用于表示只读的键值对,而SimpleEntry用于表示可写的。

    Map接口文档建议,每个Map接口的实现类都应该提供至少两个标准的构造方法,一个是默认构造方法,另一个接受一个Map类型的参数。

    扩展例子

    具体如何扩展AbstractMap呢?我们定义一个简单的Map实现类MyMap,内部还是用DynamicArray:

    public class MyMap<K, V> extends AbstractMap<K, V> {
        private DynamicArray<Map.Entry<K, V>> darr;
        private Set<Map.Entry<K, V>> entrySet = null;
    
        public MyMap() {
            darr = new DynamicArray<>();
        }
    
        public MyMap(Map<? extends K, ? extends V> m) {
            this();
            putAll(m);
        }
    
        @Override
        public Set<Entry<K, V>> entrySet() {
            Set<Map.Entry<K, V>> es = entrySet;
            return es != null ? es : (entrySet = new EntrySet());
        }
    
        @Override
        public V put(K key, V value) {
            for (int i = 0; i < darr.size(); i++) {
                Map.Entry<K, V> entry = darr.get(i);
                if ((key == null && entry.getKey() == null)
                        || (key != null && key.equals(entry.getKey()))) {
                    V oldValue = entry.getValue();
                    entry.setValue(value);
                    return oldValue;
                }
            }
            Map.Entry<K, V> newEntry = new AbstractMap.SimpleEntry<>(key, value);
            darr.add(newEntry);
            return null;
        }
    
        class EntrySet extends AbstractSet<Map.Entry<K, V>> {
            public Iterator<Map.Entry<K, V>> iterator() {
                return new DynamicArrayIterator<Map.Entry<K, V>>(darr);
            }
    
            public int size() {
                return darr.size();
            }
        }
    }

    我们定义了两个构造方法,实现了put和entrySet方法。
    put方法先通过循环查找是否已存在对应的键,如果存在,修改值,否则新建一个键值对(类型为AbstractMap.SimpleEntry)并添加。
    entrySet返回的类型是一个内部类EntrySet,它继承自AbstractSet,重写了size和iterator方法,iterator方法中,返回的是迭代器类型是DynamicArrayIterator,它支持remove方法。

    AbstractSet

    AbstractSet提供了Set接口的基础实现,它继承自AbstractCollection,增加了equals和hashCode方法的默认实现。Set接口要求容器内不能包含重复元素,AbstractSet并没有实现该约束,子类需要自己实现。

    扩展AbstractSet与AbstractCollection是类似的,只是需要实现无重复元素的约束,比如,add方法内需要检查元素是否已经添加过了。具体实现比较简单,我们就不赘述了。

    AbstractQueue
    AbstractQueue提供了Queue接口的基础实现,它继承自AbstractCollection,实现了如下方法:

    public boolean add(E e)
    public boolean addAll(Collection<? extends E> c)
    public void clear()
    public E element()
    public E remove()

    这些方法是基于Queue接口的其他方法实现的,包括:

    E peek();
    E poll();
    boolean offer(E e);

    扩展AbstractQueue需要实现这些方法,具体逻辑也比较简单,我们就不赘述了。

    小结

    本节介绍了Java容器类中的抽象类AbstractCollection, AbstractList, AbstractSequentialList, AbstractSet, AbstractQueue以及AbstractMap,介绍了它们与容器接口和具体类的关系,对每个抽象类,介绍了它提供的基础功能,是如何实现的,并举例说明了如何进行扩展。

    前面我们提到,实现了容器接口,就可以方便的参与到容器类这个大家庭中进行相互协作,也可以方便的利用Collections这个类实现的通用算法和功能。

    但Collections都实现了哪些算法和功能?都有什么用途?如何使用?内部又是如何实现的?有何参考价值?让我们下一节来探讨。

    ----------------

    未完待续,查看最新文章,敬请关注微信公众号“老马说编程”(扫描下方二维码),从入门到高级,深入浅出,老马和你一起探索Java编程及计算机技术的本质。用心原创,保留所有版权。

  • 相关阅读:
    AIR配置文件(*app.xml)说明
    重学AS3之基础知识重点记忆
    重学AS3之高级知识重点记忆
    FLEX AIR添加系统托盘图标步骤
    FLASH组件在FLEX中使用
    ASP.NET入门教程:数据绑定
    ASP.NET入门教程:Web表单维持对象的ViewState
    ASP.NET入门教程:简单的ASP.NET页面
    ASP.NET入门教程:事件句柄
    ASP.NET入门教程:TextBox控件
  • 原文地址:https://www.cnblogs.com/swiftma/p/6044809.html
Copyright © 2011-2022 走看看