实现一个简单的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--;
        }
    }
}