实现一个简单的java集合框架

主要实现了集合框架中标准的bag，queue，stack三种结构，每种结构分别提供了数组和链表两种实现方式。

1.接口定义

1.1Collection接口：

/** *集合接口，主要定义了集合的长度和集合是否为空的方法 */public interface Collection {    boolean isEmpty();    int size();}

1.2Queue接口：

/** * * 这是一个队列接口，主要包括一个出队和入队方法 */public interface Queue<E> extends Collection{    void enqueue(E item);    E dequeue();}

1.3Stack接口：

/** *栈接口，定义了出栈和入栈方法 * @param <E> */public interface Stack<E> extends Collection{    void push(E item);    E pop();}

1.4Bag接口：

/** *背包接口 *只有一个add方法 * @param <E> */public interface Bag<E> extends Collection{    void add(E item);}

2.抽象类

2.1AbstractCollection集合抽象类：

/** *使用java的Iterable接口 *实现了集合两个主要方法 *该类中定义了集合共有属性和方法 * @param <E> */public abstract class AbstractCollection<E> implements Iterable<E>, Collection {//  集合的大小    int size;//  集合是否为空的判断    public boolean isEmpty() {        return size == 0;    }    public int size() {        return size;    }//  集合的toString    @Override    public String toString() {        Iterator<E> iter = iterator();        StringBuilder sb = new StringBuilder();        while (iter.hasNext()) {            sb.append(iter.next() + "  ");        }        return sb.toString();    }//  范围检查    protected void checkRange(int index) {        if (index >= size)            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));    }    private String outOfBoundsMsg(int index) {        return "Index: " + index + ", Size: " + size;    }}

2.2AbstractArrayList抽象数组类

/** *集合框架的数组实现方式 * @param <E> */public abstract class AbstractArrayList<E> extends AbstractCollection<E> {//  数组的初始容量    protected static final int DEFAULT_CAPACITY = 10;//  遍历的顺序有两种FIFO和LIFO 这种设计主要是考虑了stack，bag和queue迭代方式不同//  First Input First Output的缩写，先进先出//  Last  Input First Output的缩写，后进先出    protected boolean isFIFO = true;//  数组实现的核心    protected Object[] elementData;//  在该类中实现了迭代器    private class ArrayIterator<T> implements Iterator<T> {//      迭代器的游标        private int cursor = 0;//      迭代器的构造器        public ArrayIterator() {//          根据迭代器可以选择迭代顺序            if (isFIFO)                this.cursor = 0;            else                this.cursor = size;        }//              @Override        public boolean hasNext() {            if (isFIFO)                return this.cursor != size;            else                return this.cursor != 0;        }        @Override        public T next() {            T item;            if (isFIFO)                item = (T) elementData[cursor++];            else                item = (T) elementData[--cursor];            return item;        }    }//  迭代器    @Override    public Iterator<E> iterator() {        return new ArrayIterator<>();    }//  数组容量检查方法    protected void ensureCapacity() {        int capacity = elementData.length;        if (size >= capacity) {            int enlarge = capacity >> 1;            if (enlarge < DEFAULT_CAPACITY) {                enlarge = DEFAULT_CAPACITY;            }            grow(enlarge + capacity);        }    }//  数组扩容    private void grow(int minCapacity) {        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        elementData = Arrays.copyOf(elementData, newCapacity);    }}

2.3AbstractLinkedList抽象链表类

/** *抽象链表实现 * @param <E> */public abstract class AbstractLinkedList<E> extends AbstractCollection<E> {//  链表的头结点    protected Node<E> first;//  链表实现的核心内部类，节点    protected static class Node<E> {        E item;        Node<E> next;    }//  链表迭代器内部类    private class LinkedIterator<T> implements Iterator<T> {//      由第一个链表开始迭代        Node<E> current = first;        @Override        public boolean hasNext() {            return current != null;        }        @Override        public T next() {            T item = (T) current.item;            current = current.next;            return item;        }    }//  返回迭代器    @Override    public Iterator<E> iterator() {        return new LinkedIterator<>();    }}

3.数组实现

3.1使用数组的实现背包Bag：

/** *数组实现背包 * @param <E> */public class ArrayBag<E> extends AbstractArrayList<E> implements Bag<E> {//  初始化数组    public ArrayBag() {        this(DEFAULT_CAPACITY);    }    public ArrayBag(int initialCapacity) {        this.elementData = new Object[initialCapacity];//      Bag是LIFO后进先出的，因此这是false        this.isFIFO = false;    }//  加入Bag    @Override    public void add(E item) {        ensureCapacity();        elementData[size++] = item;    }}

3.2使用数组实现Queue：

/** * 使用数组实现队列 *  * @param <E> */public class ArrayQueue<E> extends AbstractArrayList<E> implements Queue<E> {    public ArrayQueue() {        this(DEFAULT_CAPACITY);    }    public ArrayQueue(int initialCapacity) {        this.elementData = new Object[initialCapacity];        // 队列是FIFO先进先出的        this.isFIFO = true;    }//  入队在结尾添加    @Override    public void enqueue(E item) {        ensureCapacity();        elementData[size++] = item;    }//  出队在开头移除    @Override    public E dequeue() {        E item = (E) elementData[0];        deleteFirst();        return item;    }    private void deleteFirst() {        size--;        Object[] newElementData = new Object[elementData.length - 1];        System.arraycopy(elementData, 1, newElementData, 0, size);        elementData = newElementData;    }}

3.3使用数组实现Stack：

/** *使用数组实现Stack * @param <E> */public class ArrayStack<E> extends AbstractArrayList<E> implements Stack<E> {    public ArrayStack() {        this(DEFAULT_CAPACITY);    }    public ArrayStack(int initialCapacity) {        this.elementData = new Object[initialCapacity];//      Stack是后进先出的        this.isFIFO = false;    }//  压栈    public void push(E item) {        ensureCapacity();        elementData[size++] = item;    }//  弹栈    public E pop() {        E item = (E) elementData[--size];        elementData[size] = null;        return item;    }}

4.链表实现

4.1链表实现Bag

/** * 使用链表实现Bag *  * @param <E> */public class LinkedBag<E> extends AbstractLinkedList<E> implements Bag<E> {    // 将元素加入背包    public void add(E item) {        Node<E> oldfirst = first;        first = new Node<>();        first.item = item;        first.next = oldfirst;        size++;    }}

4.2链表实现Queue

/** * 使用链表实现队列 *  * @param <E> */public class LinkedQueue<E> extends AbstractLinkedList<E> {    // 定义尾节点    private Node<E> last;    // 入队方法    public void enqueue(E item) {        Node<E> oldlast = last;        last = new Node<E>();        last.item = item;        last.next = null;        if (isEmpty())            first = last;        else            oldlast.next = last;        size++;    }    // 出队方法    public E dequeue() {        E item = first.item;        first = first.next;        if (isEmpty())            last = null;        size--;        return item;    }}

4.3使用链表实现Stack

/** *使用链表实现Stack * @param <E> */public class LinkedStack<E> extends AbstractLinkedList<E> implements Stack<E> {//  压栈    public void push(E item) {        Node<E> oldfirst = first;        first = new Node<>();        first.item = item;        first.next = oldfirst;        size++;    }//  在不弹栈的情况下拿到第一个值    public E peek() {        E item = first.item;        return item;    }//  弹栈    public E pop() {        E item = first.item;        first = first.next;        size--;        return item;    }    /**     * 删除该索引之后所有节点     * @param index     */    public void deleteAfter(int index) {        checkRange(index);        Node<E> node = first;        for (int i = 0; i < index; i++) {            node = node.next;        }        while (node.next != null) {            node.next = node.next.next;            size--;        }    }}