[Java]ArrayList与LinkedList的模拟实现

    Java中的List继承自Collection接口。List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。跟Set集合不同的是，List允许有重复元素。对于满足e1.equals(e2)条件的e1与e2对象元素，可以同时存在于List集合中。当然，也有List的实现类不允许重复元素的存在。除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

    实现List接口的常用类有LinkedList，ArrayList，这里模拟两种List的特点进行实现从而加深理解。

一、 双向链表LinkedSequence：

a) 私有成员变量：

	private Entry head;
	private int cnt;

i. head为Entry型的每个LinkedSequence头指针，通过它能够访问该对象的所有内部数据，注意head不存储数据，只是用作头节点标记。
Entry结构具体在下面介绍。
ii. cnt记录每个LinkedSequence内部的成员个数，为了方便内部类的使用，创建了私有方法setSize()对齐进行修改。

b) 私有内部静态类：

private static class Entry {
	SequenceItem si;
	Entry befo;
	Entry next;
	Entry(SequenceItem si, Entry befo, Entry next) {
		this.si = si;
		this.befo = befo;
		this.next = next;
	}
}

每个实体含有一个SequenceItem型的私有成员变量si，指向前一个Entry的引用befo，指向下一个Entry的引用next。
c) 构造函数：

LinkedSequence() {
	head = new Entry(null, null, null);
	head.next = head;
	head.befo = head;
	cnt = 0;
}

i. 将head初始化，所有数据成员均为空；
ii. 将head的next和befo均标记为自己；
iii. cnt计数清零。

d) 公有方法：

i. public void add(SequenceItem item)链表尾段添加item元素：
创建一个Entry型的tmp，它的si为item，befo即head的befo(head的befo指向链表中的最后一个Entry)，next即head。
将原来的末端元素的next标记为tmp，将head的befo指向新的末端元素tmp。
计数器cnt加一。

ii. public SequenceItem get(int i)获取链表中第i个元素，起始下标为0：
如果索引i超出[0, cnt)，则抛出越界异常。
创建Entry e指向第一个元素，通过next向后迭代i次，返回此时的e.si。

iii. public void remove(SequenceItem item)删除链表中的第一个item元素：
如果item为空，不做处理；
创建Entry e指向第一个元素，根据e扫描链表，如果有一个e的si与item相等，创建一个Entry tmp指向此时的e，将e的前驱节点的next标记为e的后继节点，将e的后继节点的befo标记为e的前驱结点。
将tmp的befo、next和si均标记为空，计数器cnt减一。
如果遍历整个列表结束后没有找到，则抛出NoSuchElementException异常。

iv. public boolean contains(SequenceItem item)判断链表中是否含有item元素：
与remove()操作类似，只不过返回true和false不做敖述。

v. public int size()返回链表的长度：返回cnt。

vi. public boolean isEmpty()判断链表是否为空：
返回cnt==0?

vii. public SequenceItem[] toArray()将链表转化为数组：
创建一个大小为cnt的SequenceItem数组ans，依次将链表中每个节点e的si放入ans即可。

viii. public boolean equals(Sequence seq)判断两个链表元素是否相对：
如果两个Sequence的大小不等，则不再进行比较，直接返回false。
否则依次比较两个sequence的全部元素，一旦含有一个不同则返回false。

ix. public String toString()将链表转化为字符串：
与toArray类似，只不过将原来的ans用string存储，并在放入结束后返回Arrays.toString(ans)。

x. public SeqIterator iterator()正向迭代器：
返回一个SeqIterator的内部匿名类对象，含有私有成员变量index，记录当前访问元素的相对位置，初始化为0；Entry e记录当前将要访问的节点，初始化为链表的第一个元素。
public boolean hasNext()：返回index是否小于LinkedSequence.this.size()。
public SequenceItem next()：返回当前e.si，index加1，e指向e.next。
public void remove()：只有当index大于0时，才可以将前一个元素删除，删除操作同remove()。注意删除后需要将index减一！

xi. public SeqIterator reverseIterator()反向迭代器：
返回一个SeqIterator的内部匿名类对象，含有私有成员变量index，记录当前访问元素的相对位置，初始化为size()-1；Entry e记录当前将要访问的节点，初始化为链表的最后一个元素。
public boolean hasNext()：返回index是否大于-1。
public SequenceItem next()：返回当前e.si，index减1，e指向e.befo。
public void remove()：只有当index小于size()-1时，才可以将后一个元素删除，删除操作同remove()。注意此时无需修改index。

xii. public BiSeqIterator biIterator()双向迭代器：
即前两种迭代器的综合。

二、 变长数组ArraySequence：

a) 私有成员变量：

	private SequenceItem[] sequenceItemArray = new SequenceItem[2];
	private int cnt = 0;

