关于集合中迭代器的改写仿写小记

这篇文章对我来说比较的特殊，它意味着自己的知识体系开始建立，从此在csdn安家喽。

首先先要知道为什么需要使用Iterator,我也不想从别的地方copy非常苦涩难懂的描述，只按照自己现在的水平去理解的，最直接的描述出来

1：就像是小说的武林，总有一些人喜欢当个盟主来一统天下，而这个Iterator就是完成统一系列有相近功能的类，来完成他们的查询方法。这里所说的功能相近是什么呢，就是都要用到查找功能，或者删除功能等等一些统一，通用的功能。在集合中Iterator是实现了查找功能。 如果想完成上面的想法，就得给每一个类定义一个内部类实现Iterator的接口 有了这一层规范的做法，那么才是实现便利的第一步。

2：这样做以后，用户就不需要了解那些类的具体结构才能实现查询了。自身的结构肯定有差异的，所以这些差异在内部类实现的Iterator中进行统一，由此看来这个Iterator接口的就体现出了几个优点：1：万物有统一也有差异，接口可以实现其中的统一，2：对于经常性且通用的功能的使用，为什么不写在一个接口上，每次重复性代码劳动很有意思吗。3：只有实现Iterator 那么实现类之间及时相差非常的大，但至少Iterator那几个功能总相同的吧，那么我就可以名正言顺的将这几个内部类实例在用户那里赋给接口Iterator，有接口引用来统一操作

NodeList是作为一种数据结构为另外一个迭代程序服务

package com.Iterator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;

/**
 * 本程序主要实现的功能：
 * 1：主要功能的是迭代器的实现，这里懒得写接口直接拿Enumeration线程接口使用。
 * 2：顺便继承集合，重写了几个在Enumeration实现类中用到的方法，功能和原集合没什么区别
 * 3：此类主要是为了测试后面的一个迭代器而作为一种数据结构
 * @author 追本溯源
 *
 * @param <T>
 */
public  class NodeList<T> extends ArrayList<T>{
	private static final long serialVersionUID = 1L;
	private Object[] objs;
	private int cursor;
	private int defaultSize = 10;
	public NodeList(){
		objs = new Object[defaultSize];
	}
	
	/**
	 * 重写添加功能,和原功能倒是也没什么区别
	 */
	public boolean add(T t) {
		if(objs.length <= cursor+1){
			defaultSize += 10;
			objs = Arrays.copyOf(objs, defaultSize);
		}
		objs[cursor++] = t; 
		return true;
	}
	public int size(){
		return cursor;
	}
	
	public T remove(int index) {
		T removeData = null;
		if(objs.length > 0){
			//索引范围判断
			if(index < 0 || index > objs.length){
				System.out.println("索引越界！");
			}else{
				removeData = (T) objs[index];
				//覆盖数组
				for(int i = index; i < objs.length-1; i++){
					objs[i] = objs[i+1];
				}
				cursor--;
			}
		}	
		return removeData;
	}
	public String toString(){
		StringBuffer strbuf = new StringBuffer();
		strbuf.append("[");
		for(int i = 0; i < objs.length&&objs[i]!=null; i++){
			if(i==0){
				strbuf.append(objs[i]);
			}else{
				strbuf.append(","+objs[i]);
			}
			
		}
		strbuf.append("]");
		return strbuf.toString();
	}
	/**
	 * 该方法的功能主要是为用户提供一个迭代对象
	 * @return
	 */
	public NodeEnumeration<T> myiterator(){
		return new NodeEnumeration<T>(this,true);
	}

	/**
	 * 私有静态内部类实现迭代
	 * @author 追本溯源
	 *
	 */
	public static class NodeEnumeration<E> implements Enumeration<E>{
		private Integer index;
		private E curValue;
		private List<E> nodes = new ArrayList<E>();
		private boolean ifRemove;
		public NodeEnumeration(){
			
		}
		public NodeEnumeration(List<E> list,boolean ifRemove){
			this.index = 0;
			this.ifRemove = ifRemove;
			nodes = list;
		}
		/**
		 * ifRemove? "将查询到的数据从集合删除","不再集合中删除查询到的数据"
		 */
		public boolean hasMoreElements() {
			boolean falg = false;
			if(ifRemove){
				if(nodes.size()>0){
					curValue = nodes.remove(0);
					falg = true;
				}else{
					curValue = null;
				}
			}else{
				if(nodes.size() >= index+1){
					curValue = nodes.get(index);
					falg = true;
				}else{
					curValue = null;
				}
			}
			return falg;
		}

