用应用泛型、工厂设计模式实现双链表

 

package tlinklist;

//用泛型代替Object的双向链表实现
public interface LinkList<T> {
	void add(T t);
	
	void addIndex(int index, T t);
	
	boolean remove(int index);
	
	boolean modify(int index, T t);
	
	Object getNode(int index);
	
	void printLink();
	
	Object[] toArray();
	
	int getSize();
	
	void clear();
	
	int contains(T t);
}

package tlinklist;

public class LinkListImpl<T> implements LinkList<T> {
	private Node first;
	private Node last;
	private int size;
	
	//结点类，内部类
	private class Node{
		private Node prev;
		private T data;
		private Node next;
		
		public Node(Node prev, T data, Node next) {
			super();
			this.prev = prev;
			this.data = data;
			this.next = next;
		}
	}

	@Override
	public void add(T t) {
		Node node = this.last;
		Node newNode = new Node(node, t, null);
		this.last = newNode;
		if(this.first == null) {
			this.first = newNode;
		}else {
			node.next = newNode;
		}
		this.size++;
	}

	@Override
	public void addIndex(int index, T t) {
		Node node = this.first;
		if(index == 0) {//头插
			Node newNode = new Node(null, t, node);
			node.prev = newNode;
			this.first = newNode;
		}else if(index == size) {//尾插
			add(t);
		}else {//中间插
			for(int i = 0; i < index; i++) {
				node = node.next;
			}
			Node newNode = new Node(node.prev, t, node);
			node.prev.next = newNode;
			node.prev = newNode;
		}
	}
	
	@Override
	public boolean remove(int index) {
		if(!isExit(index)) {
			return false;
		}
		Node node = findNode(index);
		
		if(node.equals(this.first)) {//删除结点为头结点
			if(this.size == 1) {//只有一个结点
				node = null;
				this.first = this.last = null;
			}else {
				this.first = node.next;
				node.next = null;
				node.prev = null;
			}
		}else if(node.equals(last)){//删除结点为尾结点
			this.last = node.prev;
			node.prev.next = null;
			node.prev = null;
		}else {//删除中间结点
			node.prev.next = node.next;
			node.next.prev = node.prev;
			node.prev = node.next = null;
		}
		this.size--;
		return true;
	}

	@Override
	public boolean modify(int index, T t) {
		if(!isExit(index)) {
			return false;
		}
		Node node = findNode(index);
		node.data = t;
		return true;
	}
	
	private Node findNode(int index) {
		Node node = this.first;
		if(index < (this.size>>1)) {
			for(int i = 0; i < index; i++) {
				node = node.next;
			}
			return node;
		}else {
			node = this.last;
			for(int i = size-1; i > index; i--) {
				node = node.prev;
			}
			return node;
		}
	}
	
	private boolean isExit(int index) {
		return index >= 0 && index < this.size;
 	}

	@Override
	public Object getNode(int index) {
		if(!isExit(index)) {
			return null;
		}
		Node node = findNode(index);
		return node.data;
	}

	@Override
	public void printLink() {
		Node node = this.first;
		for(; node != null; node = node.next) {
			System.out.print(node.data+" ");
		}
                System.out.println();
	}

	@Override
	public Object[] toArray() {
		Object[] result = new Object[this.size];
		Node node = this.first;
		for(int i = 0; i < size; i++ ,node = node.next) {
			result[i] = node.data;
		}
		return result;
	}

	@Override
	public int getSize() {
		return this.size;
	}

	@Override
	public void clear() {
		Node node = this.first;
		while(node != null) {
			Node tmp = node.next;
			node.prev = node.next = null;
			node = tmp;
		}
		this.first = this.last = null;
		this.size = 0;
	}

	@Override
	public int contains(T t) {
		int index = 0;
		Node node = this.first;
		if(t == null) {
			for(; node != null; node = node.next) {
				if(node.data == t) {
					return index;
				}
				index++;
			}
			return -1;
		}
		node = this.first;
		for(; node != null; node = node.next) {
			if(node.data.equals(t)) {
				return index;
			}
			index++;
		}
		return -1;
	}

}

package tlinklist;

//工厂类
public class LinkFactory {
        private LinkFactory() {};
	
        public static <T> LinkList<T> getInstance() {
                return new LinkListImpl<T>();
        }
}

package tlinklist;

//测试代码
public class Test {

	public static void main(String[] args) {
//		LinkList<String> linkList = LinkFactory.getInstance();
//		linkList.add("1");
//		linkList.add("2");
//		linkList.add("3");
//		linkList.add("4");
//		linkList.printLink();
//		
//		linkList.modify(1, "3");
//		linkList.printLink();
//		System.out.println(linkList.getNode(2));
//		System.out.println(linkList.getSize());
//		System.out.println(linkList.contains("4"));
//		System.out.println(linkList.contains("2"));
//		System.out.println(linkList.getNode(3));
//		linkList.remove(3);
//		linkList.addIndex(2, "6");
//		linkList.printLink();
//		linkList.clear();
//		System.out.println(linkList.getSize());
		LinkList<Integer> linkList = LinkFactory.getInstance();
		linkList.add(1);
		linkList.add(2);
		linkList.add(3);
		linkList.add(4);
		linkList.printLink();
		
		linkList.modify(1, 1);
		linkList.printLink();
		System.out.println(linkList.getNode(2));
		System.out.println(linkList.getSize());
		System.out.println(linkList.contains(4));
		System.out.println(linkList.contains(2));
		System.out.println(linkList.getNode(3));
		linkList.remove(3);
		linkList.addIndex(2, 6);
		linkList.printLink();
		linkList.clear();
		System.out.println(linkList.getSize());
	}

}

 注释部分与非注释部分是一样的运行结果：