今天看IO合并的时候，毕老师在用集合存储多个文件的时候，用了Enumeration这个接口。
我在百度上搜了一下他们说这个接口是1.0版本的，现在都被迭代器取代了，那这两个接口有什么不同么？？
集合那快听的比较懵，大牛们如果高兴顺带着把集合的体系结构说下，那就太感激不尽了~

API上是这样描述的
大概意思就是 迭代器是快速失败的，而Enumeration不是 快速失败的，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。
这是不是就是说在涉及到线程问题的时候，用Enumeration更稳定一些？？

看洒家来拯救你~~

源码注释是这样写的~~API上面的说明都是源码注释翻译过去的，很明显，英文好的可以免去API这个道具~



我自己实现了一个简易的ArrayList，里面包含了Iterator和Enumeration的用法，你可以自己调试一下

1. import java.util.Enumeration;
   
2. import java.util.Iterator;
   
3. import java.util.NoSuchElementException;
   
4. 
   
5. public class MyList<T> {
   
6. 
   
7.         private T[] theItems;
   
8.         
   
9.         private int size;//数组当前大小
   
10.         
    
11.         private static final int DEFULT_CAPACITY = 10;//数组默认初始化大小
    
12. 
    
13.         public MyList() {
    
14.                 theItems = (T[]) new Object[DEFULT_CAPACITY];
    
15.         }
    
16.         
    
17.         public boolean add(T item){
    
18.                         
    
19.                 //如果最初的数组装不下了，就重新申请内存
    
20.                 if(size >= DEFULT_CAPACITY){
    
21.                         T[] old = theItems;
    
22.                         theItems = (T[]) new Object[size * 2 + 1];
    
23.                         for (int i = 0; i < old.length; i++) {
    
24.                                 theItems[i] = old[i];
    
25.                         }
    
26.                 }
    
27. 
    
28.                 theItems[size] = item;
    
29.                 size++;
    
30.                
    
31.                 return true;
    
32.         }
    
33.         
    
34.         public T remove(int index){
    
35.                
    
36.                 if(index < 0|| index > size ){
    
37.                         throw new ArrayIndexOutOfBoundsException();
    
38.                 }
    
39.                
    
40.                 T retVal = theItems[index];
    
41.                
    
42.                 for(int i = index; i < size;i++){
    
43.                         theItems[i] = theItems[i+1];
    
44.                 }
    
45.                 theItems[size] = null;
    
46.                 size--;
    
47.                
    
48.                 return retVal;
    
49.         }
    
50.         
    
51.         public T get(int index){
    
52.                 if(index < 0|| index > size ){
    
53.                         throw new ArrayIndexOutOfBoundsException();
    
54.                 }
    
55.                 return theItems[index];
    
56.         }
    
57.         
    
58.         public int size(){
    
59.                 return this.size;
    
60.         }
    
61. 
    
62.         public Iterator<T> iterator() {
    
63.                 return new MyIterator();
    
64.         }
    
65. 
    
66.         private class MyIterator implements Iterator<T> {
    
67.                
    
68.                 private int current = 0;
    
69.                
    
70.                 @Override
    
71.                 public boolean hasNext() {
    
72.                         return current < size();
    
73.                 }
    
74. 
    
75.                 @Override
    
76.                 public T next() {
    
77.                         if(current >= size){
    
78.                                 throw new NoSuchElementException();
    
79.                         }
    
80.                         return theItems[current++];
    
81.                 }
    
82. 
    
83.                 @Override
    
84.                 public void remove() {
    
85.                         MyList.this.remove(current);
    
86.                 }
    
87.         }
    
88. 
    
89.         public Enumeration<T> enumeration() {
    
90.                 return new MyEnumeration();
    
91.         }
    
92.         
    
93.         private class MyEnumeration implements Enumeration<T>{
    
94.                
    
95.                 private int current = 0;
    
96.                
    
97.                 @Override
    
98.                 public boolean hasMoreElements() {
    
99.                         return current < size();
    
100.                 }
     
101. 
     
102.                 @Override
     
103.                 public T nextElement() {
     
104.                         if(current >= size){
     
105.                                 throw new NoSuchElementException();
     
106.                         }
     
107.                         return theItems[current++];
     
108.                 }
     
109.         }
     
110.         
     
111.         public static void main(String[] args) {
     
112.                
     
113.                 MyList<String> myList = new MyList<String>();
     
114.                
     
115.                 myList.add("a");
     
116.                 myList.add("b");
     
117.                 myList.add("c");
     
118.                
     
119.                 for (Iterator<String> iterator = myList.iterator(); iterator.hasNext();) {
     
120.                         System.out.println(iterator.next());
     
121.                 }
     
122.                
     
123.                 for(Enumeration<String> enumeration = myList.enumeration();enumeration.hasMoreElements();){
     
124.                         System.out.println(enumeration.nextElement());
     
125.                 }
     
126.                
     
127.                 for (Iterator<String> iterator = myList.iterator(); iterator.hasNext();) {
     
128.                         iterator.remove();
     
129.                 }
     
130.                                 
     
131.         }
     
132. 
     
133. }

复制代码

讲解一下，从我的代码可以看出来，两个接口的差别很小，只是iterator多了一个remove方法

楼上感觉好高端~~~~~~

java之所以淘汰了Enumeration是因为名称过长。采用Iterator替代了，简化了书写。Iterator比Enumerations多了一个移除方法。
上海传智学员路过。。。。。。