自己實現一個泛型LinkedList,保證最基本的 add(), remove(), get() , set(), 增強for循環等。
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class MyLinkedList<T> implements Iterable<T> {
private int size;
private int modCount = 0;
private Node<T> beginMarker;
private Node<T> endMarker;
public MyLinkedList() {
clear();
}
public void clear() {
doClear();
}
private void doClear() {
beginMarker = new Node<T>(null, null, null);
endMarker = new Node<T>(null, beginMarker, null);
beginMarker.next = endMarker;
size = 0;
modCount++;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public boolean add(T t) {
addBefore(endMarker, t);
return true;
}
public void add(int index, T t) {
addBefore(getNode(index, 0, size), t);
}
public T get(int index) {
return getNode(index).data;
}
public T set(int index, T t) {
Node<T> p = getNode(index);
T old = p.data;
p.data = t;
return old;
}
public T remove(int index) {
return remove(getNode(index));
}
private T remove(Node<T> p) {
p.prev.next = p.next;
p.next.prev = p.prev;
size--;
modCount++;
return p.data;
}
private void addBefore(Node<T> p, T t) {
p.prev = p.prev.next = new Node<T>(t, p.prev, p);
size++;
modCount++;
}
private Node<T> getNode(int index) {
return getNode(index, 0, size - 1);
}
private Node<T> getNode(int index, int lower, int upper) {
if (index < lower || index > upper)
throw new IndexOutOfBoundsException();
Node<T> p;
if (index < size / 2) {
p = beginMarker.next;
for (int i = 0; i < index; i++)
p = p.next;
} else {
p = endMarker;
for (int i = size; i > index; i--)
p = p.prev;
}
return p;
}
@Override
public String toString() {
StringJoiner joiner = new StringJoiner(", ", "[", "]");
Node<T> p = beginMarker.next;
while (p != endMarker) {
joiner.add(p.data.toString());
p = p.next;
}
return joiner.toString();
}
@SuppressWarnings("all")
private static class Node<T> {
public T data;
public Node<T> prev;
public Node<T> next;
public Node(T data, Node<T> prev, Node<T> next) {
this.data = data;
this.prev = prev;
this.next = next;
}
}
@Override
public Iterator<T> iterator() {
return new LinkedListIterator();
}
private class LinkedListIterator implements Iterator<T> {
private Node<T> current = beginMarker.next;
private int expectedModCount = modCount;
private boolean okToRemove = false;
@Override
public boolean hasNext() {
return current != endMarker;
}
@Override
public T next() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
if (!hasNext())
throw new NoSuchElementException();
T data = current.data;
current = current.next;
okToRemove = true;
return data;
}
public void remove() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
if (!okToRemove)
throw new IllegalStateException();
MyLinkedList.this.remove(current.prev);
expectedModCount++;
okToRemove = false;
}
}
}