MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java集合框架中的迭代器使用

2023-01-263.8k 阅读

Java集合框架中的迭代器使用

迭代器的概念与重要性

在Java集合框架中，迭代器（Iterator）是一种设计模式，它提供了一种通用的方式来遍历集合中的元素，而无需了解集合的具体内部实现。这一机制极大地增强了代码的可维护性和可扩展性，因为无论集合是列表（List）、集合（Set）还是映射（Map），都可以使用相同的迭代器接口来遍历其元素。

迭代器的重要性体现在多个方面。首先，它分离了集合的遍历逻辑和集合的实现细节。这意味着集合的内部结构可以改变，而遍历代码无需修改。其次，迭代器支持并发访问控制，当集合在多线程环境下被访问时，迭代器可以提供安全的遍历方式。再者，迭代器使得代码更加简洁和通用，通过使用迭代器，开发人员可以使用统一的方式处理不同类型的集合。

Java中的迭代器接口

Java的java.util包中定义了Iterator接口，该接口提供了三个主要方法：hasNext()、next()和remove()。

hasNext()方法

hasNext()方法用于判断集合中是否还有下一个元素。它返回一个布尔值，如果集合中存在下一个元素，则返回true，否则返回false。这个方法是迭代器遍历的基础，通过不断调用hasNext()方法，我们可以确定是否应该继续获取下一个元素。

next()方法

next()方法用于返回集合中的下一个元素，并将迭代器的位置向前移动一位。如果在调用next()方法之前没有调用hasNext()方法，并且集合中没有下一个元素，将会抛出NoSuchElementException异常。因此，在调用next()方法之前，通常应该先调用hasNext()方法进行检查。

remove()方法

remove()方法用于从集合中移除当前迭代器返回的元素。该方法是可选操作，并非所有的迭代器实现都支持此方法。如果调用不支持remove()方法的迭代器的该方法，将会抛出UnsupportedOperationException异常。在调用remove()方法之前，必须先调用next()方法，否则也会抛出异常。

迭代器在不同集合类型中的使用

在List集合中的使用

List是一个有序的集合，允许包含重复元素。以ArrayList为例，以下是使用迭代器遍历ArrayList的代码示例：

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

public class ListIteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

在上述代码中，我们首先创建了一个ArrayList并添加了一些元素。然后通过调用list.iterator()方法获取迭代器。使用while循环结合hasNext()和next()方法遍历集合中的所有元素并打印出来。

如果要在遍历过程中移除元素，可以使用remove()方法，如下所示：

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

public class ListIteratorRemoveExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if ("banana".equals(element)) {
                iterator.remove();
            }
        }
        System.out.println(list);
    }
}

在这个示例中，当迭代器遍历到元素"banana"时，调用remove()方法将其从列表中移除。最后打印列表，会发现"banana"已经不存在。

在Set集合中的使用

Set是一个不包含重复元素的集合。以HashSet为例，使用迭代器遍历HashSet的方式与遍历ArrayList类似：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetIteratorExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

同样，先创建HashSet并添加元素，然后获取迭代器进行遍历。需要注意的是，Set集合本身不保证元素的顺序，所以遍历输出的顺序可能与添加顺序不同。

如果在Set遍历中需要移除元素，也可以使用remove()方法，如下：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetIteratorRemoveExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("cherry");

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if ("banana".equals(element)) {
                iterator.remove();
            }
        }
        System.out.println(set);
    }
}

在Map集合中的使用

Map是一种键值对（key - value）的集合。由于Map本身没有直接实现Iterable接口，所以不能直接获取迭代器。但是Map提供了几种视图（view），通过这些视图可以获取迭代器。

  • 通过keySet()获取键的迭代器： keySet()方法返回一个包含Map中所有键的Set集合，我们可以通过这个Set集合获取迭代器来遍历键。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapKeyIteratorExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);

        Set<String> keySet = map.keySet();
        Iterator<String> keyIterator = keySet.iterator();
        while (keyIterator.hasNext()) {
            String key = keyIterator.next();
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }
    }
}

