java实现单向链

       链表是线性表链接存储的实现。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个受限制的指针。

所以，我们可以编写这样的类来实现链表中的结点。 

public class Node <T>{
	
	private T data; //数据
	
	private Node<T> next; //下一个节点的引用
	
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}
	public Node<T> getNext() {
		return next;
	}
	public void setNext(Node<T> next) {
		this.next = next;
	}
	
}

单向链表源代码：

/**
 * 单向链表
 * 
 * @author Administrator
 *
 */
public class LinkList<T> {

	
	
	private Node<T> frist; // 定义链表的头指针
	
	
	/**
	 * 空的构造函数
	 */
	public LinkList() {
		frist = new Node<T>();

	}

	/**
	 * 头插法 建立链表
	 * 
	 * @param data
	 *            数据
	 * @param n
	 *            个数
	 */
	/*public LinkList(T[] data, int n) {

		frist = new Node<T>(); // 头结点
		Node<T> s = null;

		for (T t : data) {
			s = new Node<T>();
			s.setData(t);
			s.setNext(frist.getNext());
			frist.setNext(s);

		}
	}*/
	
	/**
	 * 尾插 建立法链表
	 * 
	 * @param data 数据
	 * @param n	个数
	 */	
	  public LinkList(T[] data,int n){
		  
		  frist = new Node<T>(); // 头结点
		  Node<T> end = frist;
		  Node<T> s = null;
		  for (T t : data) {
			s = new Node<T>();
			s.setData(t);
			end.setNext(s);
			end = s;
		}
	 }
	 
	/**
	 * 插入元素
	 * 
	 * @param e
	 *            要插入的元素
	 * @param index
	 *            位置
	 * @return
	 */
	public boolean insert(T e, int index) {
		int count = 0;
		Node<T> s = frist;
		Node<T> s2 = null;
		if (index < 1)
			throw new ArrayIndexOutOfBoundsException();
		while (s != null && count < index - 1) {
			s = s.getNext();
			count++;
		}

		if (s == null)
			throw new ArrayIndexOutOfBoundsException();
		else {
			s2 = new Node<T>();
			s2.setData(e);
			s2.setNext(s.getNext());
			s.setNext(s2);
		}
		return true;
	}
	
	

	/**
	 * 按位置删除元素
	 * 
	 * @param index
	 *            元素位置
	 * @return
	 */
	public Boolean remove(int index) {

		int count = 0;
		Node<T> s = frist;
		Node<T> s2 = null;
		if (index < 1)
			throw new ArrayIndexOutOfBoundsException();
		while (s != null && count < index - 1) {
			s = s.getNext();
			count++;
		}
		if (s == null)
			throw new ArrayIndexOutOfBoundsException();
		else {
			s2 = s.getNext();
			s.setNext(s2.getNext());
		}
		return true;
	}
	

	/**
	 * 按位置替换元素
	 * 
	 * @param index
	 *            元素位置
	 * @param e
	 *            新元素
	 * @return
	 */
	public boolean replace(int index, T e) {

		int count = 0;
		Node<T> s = frist;

		if (index < 1)
			throw new ArrayIndexOutOfBoundsException();
		while (s != null && count < index) {
			s = s.getNext();
			count++;
		}
		if (s == null)
			throw new ArrayIndexOutOfBoundsException();
		else
			s.setData(e);

		return true;
	}

	/**
	 * 按位置查找元素
	 * 
	 * @param index
	 *            位置
	 * @return
	 */
	public T get(int index) {

		int count = 0;
		Node<T> s = frist;

		if (index < 1)
			throw new ArrayIndexOutOfBoundsException();
		while (s != null && count < index) {
			s = s.getNext();
			count++;
		}
		if (s == null)
			throw new ArrayIndexOutOfBoundsException();
		else
			return s.getData();

	}

	/**
	 * 按值查找，返回元素位置
	 * 
	 * @param e
	 *            查找的元素
	 * @return
	 */
	public ArrayList<Integer> locate(T e) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		int index = 0;
		Node<T> s = frist;

		while (s != null) {
			index++;
			s = s.getNext();
			if (s.getData().equals(e))
				list.add(index);

		}

		return list;
	}
	
	
	/**
	 * 判断链表是否为空，为空返回true
	 * @return
	 */
	public boolean isEmpty(){
		
		if(frist.getNext() == null)
			return true;
		
		return false;
	}

	/**
	 * 获取单向链表的长度
	 * 
	 * @return
	 */
	public int size() {

		int count = 0;
		Node<T> s = frist;
		while (s.getNext() != null) {
			s = s.getNext();
			count++;
		}
		return count;
	}

	@Override
	public String toString() {

		String str = "[";
		Node<T> s = frist;
		while (s != null) {
			s = s.getNext();
			if (s != null) {
				if (s.getNext() != null)
					str = str + s.getData() + ",";
				else
					str = str + s.getData();
			}
		}
		str = str + "]";
		return str;
	}

	

}