链表（清空链表）

清空链表：public void clean()

有些时候需要进行链表数据的整体清处理，这个时候就可以直接根据数据根元素来进行控制，只要root设置为了null，后续的节点都将不存在。

1. 在Link接口中追加清空处理方法
2. 在子类LinkImpl中覆写该方法

class  JavaDemo
{
	public static void main(String[] args) 
	{
		ILink<String> all = new LinkImpl<String>(); 
		all.add("Heool");
		all.add("World");
		Object[] result = all.toArray();
		for(Object x : result){
			System.out.println(x);
		}
		System.out.println("------------------数据获取的分割线-------------------");
		System.out.println(all.get(0));
		System.out.println("------------------数据修改Hellow->hellow的分割线-------------------");
		all.set(0,"hellow");
		System.out.println(all.get(0));
		System.out.println("------------------判断数据hell是否存在的分割线-------------------");
		System.out.println(all.contains("hell"));
		System.out.println("------------------删除hellow分割线-------------------");
		all.remove("hellow");
		System.out.println("hellow是否存在:"+all.contains("hellow"));
		System.out.println("------------------数据清空的方法-------------------");
		all.clean();
		//尝试输出
		System.out.println(all.get(1));
	
	}
}

interface ILink<E>	//设置泛型避免安全隐患
{
	public void add(E e);
	public int size();	//获取数组的个数
	public boolean isEmpty();	//判断是否为空集合 
	public Object[] toArray();	//变成数据形式的方法
	public E get(int index);	//按照索引提取数据的方法 
	public void set(int index,E data);	//根据索引修改制定数据
	public boolean contains(E data);	//判断数据是否存在
	public void remove(E data);	//删除节点的方法
	public void clean();	//清空链表的方法
}

class LinkImpl<E> implements ILink<E>
{
	private class Node	//保存节点的数据关系
	{
		private E data;	//保存的数据
		private Node next;	//下一个节点
		public Node(E data){	//有数据的情况下才有意义
			this.data = data;
		}
		//第一次调用：LinkImpl.root.addNode(),this = LinkImpl.root
		//第二次调用：LinkImpl.root.next.addNode(),this = LinkImpl.root.next
		public void addNode(Node newNode){	//保存新的Node数据
			if(this.next == null){	//root的下一个节点为空
				this.next = newNode;
			}else{	//如果已经有节点了
				this.next.addNode(newNode);	//利用递归继续往后查询直到遇到空节点
			}
		}
		
		//第一次调用：this = LinkImpl.root
		//第二次调用：this = LinkImpl.root.next
		public void toArrayNode(){
			LinkImpl.this.returnData[LinkImpl.this.foot++] = this.data;
			if (this.next != null)	//还有下一个数据
			{
				this.next.toArrayNode();
			}
		}
		
		//根据索引查找数据
		public E getNode(int index){
			if(LinkImpl.this.foot == index){	//索引相同
				return this.data;	//返回当前数据
			}else{
				return this.next.getNode(index);	//递归调用
			}
		}

		//根据索引修改数据
		public void setNode(int index,E data){
			if(LinkImpl.this.foot == index){	//索引相同
				 this.data = data;	//修改数据
			}else{
				 this.next.setNode(index,data);	//递归调用
			}
		}

		//判断数据是否存在
		public boolean containsNode(E data){
			if(this.data.equals(data)){	//数据与当前对象数据是否相等
				return true;
			}else{
				if(this.next == null){	//找不到
					return false;
				}
			}
			return this.next.containsNode(data);	//递归调用
		}

		//跟节点以外的节点删除操作
		public void removeNode(Node previous,E data){
			if(this.data.equals(data)){
				previous.next = this.next;	//上一个节点的下一个节点变成要删除节点的下一个
			}else{
				if (this.next != null)	//有后续节点
				{
					this.next.removeNode(this,data);	//向后继续寻找data数据相等的节点
				}
			}
		}
	}
	//----------以下为LinkImpl类中定义的成员-----------
	private Node root;	//保存根元素
	private int count;	//保存数据的个数
	private int foot = 0;	//操作数组的脚标
	private Object[] returnData;	//返回的数组
	//----------以下为LinkImpl类中定义的方法-----------
	public void add(E e){
		if(e == null){	//保存的数据为null
			return;	//方法调用直接结束
		}
		//数据本身是不具备关联性的，只有Node类有，那么想实现关联处理就必须将数据封装在Node类中
		Node newNode = new Node(e);	//创建一个新的节点
		if(this.root == null){	//现在没有根节点			
			this.root = newNode;//第一个节点作为根节点
		}else{	//根节点存在
			this.root.addNode(newNode);	//把创建的新节点交给Node类自行判断放在合适的位置
		}
		this.count++;//每传入一个对象都会增加
	}

	//获取长度的方法
	public int size(){
		return this.count;
	}

	public boolean isEmpty(){
		return this.count == 0;//数组长度是否为0
	}

	//获取数组的方法
	public Object[] toArray(){
		if(this.isEmpty()){	//空集合
			return null;//没有数据
		}
		this.foot = 0;	//脚标清零
		this.returnData = new Object[this.count];//根据已有的长度开辟数组
		this.root.toArrayNode();//利用Node类进行递归数据获取
		return this.returnData;
	}

	//获取指定索引位置内容的方法
	public E get(int index){
		if(index >= this.count){	//索引应该在指定范围之内
			return null;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		return this.root.getNode(index);
	}
	
	//根据索引修改数据
	public void set(int index,E data){
		if(index >= this.count){	//索引应该在指定范围之内
			return;	//方法结束
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		this.root.setNode(index,data);	
	}
	
	//判断数据是否存在
	public boolean contains(E data){
		if(data == null){
			return false;
		}
		return this.root.containsNode(data);
	}

	//删除节点的方法
	public void remove(E data){
		if(this.contains(data)){	//判断数据是否存在
			if(this.root.data.equals(data)){	根节点处理
				this.root = this.root.next;		//根引用根的下一个节点
			}else{	//非根节点处理
				this.root.next.removeNode(this.root,data);
			}
			this.count--;	//数组长度减1
		}	
	}

	//清空链表的方法
	public void clean(){
		this.root =null;	//后续的节点都没了
		this.count = 0;		//数组长度清零
	}
}  

结果：

Heool
World
------------------数据获取的分割线-------------------
Heool
------------------数据修改Hellow->hellow的分割线-------------------
hellow
------------------判断数据hell是否存在的分割线-------------------
false
------------------删除hellow分割线-------------------
hellow是否存在:false
------------------数据清空的方法-------------------
null