Java手写通用型链表，同时可以使用迭代器，foreach

标题：Java手写通用型链表，同时可以使用迭代器，foreach

一、首先可以看看使用Java实现一个链表的思想
手写链表

二、实现一个通用型的链表【使用泛型】
原理：将之前节点的int info–>T info,即使得链表更加通用【使用了泛型类】

注意：为什么不建议直接将int info–>Object info,
原因：使用，Object info可以实现通用型链表，但链表里的类型可以不固定，使得结构混乱
eg：

LinkedList list=new LinkedList();
list.add(1);
list.add("aaa");
list.add(new Person());//此处Person类是为了举例

三、使用迭代器，使用foreach进行遍历
手写，解析Java中的迭代器

• 使用foreach进行遍历，只能通过 java.lang.Iterable 的数组或实例进行迭代，也就是说，我们写的FNodeList链表需要实现java.lang.Iterable接口。

• 具体实现【只显示FNodeList中有关的代码】

class FNodeList<T> implements Iterable<T> {//使用foreach，就需要实现此接口
	private FNode<T> head;
	private FNode<T> tail;

	/**
	使用内部类，是因为我们迭代的时，需要先p=head,而head的指向随时可能根据【增删操作】进行更改，故p=head赋值语句写在哪里很关键，于是使用了内部类，使得进入iterator()后，new Itr(),进入内部类，而在内部类里面使用外部类FNodeList中的head，为p进行赋值。进而得到的p为最新的。
	*/
	private  class Itr  implements Iterator<T> {
		private FNode<T> p;
		public Itr() {
			p=head;
		}
		@Override
		public boolean hasNext() {
			return p!=null;
		}

		@Override
		public T next() {
			FNode<T> s=p;
			p=p.next;
			return s.info;
		}
	}

	@Override
	public Iterator<T> Itr iterator() {
		return new Itr();
	}
}

• 解析：
  使用内部类，是因为我们迭代的时，需要先p=head,而head的指向随时可能根据【增删操作】进行更改，故p=head赋值语句写在哪里很关键，于是使用了内部类，使得进入iterator()后，new Itr(),进入内部类，而在内部类里面使用外部类FNodeList中的head，为p进行赋值。进而得到的p为最新的。

Iterator<Integer>  it = myList.iterator();
		while(it.hasNext()) {
			Integer in = it.next();
			System.out.print(in+" ");
		}

完整代码如下：

package c_Utils.cn.my.com.node2;

import java.util.Iterator;

/**
 * 测试手写链表  【9.19】  【Object类型】缺点，一个NodeList中什么类型都可以同时加入，
 * 							 solution：使用泛型
 * 【使用了泛型】
 * 【使用了迭代器，可以使用foreach进行遍历】
 * @author dell
 *
 */
class FNode<T>{
	public T info;
	public FNode<T> next;
	public FNode(T info) {
		this(info,null);
	}
	public FNode(T info,FNode<T> next) {
		this.info=info;
		this.next=next;
	}
}

class FNodeList<T> implements Iterable<T>{//使用foreach，就需要实现此接口
	private FNode<T> head;
	private FNode<T> tail;
	
	/**
	 * 添加节点->头部
	 * @param info
	 */
	public void addToHead(T info) {
		head=new FNode<T>(info,head);
		if(tail==null) {
			tail=head;
		}
	}
	
	/**
	 * 添加节点-->尾部
	 */
	public void addToTail(T info) {
		if(null==tail) {
			head=new FNode<T>(info);
			tail=head;
		}else {
			tail.next=new FNode<T>(info);
			tail=tail.next;
		}
	}
		
	/**
	 * 从头部删除--》节点
	 */
	public FNode<T> deleteFromHead() {
		FNode<T> p=head;
		if(head!=null) {
			head=head.next;
			if(head==null) {
				tail=null;
			}
		}
		return p;
	}
	
	/**
	 * 从尾部删除-》节点
	 */
	public FNode<T> deleteFromTail() {
		FNode<T> p=tail;
		if(tail!=null) {
			if(head==tail) {
				head=null;
				tail=null;
			}else {
				FNode<T> s=head;
				while(s.next!=tail) {
					s=s.next;
				}
				tail=s;
				tail.next=null;
			}
		}
	    return p;
	}
	