		public E nextElement() {
			if(curValue==null){
				System.out.println("数据结构中没有数据！返回null");
			}
			return curValue;
		}
	}
	public static void main(String[] args) {
		NodeList<String> neion = new NodeList<String>();
		System.out.println("=================测试add是否可行================");
		neion.add("张小凡");
		neion.add("陆雪琪");
		neion.add("杜碧书");
		System.out.println(neion.toString());
		System.out.println("=========测试remove是否可行====================");
		neion.remove(2);
		System.out.println(neion.toString());
		System.out.println("====================测试add是否会自动扩展长度=====================");
		for(int i = 0; i < 30; i++){
			neion.add("小萝莉");
		}
		System.out.println(neion.toString());
		System.out.println("====================本程序主题迭代用法========================");
		Enumeration<String> ite = neion.myiterator();
		while(ite.hasMoreElements()){
			String result = (String) ite.nextElement();
			System.out.print(result+",");
		}
		
	}
}

CoverIterator这个迭代器仿写了struts2 LoadClassUtil中那个迭代，总结吸收成为自己的。

package com.Iterator;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import com.Iterator.NodeList.NodeEnumeration;

/**
 * 该类的功能：
 * 1：迭代对象为NodeEnumeration 而其本身也是一个迭代器。
 * 2：过滤掉迭代器中所有重复的属性。
 * 3：只要该类对象不变则可以在内存记录查询后移除的数据。
 * 缺点：
 * 1：如果不是全部迭代，next()只调用一次的话，persisence会多出下一个没移除的值。
 * 2：下面递归那里如果n次重复，n+1次成功，在回溯的时候都会执行if中的add功能，会重复添加数据，如果用list储存的话是一个比较的大的问题
 * 采用set可以解决问题
 * @author 追本溯源
 *
 * @param <E>
 */

public class CoverIterator<E> {

	
	
	static class MyIterator<E> implements Iterator<E>{
		
		//存储当前NodeIterator
		private NodeEnumeration<E> current;
		private E value;
		//只要对象不变，保存之前一切插入的数据
		private List<E> persisence = new ArrayList<E>();
		//频繁增删采用LinkedList，临时存储
		private LinkedList<NodeEnumeration<E>> temporary = new LinkedList<NodeEnumeration<E>>();
		
		/** 提供一个供外部增添NodeIterator的方法*/
		public void saveDataStructure(NodeEnumeration<E> orginal){
			if(orginal!=null&&orginal.hasMoreElements()){
				if(current==null){
					current = orginal;
					value = orginal.nextElement();
					persisence.add(value);
				}else{
					temporary.add(orginal);
				}
			}
			
		}
		public boolean hasNext() {
			return current==null ? false : true;
		}

		public E next() {
			E previous = null;
			if(current!=null){
				previous = value;
				value = loadValue();
			}else{
				System.out.println("在迭代前养成用hasMoreElements判断的习惯！");
			}
			return previous;
		}
		
		public NodeEnumeration<E> determineCurrentNext(){
			if(current!=null&&!current.hasMoreElements()){
				if(temporary.size()>0){
					current = temporary.remove(0);
				}else{
					current = null;
				}
			}
			return current;
		}
		/** 去next的值预先存放到value中*/
		public E loadValue(){
			if(determineCurrentNext()!=null){
				value = current.nextElement();
				if(persisence.contains(value)){
					//递归得到value null 或者 具体值
					value = loadValue();
				}
				if(value!=null){
					//重复添加数据，看样子不能用list集合
					persisence.add(value);
					System.out.println("看看递归成功返回重复添加了几次");
				}
				return value;
			}
			return null;
		}
		public void printPersisence(){
			for(int i = 0; i < persisence.size(); i++){
				String name = (String) persisence.get(i);
				System.out.print(name+",");
			}
		}
		public void remove() {
			System.out.println("不支持该方法");
		}
	}
	public static void main(String[] args) {
		NodeList<String> nodelist = new NodeList<String>();
		nodelist.add("张小凡");
		nodelist.add("张小凡");
		nodelist.add("张小凡");
		nodelist.add("张小ya");
		NodeList<String> nodelist1 = new NodeList<String>();
		nodelist.add("张小凡1");
		nodelist.add("张小凡2");
		nodelist.add("张小凡3");
		nodelist.add("张小ya");
		MyIterator<String> my = new MyIterator<String>();
		my.saveDataStructure(nodelist.myiterator());
		my.saveDataStructure(nodelist1.myiterator());
		System.out.print("移除前的persisence数据：");
		my.printPersisence();
		if(my.hasNext()){
			System.out.println(my.next());
		}
		System.out.println("移除后的persisence数据：");
		my.printPersisence();
	}
}