Java设计模式（二）——迭代模式

迭代模式的基本定义：对于一组对象集合（数组、堆栈、列表或散列），用户无需关心它的底层实现而能够通过调用统一接口遍历当中的所有元素。由于jdk已经对常见的迭代模式实现了封装，本文直接提供Collection和Iterator两个接口的模拟。

定义Iterator接口

/*
 * 设计迭代接口
 */
public interface Iterator<E> {
    // 测试是否有下一个元素
    boolean hasNext();
    // 返回下一个元素
    E next();
}

定义Collection接口

/*
 * 设计一个集合对象
 */
public interface Collection<E> {
    void add(E e);
    E get(int index);
    int size();
    // 要求实现类根据自身的特点实现迭代方法
    Iterator<E> iterator();
}

对于任何实现了接口的集合都能很方便的查找或遍历其中的元素。

创建使用数组方式存放元素集合的类：ArrayList

/*
 * 模拟jdk中ArrayList的实现
 */
public class ArrayList<E> implements Collection<E>, Iterator<E> {
    // 迭代下标
    private int iteratorIndex = 0;
    // 初始化的数组大小
    private Object[] objects = new Object[10];
    // 数组下标
    private int index = 0;

    @Override
    public void add(E e) {
        if (index == objects.length) {
            // 数组的增长的步长为10
            Object[] newObjects = new Object[objects.length + 10];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }
        objects[index] = e;
        index++;
    }

    // 通过ArrayList读取元素是一次性的，开销较小
    @Override
    public E get(int index) {
        if (index < this.index) {
            return (E) objects[index];
        } else {
            return null;
        }
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public Iterator<E> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        if (iteratorIndex < index) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public E next() {
        if (iteratorIndex < index) {
            E e = get(iteratorIndex);
            iteratorIndex++;
            return e;
        } else {
            return null;
        }
    }
}

创建使用链表方式存放元素集合的类：LinkedList

package iterator.jdk;
/*
 * 模拟jdk中LinkedList的实现
 */
public class LinkedList<E> implements Collection<E>, Iterator<E> {
    // 迭代下标
    private int iteratorIndex = 0;
    // 链表长度，随元素的数量逐步递增
    private int len = 0;
    
    private Node<E> headNode;
    private Node<E> tailNode;
    private Node<E> point;

    // 内部类实现链表对象的存储
    private class Node<E> {
        E e;
        Node<E> next;

        Node(E e, Node<E> next) {
            this.e = e;
            this.next = next;
        }

        public Object get() {
            return e;
        }

        public Node<E> getNext() {
            return next;
        }

        public void setNext(Node<E> next) {
            this.next = next;
        }
    }

    @Override
    public void add(E e) {
        // len==0既是把头元素放入也是将链表初始化
        if (len == 0) {
            headNode = new Node<E>(e, null);
            tailNode = headNode;
            point = headNode;
            len++;
        } else {
            Node<E> node = new Node<E>(e, null);
            tailNode.setNext(node);
            tailNode = node;
            len++;
        }
    }

    // 通过LinkedList每次读取元素都是一次迭代的过程，开销较大
    @Override
    public E get(int index) {
        if (index == 0) {
            return (E) headNode.get();
        } else if (index > 0 && index < this.len) {
            Node<E> node = headNode;
            for (int i = 1; i <= index; i++) {
                node = node.getNext();
            }
            return (E) node.get();
        } else {
            return null;
        }
    }

    @Override
    public int size() {
        return len;
    }

    @Override
    public Iterator<E> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        if (iteratorIndex < len) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public E next() {
        if (iteratorIndex < len) {
            E e = (E) point.get();
            point = point.getNext();
            iteratorIndex++;
            return e;
        } else {
            return null;
        }
    }

}

附A：JDK容器分类

附B：HashMap模拟实现

ArrayList遍历和查询持有对象更加敏捷，但是执行插入和移除操作没有LinkedList高效，反之亦如此。如何能够结合双方的优点实现更加高效的集合容器呢？Set采用的链表数组算法更优秀，Set底层依靠Map作为实现，这里提供HashMap的模拟。

1）新建MapEntry

package containers;

import java.util.*;
/*
 * 键-值对模型类
 */
public class MapEntry<K, V> implements Map.Entry<K, V> {
    private K key;
    private V value;

    public MapEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }

    // 重写对象hashCode值，更正规的写法应该要考虑到key==null或value==null的情况并分别处理。
    @Override
    public int hashCode() {
        if (key != null && value != null) {
            return key.hashCode() ^ value.hashCode();
        }
        return 0;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof MapEntry) {
            MapEntry mapEntry = (MapEntry) obj;
            return key.equals(mapEntry.getKey()) && value.equals(mapEntry.getValue());
        }
        return false;
    }

    @Override
    public String toString() {
        return key + "=" + value;
    }

}

2）通过MapEntry存储键-值对实现HashMap

package containers;

import java.util.*;

/*
 * HashMap的底层是一种链表数组的结构，依靠hashCode值取余确定数组下标，相同下标的对象依靠链表维护
 * 由此可见HashMap本质上无法保证元素加载顺序
 */
public class SimpleHashMap<K, V> extends AbstractMap<K, V> {
    // 设定数组长度
    private static final int SIZE = 999;
    // 初始化一个链表数组
    private LinkedList<MapEntry<K, V>>[] slots = new LinkedList[SIZE];

    public V put(K key, V value) {
        // 返回值
        V oldValue = null;
        int index = Math.abs(key.hashCode()) % SIZE;
        // 如果数组槽位为空则在当前槽位新建一个空列表
        if (slots[index] == null) {
            slots[index] = new LinkedList<MapEntry<K, V>>();
        }
        // 返回当前槽位链表
        LinkedList<MapEntry<K, V>> slot = slots[index];
        MapEntry<K, V> mapEntry = new MapEntry<K, V>(key, value);
        // 遍历整条链表，如果找到key值则覆盖，否则新增
        ListIterator<MapEntry<K, V>> it = slot.listIterator();
        while (it.hasNext()) {
            MapEntry<K, V> me = it.next();
            if (me.getKey().equals(key)) {
                oldValue = me.getValue();
                // 覆盖
                it.set(mapEntry);
                return oldValue;
            }
        }
        slots[index].add(mapEntry);
        return oldValue;
    }

    // 获取value的步骤是先命中槽位再遍历链表
    public V get(Object key) {
        int index = Math.abs(key.hashCode()) % SIZE;
        if (slots[index] != null) {
            for (MapEntry<K, V> me : slots[index]) {
                if (me.getKey().equals(key)) {
                    return me.getValue();
                }
            }
        }
        return null;
    }

    // 返回Set的步骤是先过滤空槽位再分别加载链表
    @Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> set = new HashSet<Map.Entry<K, V>>();
        for (LinkedList<MapEntry<K, V>> slot : slots) {
            if (slot != null) {
                set.addAll(slot);
            }
        }
        return set;
    }

}