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