在上述代码中，首先通过map.keySet()获取键的Set集合，然后获取迭代器遍历键，并通过map.get(key)获取对应的值。

  • 通过entrySet()获取键值对的迭代器： entrySet()方法返回一个包含Map中所有键值对的Set集合，每个元素都是Map.Entry类型。通过这个Set集合获取的迭代器可以同时访问键和值。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapEntryIteratorExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);

        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, Integer>> entryIterator = entrySet.iterator();
        while (entryIterator.hasNext()) {
            Map.Entry<String, Integer> entry = entryIterator.next();
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

在这个示例中，通过map.entrySet()获取键值对的Set集合，然后获取迭代器遍历每个Map.Entry对象，直接获取键和值。

迭代器的实现原理

从本质上讲，迭代器是基于集合的内部结构实现的。以ArrayList为例，ArrayList内部使用数组来存储元素。当调用iterator()方法时，ArrayList会创建一个实现了Iterator接口的内部类实例。

这个内部类维护了一个指向当前元素位置的游标（cursor）。hasNext()方法通过判断游标是否小于数组的有效元素个数来确定是否还有下一个元素。next()方法则返回游标指向的元素，并将游标向后移动一位。remove()方法会删除游标前一个位置的元素（因为游标在调用next()后已经移动），并对数组进行相应的调整。

对于HashSet，它内部基于哈希表实现。迭代器通过遍历哈希表的桶（bucket）来访问元素。当调用iterator()方法时，会创建一个迭代器对象，该对象维护了当前桶的索引和当前桶内元素的位置。hasNext()方法通过检查当前桶是否还有未遍历的元素以及是否还有后续的桶来判断是否有下一个元素。next()方法则返回当前位置的元素，并移动到下一个位置。

HashMap的迭代器实现与HashSet类似，只不过它需要同时处理键和值。通过entrySet()获取的迭代器遍历哈希表中的每个桶，每个桶中的元素是Map.Entry类型，从而可以同时获取键和值。

迭代器与增强for循环

在Java中，增强for循环（也称为foreach循环）为遍历集合提供了一种更简洁的语法。例如：

import java.util.ArrayList;
import java.util.List;

public class EnhancedForLoopExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        for (String element : list) {
            System.out.println(element);
        }
    }
}

增强for循环在编译时会被转换为使用迭代器的代码。以上面的代码为例，编译器会将其转换为类似如下的使用迭代器的代码：

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

public class EnhancedForLoopCompiledExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

虽然增强for循环语法简洁，但它也有一些局限性。例如，在增强for循环中无法直接调用remove()方法来移除元素。如果需要在遍历过程中移除元素，仍然需要使用显式的迭代器。

并发环境下的迭代器

在多线程环境下使用迭代器需要特别小心。如果一个线程在遍历集合时，另一个线程同时修改了集合的结构（例如添加或删除元素），可能会导致ConcurrentModificationException异常。

为了避免这种情况，Java提供了几种解决方案。一种是使用java.util.concurrent包中的并发集合类，如CopyOnWriteArrayList和ConcurrentHashMap。这些集合类在内部实现了线程安全的机制。