i. sequenceItemArray为每个ArraySequence数据存储数组。
ii. cnt记录每个ArraySequence内部的成员个数，与数组大小不同。

b) 构造函数：

ArraySequence() {
	sequenceItemArray = new SequenceItem[2];
	cnt = 0;
}

i. 将sequenceItemArray初始化大小为2；
ii. cnt计数清零。

c) 公有方法：基本与LinkedSequence类似，主要区别在于add()和remove()操作。
i. public void add(SequenceItem item)数组中添加item元素：
首先确保sequenceItemArray的大小可以装下cnt+1个元素，如果超出sequenceItemArray的大小，需要将当前数组大小扩充为原来的一倍，再将item放入，计数器cnt加一。

ii. public void remove(SequenceItem item)删除链表中的第一个item元素：
首先在sequenceItemArray中寻找item的下标，记为i，则后面的cnt-i-1个元素都需要前移，之后将cnt-1下标处置为空。
以上完成了删除操作，需要对容器的大小重新确定，如果当前cnt不足sequenceItemArray长度的1/4，则可将sequenceItemArray的长度缩短一半，方法类似于扩张的方法。

三、 性能比较：

四、源码：

Sequence接口：

import java.util.*;
interface Sequence {
	void add(SequenceItem item);
	SequenceItem get(int i);
	void remove(SequenceItem item);
	boolean contains(SequenceItem item);
	int size();
	boolean isEmpty();
	SeqIterator iterator();
	SeqIterator reverseIterator();
	BiSeqIterator biIterator();
	SequenceItem[] toArray();
	boolean equals(Sequence seq);
	String toString();
}

SeqIterator接口：

interface SeqIterator {
	boolean hasNext();
	SequenceItem next();
	void remove();
}

数据成员SequenceItem类：

public class SequenceItem {
	private String data;
	public String getData() {
		return data;
	}
	public void setData(String s) {
		data = new String(s);
	}
	public boolean equals(SequenceItem si) {
		return this.getData().equals(si.getData());
	}
}

双向链表LinkedSequence：

import java.util.*;
public class LinkedSequence implements Sequence {
	private Entry head;
	private int cnt;
	private static class Entry {
		SequenceItem si;
		Entry befo;
		Entry next;
		Entry(SequenceItem si, Entry befo, Entry next) {
			this.si = si;
			this.befo = befo;
			this.next = next;
		}
	}
	LinkedSequence() {
		head = new Entry(null, null, null);
		head.next = head;
		head.befo = head;
		cnt = 0;
	}
	public void add(SequenceItem item) {
		Entry tmp = new Entry(item, head.befo, head);
		tmp.befo.next = tmp;
		head.befo = tmp;
		cnt++;
	}
	public SequenceItem get(int i) {
		if (i >= cnt || i < 0) {
			throw new IndexOutOfBoundsException();
		}
		Entry e = head.next;
		for (int j = 0; j < i; j++) {
			e = e.next;
		}
		return e.si;
	}
	public void remove(SequenceItem item) {
		if (item == null) {
			return;
		}
		Entry e = head.next;
		for (int i = 0; i < cnt; i++) {
			if (item.equals(e.si)) {
				Entry tmp = e;
				tmp.befo.next = tmp.next;
				tmp.next.befo = tmp.befo;
				tmp.befo = null;
				tmp.next = null;
				tmp.si = null;
				cnt--;
				return;
			}
			e = e.next;
		}
		throw new NoSuchElementException();
	}
	public boolean contains(SequenceItem item) {
		if (item == null) {
			return false;
		}
		Entry e = head.next;
		for (int i = 0; i < cnt; i++) {
			if (item.equals(e.si)) {
				return true;
			}
			e = e.next;
		}
		return false;
	}
	public int size() {
		return this.cnt;
	}
	private void setSize(int cnt) { // use for inner class to modify cnt
		this.cnt = cnt;
		// System.out.println("cnt:"+this.cnt);
	}
	public boolean isEmpty() {
		return this.cnt==0 ? true:false;
	}
	public SeqIterator iterator() {
		return new SeqIterator() {
			private int index = 0;
			private Entry e = head.next;
			public boolean hasNext() {
				return index<LinkedSequence.this.size();
			}
			public SequenceItem next() {
				SequenceItem res = e.si;
				e = e.next;
				index++;
				return res;
			}
			public void remove() {
				if (index > 0) {
					Entry tmp = e.befo;
					tmp.befo.next = tmp.next;
					tmp.next.befo = tmp.befo;
					tmp.befo = null;
					tmp.next = null;
					tmp.si = null;
					index--;
					LinkedSequence.this.setSize(LinkedSequence.this.size()-1);
				}
			}
		};
	}
	public SeqIterator reverseIterator() {
		return new SeqIterator() {
			private int index = LinkedSequence.this.size()-1;
			private Entry e = head.befo;
			public boolean hasNext() {
				return index>-1;
			}
			public SequenceItem next() {
				SequenceItem res = e.si;
				e = e.befo;
				index--;
				return res;
			}
			public void remove() {
				if (index < LinkedSequence.this.size()-1) {
					Entry tmp = e.next;
					tmp.befo.next = tmp.next;
					tmp.next.befo = tmp.befo;
					tmp.befo = null;
					tmp.next = null;
					tmp.si = null;
					LinkedSequence.this.setSize(LinkedSequence.this.size()-1);
				}
			}
		};
	}
	public BiSeqIterator biIterator() {
		return new BiSeqIterator() {
			private int index = 0;
			private Entry e = head.next;
			public boolean hasNext() {
				return index<LinkedSequence.this.size();
			}
			public SequenceItem next() {
				SequenceItem res = e.si;
				e = e.next;
				index++;
				return res;
			}
			public void remove() {
				if (index > 0) {
					Entry tmp = e.befo;
					tmp.befo.next = tmp.next;
					tmp.next.befo = tmp.befo;
					tmp.befo = null;
					tmp.next = null;
					tmp.si = null;
					index--;
					LinkedSequence.this.setSize(LinkedSequence.this.size()-1);
				}
			}
			public boolean hasPrevious() {
				// System.out.println(index);
				return index>-1;
			}
			public SequenceItem previous() {
				SequenceItem res = e.si;
				e = e.befo;
				index--;
				return res;
			}
		};
	}
	public SequenceItem[] toArray() {
		SequenceItem[] ans = new SequenceItem[cnt];
		Entry e = head.next;
		for (int i = 0; i < cnt; i++) {
			ans[i] = e.si;
			e = e.next;
		}
		return ans;
	}
	public boolean equals(Sequence seq) { //?
		if (this.size() != seq.size()) {
			return false;
		}
		Entry e1 = this.head.next;
		for (int i = 0; i < cnt; i++) {
			if (!e1.si.equals(seq.get(i))) {
				return false;
			}
			e1 = e1.next;
		}
		return true;
	}
	public String toString() {
		String[] s = new String[cnt];
		Entry e = head.next;
		for (int i = 0; i < cnt; i++) {
			s[i] = e.si.getData();
			e = e.next;
		}
		return Arrays.toString(s);
	}
}