	/**
	 * 按索引查找节点
	 */
	public FNode<T> getByIndex(int index) {
		FNode<T> p=head;
		for(int i=1;i<index && p!=null;i++,p=p.next) {
		}
		return p;
	}
	
	/**
	 * 输出所有节点
	 */
	public void printAllInfo() {
		FNode<T> p=head;
		while(p!=null) {
			System.out.print(p.info+"  ");
			p=p.next;
		}
		System.out.println();
	}

	private class Itr implements Iterator<T>{  
		private FNode<T> p;
		public Itr() {
			p=head;//类型不匹配，不能从FNode<T> --> FNode<T>,若为Itr<T>
		}
		@Override
		public boolean hasNext() {
			return p!=null;
		}

		@Override
		public T next() {
			FNode<T> s=p;
			p=p.next;
			return s.info;
		}
	}

	@Override    //Iterable
	public Iterator<T> iterator() {
		return new Itr();
	}
}

public class TestFNodeList {
	public static void main(String[] args) {
		//测试int类型
//		FNodeList<Integer> myList = new FNodeList<>();		
//		System.out.println("测试添加元素--》头部");
//		myList.addToHead(1);
//		myList.addToHead(2);
//		myList.addToHead(3);
//		myList.addToHead(4);
//		myList.printAllInfo();
//		
//		System.out.println("测试添加元素到--》尾部");
//		myList.addToTail(9);
//		myList.addToTail(10);
//		myList.addToTail(11);
//		myList.addToTail(12);
//		myList.printAllInfo();
//	
//		System.out.println("测试从头部删除--》元素");
//		FNode<Integer> p = myList.deleteFromHead();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		p = myList.deleteFromHead();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		myList.printAllInfo();
//		
//		System.out.println("测试从尾部删除-->元素");
//		p=myList.deleteFromTail();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		p=myList.deleteFromTail();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		myList.printAllInfo();
//		
//		System.out.println("测试获取指定索引的--》值");
//		p = myList.getByIndex(2);
//		if(p!=null) {
//			System.out.println(p.info);
//		}
		
		//测试double型
//		FNodeList<Double> myList = new FNodeList<>();
//		System.out.println("测试添加元素--》头部");
//		myList.addToHead(1.2);
//		myList.addToHead(2.2);
//		myList.addToHead(3.2);
//		myList.addToHead(4.2);
//		myList.printAllInfo();
//		
//		System.out.println("测试添加元素到--》尾部");
//		myList.addToTail(9.2);
//		myList.addToTail(10.2);
//		myList.addToTail(11.2);
//		myList.addToTail(12.2);
//		myList.printAllInfo();
//	
//		System.out.println("测试从头部删除--》元素");
//		FNode<Double> p = myList.deleteFromHead();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		p = myList.deleteFromHead();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		myList.printAllInfo();
//		
//		System.out.println("测试从尾部删除-->元素");
//		p=myList.deleteFromTail();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		p=myList.deleteFromTail();
//		if(p!=null) {
//			System.out.println(p.info);
//		}
//		myList.printAllInfo();
//		
//		System.out.println("测试获取指定索引的--》值");
//		p = myList.getByIndex(2);
//		if(p!=null) {
//			System.out.println(p.info);
//		}
		
		FNodeList<Integer> myList = new FNodeList<Integer>();
		myList.addToHead(1);
		myList.addToHead(2);
		myList.addToHead(3);
		myList.addToHead(4);
	
		System.out.println("使用for-each遍历");
		for(Object in:myList) {//只能通过 java.lang.Iterable 的数组或实例进行迭代
			System.out.print(in+" ");
		}
		System.out.println();
		
		System.out.println("使用迭代器遍历");
		Iterator<Integer>  it = myList.iterator();
		while(it.hasNext()) {
			Integer in = it.next();
			System.out.print(in+" ");
		}
		System.out.println();
	}
}