持有对象（6）：Foreach与迭代器

Myth丶恋晨 2023-07-07 05:44 41阅读 0赞

### 一、Foreach与迭代器 ###

到目前为止，foreach语法主要用于数组，但是它也可以应用于任何Collection对象。你实际上已经看到过很多使用ArrayList时用到它的示例，下面是一个更通用的证明：

import java.util.Collection;
    import java.util.Collections;
    import java.util.LinkedList;
    
    public class ForeachCollections {
    	public static void main(String[] args) {
    		Collection<String> cs = new LinkedList<>();
    		Collections.addAll(cs, "A B C D E".split(" "));
    		for (String string : cs) {
    			System.out.println(string);
    		}
    	}
    }

由于cs是一个Collection，所以这段代码展示了能够与foreach一起工作是所有Collection对象的特性。

之所以能够工作，是因为java SE5引入了新的被称为Iterator的接口，该接口包含了一个能够产生Iterator的iterator()方法，并且Iterator接口被foreach用来在序列中移动。因此如果你创建了任何实现Iterator的类，都可以将它用于foreach语句中：

import java.util.Iterator;
    
    public class IterableClass implements Iterable<String> {
    
    	protected String[] str = { "A", "B", "C", "D", "E" };
    
    	public Iterator<String> iterator() {
    		return new Iterator<String>() {
    			private int index = 0;
    
    			@Override
    			public boolean hasNext() {
    				return index < str.length;
    			}
    
    			@Override
    			public String next() {
    				return str[index++];
    			}
    
    			public void remove() {
    				throw new UnsupportedOperationException();
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		for (String string : new IterableClass()) {
    			System.out.println(string);
    		}
    	}
    }

iterator()方法返回的是实现了Iterator<String>的匿名内部类的实例，该匿名内部类可以遍历数组中的所有单词。在main()中，你可以看到IterableClass确实可以用于foreach语句中。

在java SE5中，大量的类都是Iterable类型，主要包括所有的Collection类（但是不包括各种Map）。例如，下面的代码可以显示所有的操作系统环境变量：

import java.util.Map;
    
    public class EnvironmentVariables {
    	public static void main(String[] args) {
    		for (Map.Entry entry : System.getenv().entrySet()) {
    			System.out.println(entry.getKey() + " : " + entry.getValue());
    		}
    	}
    }

System.getenv返回一个Map，entrySet()产生一个由Map.Entry的元素构成的Set，并且这个Set是一个Iterable，因此它可以用于foreach循环。

foreach语句可以用于数组或其他任何Iterable，但是这并不意味着数组肯定也是一个Iterable，而任何自动包装也不会自动触发：

import java.util.Arrays;
    
    public class ArrayIsNotIterable {
    	static <T> void test(Iterable<T> ib) {
    		for (T t : ib) {
    			System.out.print(t + " ");
    		}
    	}
    
    	public static void main(String[] args) {
    		test(Arrays.asList(1, 2, 3));
    		String[] strings = { "A", "B", "C" };
    		// test(strings);
    		test(Arrays.asList(strings));
    	}
    }

尝试把数组当作一个Iterable参数传递会导致失败。这说明不存在任何从数组到Iterable的自动转换，你必须手工执行这种转换。

### 二、适配器方法惯用法 ###

如果现在有一个Iterable类，你想添加一种或多种在foreach语句中使用这个类的方法，应该怎么做呢？例如，假设你希望可以选择以向前的方向或是向后的方向迭代一个单词列表。如果直接继承这个类，并覆盖iterator()方法，你只能替换现有的方法，而不能实现选择。

一种解决方案是所谓适配器方法的惯用法。“适配器”部分来自于设计模式，因为你必须提供特定接口以满足foreach语句。当你有一个接口并需要另一个接口时，编写适配器就可以解决问题。这里，希望在默认的向前迭代器的基础上，添加产生反向迭代器的能力，因此我们不能使用覆盖，而是添加了一个能够产生Iterable对象的方法，该对象可以用于foreach语句。正如你所见，这使得我们可以提供多种使用foreach的方式：

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.Iterator;
    
    class ReversibleArrayList<T> extends ArrayList<T> {
    	public ReversibleArrayList(Collection<T> c) {
    		super(c);
    	}
    
    	public Iterable<T> reversed() {
    		return new Iterable<T>() {
    			public Iterator<T> iterator() {
    				return new Iterator<T>() {
    					int current = size() - 1;
    
    					@Override
    					public boolean hasNext() {
    						return current > -1;
    					}
    
    					@Override
    					public T next() {
    						return get(current--);
    					}
    
    					public void remove() {
    						throw new UnsupportedOperationException();
    					}
    				};
    			}
    		};
    	}
    }
    
    public class AdapterMethodIdiom {
    	public static void main(String[] args) {
    		ReversibleArrayList<String> ral = new ReversibleArrayList<>(Arrays.asList("A B C D E".split(" ")));
    		for (String s : ral)
    			System.out.print(s + " ");
    		System.out.println();
    		for (String s : ral.reversed())
    			System.out.print(s + " ");
    	}
    }

如果直接将ral对象置于foreach语句中，将得到（默认的）向前迭代器。但是如果在该对象上调用reversed()方法，就会产生不同的行为。

通过使用这种方式，我可以在IterableClass.java示例中添加两种适配器方法：

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Random;
    
    public class MultiIterableClass extends IterableClass {
    	public Iterable<String> reversed() {
    		return new Iterable<String>() {
    			@Override
    			public Iterator<String> iterator() {
    				return new Iterator<String>() {
    					int current = str.length - 1;
    
    					@Override
    					public boolean hasNext() {
    						return current > -1;
    					}
    
    					@Override
    					public String next() {
    						return str[current--];
    					}
    
    					public void remove() {
    						throw new UnsupportedOperationException();
    					}
    				};
    			}
    		};
    	}
    
    	public Iterable<String> randomized() {
    		return new Iterable<String>() {
    			@Override
    			public Iterator<String> iterator() {
    				List<String> shuffled = new ArrayList<>(Arrays.asList(str));
    				Collections.shuffle(shuffled, new Random(47));
    				return shuffled.iterator();
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		MultiIterableClass mic = new MultiIterableClass();
    		for (String s : mic.reversed())
    			System.out.print(s + " ");
    		System.out.println();
    		for (String s : mic.randomized())
    			System.out.print(s + " ");
    		System.out.println();
    		for (String s : mic)
    			System.out.print(s + " ");
    	}
    }

注意，第二个方法random()没有创建它自己的Iterator，而是直接返回被打乱的List中的Iterator。

从输出中可以看到，Collection.shuffle()方法没有影响到原来的数组，而只是打乱了shuffled中的引用。之所以这样，只是因为randomized()方法用一个ArrayList将Arrays.asList()方法的结果包装了起来。如果这个由Arrays.asList()方法产生的List被直接打乱，那么它就会修改底层的数组，就像下面这样：

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    public class ModifyingArraysAsList {
    	public static void main(String[] args) {
    		Random r = new Random(47);
    		Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    		List<Integer> list1 = new ArrayList<>(Arrays.asList(ia));
    		System.out.println("Before shuffling: " + list1);
    		Collections.shuffle(list1, r);
    		System.out.println("after shuffling: " + list1);
    		System.out.println("array: " + Arrays.toString(ia));
    
    		List<Integer> list2 = Arrays.asList(ia);
    		System.out.println("Before shuffling: " + list2);
    		Collections.shuffle(list2, r);
    		System.out.println("after shuffling: " + list2);
    		System.out.println("array: " + Arrays.toString(ia));
    	}
    }

第一种情况中，Arrays.asList()的输出被传递给了ArrayList()的构造器，这将创建一个引用ia的元素的ArrayList，因此打乱这些引用不会修改该数组。但是，如果直接使用Arrays.asList(ia)的结果，这种打乱就会修改ia的顺序。意识到Arrays.asList()产生的List对象会使用底层数组作为其物理实现是很重要的。只要你执行的操作会修改这个List，并且你不想原来的数组被修改，那么你就应该在另一个容器中创建一个副本。

### 三、总结 ###

java提供了大量持有对象的方式：

1.  数组将数字与对象联系起来。它保存类型明确的对象，查询对象时，不需要对结果做类型转换。它可以是多维的，可以保存基本类型的数据。但是，数组一旦生成，其容量就不能改变。
2.  Collection保存单一的元素，而Map保存相关联的键值对。有了java的泛型，你就可以指定容器中存放的对象类型，因此你就不会将错误类型的对象放置到容器中，并且在从容器中获取元素时，不必进行类型转换。各种Collection和各种Map都可以在你向其中添加更多的元素时，自动调整其尺寸。容器不能持有基本类型，但是自动包装机制会仔细地执行基本类型到容器中所持有的包装器类型之间的双向转换。
3.  像数组一样，List也建立数字索引与对象的关联，因此数组和List都是排好序的容器。List能够自动扩充容量。
4.  如果要进行大量的随机访问，就是用ArrayList；如果经常从表中间插入或删除元素，则应该使用LinkedList。
5.  各种Queue以及栈的行为，由LinkedList提供支持。
6.  Map是一种将对象（而非数字）与对象相关联的设计。HashMap设计用来快速访问；而TreeMap保持“键”始终处于排序状态，所以没有HashMap快。LinkedHashMap保持元素插入的顺序，但是也通过散列提供了快速访问能力。
7.  Set不接受重复元素。HashSet提供最快速的查询速度，而TreeSet保持元素处于排序状态。LinkedHashSet以插入的顺序保存元素。
8.  新程序中不应该使用过时的Vector、Hashtable和Stack。

最后附上整个java容器的结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

**如果本文对您有很大的帮助，还请点赞关注一下。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200221132458174.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx,size_16,color_FFFFFF,t_70