Java中的Enumeration、迭代器和ListIterator的区别

Enumeration是一个接口。它在java的集合框架中被用来一个一个地检索元素。Enumeration是一个传统的接口,只适用于传统的类,如:Vector, HashTable, Stack等。它提供了一个单一方向的迭代。通过使用枚举,只能进行读取操作,而不能进行删除操作。

Enumeration对象可以通过调用Vector类中的elements()方法来创建。

// Here "v" is a vector object. enum is of
// type Enumeration interface and refers to "v"\\nEnumeration enum = v.elements();

迭代器是一个通用的游标,可以应用于任何集合对象。它提供了一个单一方向的迭代。通过使用迭代器,可以执行读取和删除操作,但不能执行替换操作。当想要枚举所有集合框架中的元素时,就可以使用迭代器,如:Set、List、Queue、DeQue,以及Map接口的实现类。

迭代器对象可以通过调用集合接口中的iterator()方法来创建。

// Here "c" is any collection object. itr is of
// type Iterator interface and refers to "c"\\nIterator itr = c.iterator();

ListIterator是所有三个游标中最强大的游标。ListIterator只适用于像ArrayList、LinkedList、Stack等列表实现类。ListIterator可以在前向和后向方向上进行遍历。通过使用ListIteartor,可以执行读取、移除和替换操作。当我们想要枚举列表中的元素时,必须使用ListIterator。

ListIterator 对象可以通过调用 list 接口中的 listIterator() 方法来创建。

// Here "l" is any list object. ltr is of
// type ListIterator interface and refers to "l"\\nListIterator ltr = l.listIterator();

示例代码:

// A Java program to demonstrates the
// difference between Enumeration,
// Iterator, and ListIterator

import java.io.*;
import java.util.*;

class YiibaiDemo {

    public static void main(String args[])
    {

        // Creating a vector object
        Vector<Integer> v = new Vector<Integer>();

        // Adding elements to the vector object
        v.add(10);
        v.add(20);
        v.add(30);
        v.add(40);
        v.add(50);

        System.out.println("Enumeration: ");

        // Creating an Enumeration object
        Enumeration e = v.elements();

        // Checking the next element availability
        while (e.hasMoreElements()) {

            // Moving cursor to the next element
            int i = (Integer)e.nextElement();

            // Printing the element
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println();

        System.out.println("Iterator: ");

        // Creating Iterator object
        Iterator<Integer> itr = v.iterator();

        // Checking the next element availability
        while (itr.hasNext()) {

            // Moving cursor to the next element
            int i = (Integer)itr.next();

            // Checking if i == 10 then
            // remove the element
            if (i == 10)
                itr.remove();
        }
        System.out.println(v);
        System.out.println();

        System.out.println("ListIterator: ");

        // Creating ListIterator object
        ListIterator<Integer> ltr = v.listIterator();

        // Checking the next element availability
        while (ltr.hasNext()) {

            // Moving cursor to the next element
            int i = (Integer)ltr.next();

            // Performing add, remove, and
            // replace operation
            if (i == 20)
                ltr.remove();

            else if (i == 30)
                ltr.add(60);

            else if (i == 40)
                ltr.set(100);
        }

        System.out.println(v);
    }
}

运行结果:

Enumeration: 
10 20 30 40 50 

Iterator: 
[20, 30, 40, 50]

ListIterator: 
[30, 60, 100, 50]

显示枚举、迭代器和列表迭代器之间区别 –

属性 枚举 迭代器 ListIterator
可以在哪里应用? 枚举只能应用于传统的类。 迭代器可以应用于任何集合接口。 它可以应用于唯一的列表接口。
是一个遗留问题吗? 是(在1.0 V中引入)。 迭不是(在1.2 V中引入)。 不是(在1.2 V中引入)。
允许移动方向 单一方向,即只能在前进方向上遍历集合中的元素。 单向,即可以只在前进方向上遍历集合中存在的元素。 双向,即可以向前和向后两个方向遍历集合中的元素。
允许的操作 只能执行读操作。 可以执行读和删除操作。 可以执行读、删除、添加和替换操作。
怎样才能得到它? 通过调用向量类中的elements()方法。 通过调用任何集合接口中的iterator()方法。 通过调用列表接口中的listIterator()方法。