以CopyOnWriteArrayList为例，当一个线程遍历CopyOnWriteArrayList时，它实际上是在遍历一个快照，而其他线程对集合的修改会在一个新的数组上进行，所以不会影响遍历线程。以下是使用CopyOnWriteArrayList的示例：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("apple");
        list.add("banana");

        Thread thread1 = new Thread(() -> {
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String element = iterator.next();
                System.out.println("Thread 1: " + element);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            list.add("cherry");
            System.out.println("Thread 2: Added cherry");
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，thread1遍历CopyOnWriteArrayList，thread2向列表中添加元素。由于CopyOnWriteArrayList的特性，thread1不会抛出ConcurrentModificationException异常。

另一种解决方案是使用Collections.synchronizedList()等方法将普通集合转换为线程安全的集合，并在遍历集合时使用synchronized块来同步访问。

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

public class SynchronizedListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");

        List<String> synchronizedList = Collections.synchronizedList(list);

        Thread thread1 = new Thread(() -> {
            synchronized (synchronizedList) {
                Iterator<String> iterator = synchronizedList.iterator();
                while (iterator.hasNext()) {
                    String element = iterator.next();
                    System.out.println("Thread 1: " + element);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (synchronizedList) {
                synchronizedList.add("cherry");
                System.out.println("Thread 2: Added cherry");
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，通过Collections.synchronizedList()将普通ArrayList转换为线程安全的列表。在遍历和修改列表时，使用synchronized块同步访问，以避免ConcurrentModificationException异常。

自定义迭代器

在某些情况下，我们可能需要为自定义的集合类实现迭代器。要实现自定义迭代器，需要以下几个步骤：

  1. 定义一个实现Iterator接口的内部类。
  2. 在内部类中实现hasNext()、next()和remove()方法（如果需要）。
  3. 在自定义集合类中提供一个iterator()方法，返回内部类的实例。

以下是一个简单的自定义集合类和迭代器的示例：

import java.util.Iterator;

public class CustomCollection<T> {
    private T[] elements;
    private int size;

    public CustomCollection(int capacity) {
        elements = (T[]) new Object[capacity];
        size = 0;
    }

    public void add(T element) {
        if (size < elements.length) {
            elements[size++] = element;
        }
    }

    public Iterator<T> iterator() {
        return new CustomIterator();
    }

    private class CustomIterator implements Iterator<T> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new java.util.NoSuchElementException();
            }
            return elements[currentIndex++];
        }

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

可以通过以下方式使用这个自定义集合类和迭代器：

public class CustomCollectionUsage {
    public static void main(String[] args) {
        CustomCollection<String> customCollection = new CustomCollection<>(3);
        customCollection.add("apple");
        customCollection.add("banana");
        customCollection.add("cherry");

        for (String element : customCollection) {
            System.out.println(element);
        }
    }
}

在上述代码中，CustomCollection类实现了一个简单的动态数组结构，并提供了一个自定义的迭代器。CustomIterator内部类实现了Iterator接口的方法，使得CustomCollection可以像其他标准集合一样被遍历。

迭代器与流（Stream）

Java 8引入了流（Stream）的概念，流提供了一种更高效、更简洁的方式来处理集合中的元素。流操作可以分为中间操作和终端操作，并且支持并行处理。

虽然流和迭代器都用于处理集合元素，但它们有一些区别。迭代器是外部迭代，需要开发人员显式地控制遍历过程；而流是内部迭代，由流框架自动管理遍历。

例如，使用流来遍历和打印ArrayList中的元素：

import java.util.ArrayList;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        list.stream().forEach(System.out::println);
    }
}

在这个示例中，list.stream()将ArrayList转换为流，然后通过forEach终端操作对每个元素执行打印操作。

流还支持各种中间操作，如过滤、映射等。例如，过滤出长度大于5的字符串并打印：

import java.util.ArrayList;
import java.util.List;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("watermelon");

        list.stream()
           .filter(s -> s.length() > 5)
           .forEach(System.out::println);
    }
}

虽然流在很多情况下更简洁和高效，但迭代器仍然有其存在的价值。例如，在需要在遍历过程中移除元素或者需要更细粒度地控制遍历逻辑时，迭代器可能是更好的选择。

在实际开发中，需要根据具体的需求来选择使用迭代器还是流。如果需要进行简单的遍历和操作，流通常是一个不错的选择；如果需要更复杂的遍历控制或者需要在遍历过程中修改集合结构，迭代器可能更为合适。

总结迭代器的使用场景

  1. 通用遍历：当需要遍历不同类型的集合（如List、Set、Map）时，迭代器提供了统一的遍历方式，无论集合的具体实现如何，都可以使用相同的接口进行遍历。
  2. 遍历并移除元素：在遍历集合的同时需要移除元素时，迭代器的remove()方法提供了安全的移除机制。注意在使用增强for循环时无法直接调用remove()方法，此时迭代器就显得尤为重要。
  3. 多线程环境：在多线程环境下，虽然需要额外注意并发问题，但迭代器可以结合线程安全的集合类或者同步机制来实现安全的遍历。例如CopyOnWriteArrayList和ConcurrentHashMap结合迭代器可以在多线程环境下安全地遍历集合。
  4. 自定义集合遍历：当创建自定义的集合类时，通过实现迭代器接口，可以使自定义集合类像标准集合类一样被遍历，提供统一的遍历体验。
  5. 与其他框架集成：许多Java框架和库在处理集合时依赖迭代器。例如，一些数据库访问框架在从结果集中获取数据时可能会使用迭代器的方式，因此理解和掌握迭代器对于与这些框架的集成非常重要。

总之，迭代器是Java集合框架中一个非常重要的部分，深入理解其原理和使用方法对于编写高效、健壮的Java代码至关重要。无论是处理简单的集合遍历，还是在复杂的多线程和自定义集合场景下，迭代器都发挥着不可或缺的作用。通过合理地使用迭代器，开发人员可以编写出更具可读性、可维护性和可扩展性的代码。在实际开发中，应根据具体需求选择合适的遍历方式，充分发挥迭代器和其他集合处理工具的优势。同时，随着Java语言的不断发展，迭代器的相关特性和使用场景也可能会进一步演变和扩展，开发人员需要持续关注并学习新的知识，以更好地适应不断变化的开发需求。