变长数组ArraySequence：

import java.util.*;
public class ArraySequence implements Sequence {
	private SequenceItem[] sequenceItemArray;
	private int cnt;
	ArraySequence() {
		sequenceItemArray = new SequenceItem[2];
		cnt = 0;
	}
	private void ensureCapacity(int currCapacity) {
		if (currCapacity >= sequenceItemArray.length) {
			int newCapacity = sequenceItemArray.length<<1;
			sequenceItemArray = Arrays.copyOf(sequenceItemArray, newCapacity);
		}
		else if (currCapacity < sequenceItemArray.length/4) {
			int newCapacity = sequenceItemArray.length>>1;
			sequenceItemArray = Arrays.copyOf(sequenceItemArray, newCapacity);
		}
	}
	public void add(SequenceItem item) {
		ensureCapacity(cnt+1);
		sequenceItemArray[cnt++] = item;
	}
	public SequenceItem get(int i) {
		return sequenceItemArray[i];
	}
	public void remove(SequenceItem item) {
		if (item != null) {
			for (int i = 0; i < cnt; i++) {
				if (item.equals(sequenceItemArray[i])) {
					int numMoved = cnt-i-1;
					if (numMoved > 0) {
						System.arraycopy(sequenceItemArray, i+1, sequenceItemArray, i, numMoved);
					}
					sequenceItemArray[--cnt] = null;
					ensureCapacity(cnt);
					return;
				}
			}
		}
	}
	public boolean contains(SequenceItem item) {
		for (int i = 0; i < cnt; i++) {
			if (item.equals(sequenceItemArray[i])) {
				return true;
			}
		}
		return false;
	}
	public int size() {
		// System.out.println(cnt+","+sequenceItemArray.length);
		return cnt;
	}
	public boolean isEmpty() {
		return cnt==0 ? true:false;
	}
	public SeqIterator iterator() {
		return new SeqIterator() {
			private int index = 0;
			public boolean hasNext() {
				return index<cnt;
			}
			public SequenceItem next() {
				return sequenceItemArray[index++];
			}
			public void remove() {
				if (index > 0) {
					ArraySequence.this.remove(ArraySequence.this.get(--index));
				}
			}
		};
	}
	public SeqIterator reverseIterator() {
		return new SeqIterator() {
			private int index = ArraySequence.this.size()-1;
			public boolean hasNext() {
				return index>-1;
			}
			public SequenceItem next() {
				return ArraySequence.this.get(index--);
			}
			public void remove() {
				ArraySequence.this.remove(ArraySequence.this.get(index+1));
				if (index >= ArraySequence.this.size()) {
					index = ArraySequence.this.size()-1;
				}
			}
		};
	}
	public BiSeqIterator biIterator() {
		return new BiSeqIterator() {
			private int index = 0;
			public boolean hasNext() {
				return index<ArraySequence.this.size();
			}
			public SequenceItem next() {
				return ArraySequence.this.get(index++);
			}
			public void remove() {
				if (index > 0) {
					ArraySequence.this.remove(ArraySequence.this.get(--index));	
				}
			}
			public boolean hasPrevious() {
				return index>0;
			}
			public SequenceItem previous() {
				return ArraySequence.this.get(--index);
			}
		};
	}
	public SequenceItem[] toArray() {
		return sequenceItemArray;
	}
	public boolean equals(Sequence seq) {
		if (this.size() !=seq.size()) {
			return false;
		}
		for (int i = 0; i < this.size(); i++) {
			if (!this.get(i).equals(seq.get(i))) {
				return false;
			}
		}
		return true;
	}
	public String toString() {
		String[] s = new String[cnt];
		for (int i = 0; i < cnt; i++) {
			s[i] = sequenceItemArray[i].getData();
		}
		return Arrays.toString(s);
	}
}

