Java中的Enumeration、Iterable和Iterator接口详解

前言

在看各种Java书籍或者博文的时候，老是会遇到Enumeration、Iterable和Iterator这三个接口，若是对这几个接口不是很明白的话，总会让本身看着看着就迷惑了，正好这周末，抽空把这三个接口总结一下，一扫以前的各类迷惑。

Enumeration

Enumeration(枚举)接口的做用和Iterator相似，但只提供了遍历Vector和HashTable类型集合元素的功能，不支持元素的移除操做。

Enumeration接口声明的方法以下：

方法	描述
boolean hasMoreElements()	还有更多要提取的元素时返回true，在枚举全部元素后返回false
E nextElement()	返回集合中的下一个元素

因为Enumeration接口已由Iterator取代，全部我这里就不作更详细的总结。这里提供一个简单的使用Demo：

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public class EnumerationDemo {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("Lisa");
        v.addElement("Billy");
        v.addElement("Mr Brown");

        Enumeration e = v.elements();

        while (e.hasMoreElements()) {
            String value = (String)e.nextElement();
            System.out.println(value);
        }

        Hashtable h = new Hashtable();
        h.put("name", "Yanggd");
        h.put("age", "25");
        h.put("location", "内蒙古呼和浩特");

        e = h.keys();

        while (e.hasMoreElements()) {
            String key = (String) e.nextElement();
            String value = (String) h.get(key);
            System.out.println("KEY =>" + key + "; VALUE=>" + value);
        }
    }
}

Iterable和Iterator

迭代器是一种模式、可使得序列类型的数据结构的遍历行为与被遍历的对象分离，即咱们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就能够遍历这个对象的内部。

• Iterable：实现这个接口的集合对象支持迭代，是能够迭代的；实现了这个能够配合foreach使用；
• Iterator：迭代器，提供迭代机制的对象，具体如何迭代是这个Iterator接口规范的。

Iterable接口有如下三个方法：

方法	描述
Iterator iterator()	返回一个Iterator对象
void forEach(Consumer<? super T> action)	对集合中的每一个元素执行action动做
Spliterator spliterator()	返回一个Spliterator对象

Iterator接口有如下三个方法：

方法	描述
boolean hasNext()	每次next以前，先调用此方法探测是否迭代到终点
E next()	返回当前迭代元素，同时，迭代游标后移
void remove()	删除最近一次已近迭代出出去的那个元素；只有当next执行完后，才能调用remove函数

Java容器中，全部的Collection子类会实现Iteratable接口以实现foreach功能，Iteratable接口的实现又依赖于实现了Iterator的内部类(参照LinkedList中listIterator()和descendingIterator()的JDK源码)。有的容器类会有多个实现Iterator接口的内部类，经过返回不一样的迭代器实现不一样的迭代方式。

下面经过一个简单的例子来讲明Iterable和Iterator，看懂了下面的代码，也就看明白了Iterable和Iterator。

import java.util.*;

public class IterableDemo implements Iterable<String> {
    private String[] words = "I love coding".split("");

    // 默认迭代器
    public Iterator<String> iterator() {
        // 匿名内部类
        return new Iterator<String>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < words.length;
            }

            @Override
            public String next() {
                return words[index++];
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    // 反向迭代器
    public Iterable<String> reverseIterator() {
        return new Iterable<String>() {
            @Override
            public Iterator<String> iterator() {
                return new Iterator<String>() {
                    private int index = words.length - 1;

                    @Override
                    public boolean hasNext() {
                        return index > -1;
                    }

                    @Override
                    public String next() {
                        return words[index--];
                    }

                    @Override
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                };
            }
        };
    }

    public static void main(String[] args) {
        IterableDemo iterableDemo = new IterableDemo();

        // 默认迭代器
        for (String value : iterableDemo) {
            System.out.print(value);
        }

        System.out.println();

        // 反向迭代器
        for (String value : iterableDemo.reverseIterator()) {
            System.out.print(value);
        }
    }
}

总结

又是一个小的知识点，再恶补一下。重温一下这些细节，让本身之后少掉点坑。

2019年7月21日 于内蒙古呼和浩特。