附测试程序test.java：

import java.util.*;
public class test {
	public static void main(String[] args) {
		// Sequence test = new LinkedSequence();
		Sequence test = new ArraySequence();
		SequenceItem tmp = new SequenceItem();
		// Test add(), size()
		for (int cnt = 1000; cnt <= 1000000; cnt *= 10) {
			int testTime = 10;
			double ans = 0;
			double[] res = new double[testTime];
			while (testTime > 0) {
				// Date begin = new Date();
				for (int i = 0; i < cnt; i++) {
					tmp.setData(String.valueOf(i));
					test.add(tmp);
					// System.out.println(test.size());
				}
				// Date end = new Date();

				// Date begin = new Date();
				// for (int i = 0; i < cnt; i++) {
				// 	tmp = test.get(0);
				// 	// System.out.println(tmp.getData());
				// 	test.remove(tmp);
				// }
				// Date end = new Date();

				// Date begin = new Date();
				// for (int i = 0; i < cnt; i++) {
				// 	tmp = test.get(i);
				// 	// System.out.println(tmp.getData());
				// }
				// Date end = new Date();			

				SeqIterator si = test.iterator();
				Date begin = new Date();
				while (si.hasNext()) {
					si.next();
				}
				Date end = new Date();
				res[--testTime] = ((double)end.getTime()-begin.getTime())/1000;
				ans += res[testTime];
			}
			System.out.println(Arrays.toString(res));
			System.out.println(ans);
		}

		// Test add(), get()
		// for (int i = 0; i < 10; i++) {
		// 	SequenceItem tmp = new SequenceItem();
		// 	tmp.setData(String.valueOf(i));
		// 	test.add(tmp);
		// 	System.out.println(test.get(i).getData());
		// }

		// Test iterator(), reverseIterator()
		// SeqIterator si = test.iterator();
		// while (si.hasNext()) {
		// 	System.out.println(si.next().getData());
		// 	si.remove();
		// }
		// System.out.println(test.isEmpty());
		// si = test.reverseIterator();
		// while (si.hasNext()) {
		// 	System.out.println(si.next().getData());
		// 	si.remove();
		// }
		// System.out.println(test.isEmpty());

		// Test biIterator()
		// BiSeqIterator bsi = test.biIterator();
		// while (bsi.hasNext()) {
		// 	System.out.println("test next:");
		// 	System.out.println(bsi.next().getData());
		// 	// bsi.remove();
		// }
		// System.out.println(test.isEmpty());
		// bsi.previous();
		// while (bsi.hasPrevious()) {
		// 	System.out.println("test previous:");
		// 	System.out.println(bsi.previous().getData());
		// }
		// System.out.println(test.isEmpty());

		// Test toString()
		// System.out.println(test);

		// Test isEmpty(), get(), remove(), contains(), size()
		// while (!test.isEmpty()) {
		// 	SequenceItem tmp = test.get(0);
		// 	System.out.println(tmp.getData());
		// 	test.remove(tmp);
		// 	System.out.println(test.size());
		// 	System.out.println(test.contains(tmp));
		// }
	}
}