深入研究容器Collections实用方法

    java中有大量用于容器的卓越的使用方法，它们被表示为java.util.Collections类内部的静态方法。你已经看到过其中的一部分，例如addAll()、reverseOrder()和binarySearch()。下面是另外一部分（synchronized和unmodifiable的使用方法将在后续的小节中介绍）。在这张表中，在相关的情况中使用了泛型：

    注意，min()和max()只能作用于Collection对象，而不能作用于List，所以你无需担心Collection是否应该被排序（如前所述，只有在执行binarySearch()之前，才确定需要对List或数组进行排序）。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Random;
import java.util.Vector;

public class Utilities {
	static List<String> list = Arrays.asList("one Two three Four five six one".split(" "));

	public static void main(String[] args) {
		System.out.println(list);
		System.out.println("list disjoint (Four)? : " + Collections.disjoint(list, Collections.singletonList("Four")));
		System.out.println("max: " + Collections.max(list));
		System.out.println("min: " + Collections.min(list));
		System.out.println("max w/ comparator: " + Collections.max(list, String.CASE_INSENSITIVE_ORDER));
		System.out.println("min w/ comparator: " + Collections.min(list, String.CASE_INSENSITIVE_ORDER));
		List<String> sublist = Arrays.asList("Four five six".split(" "));
		System.out.println("indexOfSubList: " + Collections.indexOfSubList(list, sublist));
		System.out.println("lastIndexOfSubList: " + Collections.lastIndexOfSubList(list, sublist));
		Collections.replaceAll(list, "one", "Yo");
		System.out.println("replaceAll: " + list);
		Collections.reverse(list);
		System.out.println("reverse: " + list);
		Collections.rotate(list, 3);
		System.out.println("rotate: " + list);
		List<String> source = Arrays.asList("in the matrix".split(" "));
		Collections.copy(list, source);
		System.out.println("copy: " + list);
		Collections.swap(list, 0, list.size() - 1);
		System.out.println("swap: " + list);
		Collections.shuffle(list, new Random(47));
		System.out.println("shuffled: " + list);
		Collections.fill(list, "pop");
		System.out.println("fill: " + list);
		System.out.println("frequency of 'pop': " + Collections.frequency(list, "pop"));
		List<String> dups = Collections.nCopies(3, "snap");
		System.out.println("dups: " + dups);
		System.out.println("'list' disjoint 'dups'? " + Collections.disjoint(list, dups));
		Enumeration<String> e = Collections.enumeration(dups);
		Vector<String> v = new Vector<String>();
		while (e.hasMoreElements())
			v.addElement(e.nextElement());
		ArrayList<String> arrayList = Collections.list(v.elements());
		System.out.println("arrayList: " + arrayList);
	}
}

    该程序的输出可看作是对每个实用方法的行为的解释。请注意由于大小写的缘故而造成的使用String.CASE_INSENSITIVE_ORDER Comparator时min()和max()的差异。

一、List的排序和查询

    List排序与查询所使用的方法与对象数组所使用的相应方法有相同的名字与语法，只是用Collections的static方法代替Arrays的方法而已。下面是一个例子，用到了Utilities.java中的list数据：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;

public class ListSortSearch {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>(Utilities.list);
		list.addAll(Utilities.list);
		System.out.println(list);
		Collections.shuffle(list, new Random(47));
		System.out.println("shuffle: " + list);
		ListIterator<String> it = list.listIterator(10);
		while (it.hasNext()) {
			it.next();
			it.remove();
		}
		System.out.println("Trimmed: " + list);
		Collections.sort(list);
		System.out.println("sorted: " + list);
		String key = list.get(7);
		int index = Collections.binarySearch(list, key);
		System.out.println("Location of " + key + " is " + index + ", list.get(" + index + ") = " + list.get(index));
		Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
		System.out.println("Case-insensitive sorted: " + list);
		key = list.get(7);
		Collections.binarySearch(list, key, String.CASE_INSENSITIVE_ORDER);
		System.out.println("Location of " + key + " is " + index + ", list.get(" + index + ") = " + list.get(index));
	}
}

    与使用数组进行查找和排序一样，如果使用Comparator进行排序，那么binarySearch()必须使用相同的Comparator。

    此程序还演示了Collections的Shuffle()方法，它用来打乱List的顺序。ListIterator是在被打乱的列表中的某个特定位置创建的，并用来移除从该位置到列表尾部的所有元素。

二、设定Collection或Map不可修改

    创建一个只读的Collection或Map，有时可以带来某些方便。Collections类可以帮助达成此目的，它有一个方法，参数为原本的容器，返回值是容器的只读版本。此方法有大量变种，对应于Collection（如果你不能把Collection视为更具体的类型）、List、Set和Map。下例将说明如何正确生成各种只读容器：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import com.buba.util.Countries;

public class ReadOnly {
	static Collection<String> data = new ArrayList<>(Countries.names(6));

	public static void main(String[] args) {
		Collection<String> c = Collections.unmodifiableCollection(new ArrayList<String>(data));
		System.out.println(c);
//		c.add("one"); java.lang.UnsupportedOperationException

		List<String> a = Collections.unmodifiableList(new ArrayList<String>(data));
		ListIterator<String> lit = a.listIterator();
		System.out.println(lit.next());
//		lit.add("one");

		Set<String> s = Collections.unmodifiableSet(new HashSet<String>(data));
		System.out.println(s);
//		s.add("one");

		Set<String> ss = Collections.unmodifiableSortedSet(new TreeSet<String>(data));

		Map<String, String> m = Collections.unmodifiableMap(new HashMap<String, String>(Countries.capitals(6)));
		System.out.println(m);
//		m.put("Ralph", "Howdy!");

		Map<String, String> tm = Collections.unmodifiableSortedMap(new TreeMap<String, String>(Countries.capitals(6)));
	}
}

    对特定类型的“不可修改的”方法的调用并不会产生编译时的检查，但是转换完成后，任何会改变容器内容的操作都会引起UnsupportedOperationException异常。

    无论哪一种情况，在将容器设为只读之前，必须填入有意义的数据。装载数据后，就应该使用“不可修改的”方法返回的引用去替换掉原本的引用。这样，就不用担心无意中修改了只读的内容。另一方面，此方法允许你保留一份可修改的容器，作为类的private成员，然后通过某个方法调用返回对该容器的“只读”的引用。这样一来，就只有你可以修改容器的内容，而别人只能读取。

三、Collection或Map的同步控制

    关键字synchronized是多线程议题中的重要部分，在并发中将讨论这种较为复杂的主题。这里，我只是提醒注意，Collections类有办法能够自动同步整个容器。其语法与“不可修改的”方法相似：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class Synchronization {
	public static void main(String[] args) {
		Collection<String> c = Collections.synchronizedCollection(new ArrayList<String>());
		List<String> list = Collections.synchronizedList(new ArrayList<String>());
		Set<String> s = Collections.synchronizedSet(new HashSet<String>());
		Set<String> ss = Collections.synchronizedSortedSet(new TreeSet<String>());
		Map<String, String> m = Collections.synchronizedMap(new HashMap<String, String>());
		Map<String, String> sm = Collections.synchronizedSortedMap(new TreeMap<String, String>());
	}
}

    最好是如上所示，直接将新生成地容器传递给适当的“同步”方法；这样做就不会有任何机会暴露出不同步的版本。

四、快速报错

    java容器有一种保护机制，能够防止多个进程同时修改同一个容器的内容。如果你在迭代遍历某个容器的过程中，另一个进程介入其中，并且插入、删除或修改此容器内的某个对象，那么就会出现问题：也许迭代过程已经处理过容器中该元素了，也许还没处理，也许在调用size()之后容器的尺寸收缩了——还有许多灾难情景。java容器类类库采用快速报错（fail-fast）机制。它会探查容器上的任何除了你的进程所进行的操作以外的所有变化，一旦它发现其他进程修改了容器，就会立刻抛出ConcurrentModificationException异常。这就是“快速报错”的意思——即，不是使用复杂的算法在事后来检查问题。

    很容易就可以看出“快速报错”机制的工作原理：只需创建一个迭代器，然后向迭代器所指向的Collection添加点什么，就像这样：

import java.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;

public class FailFast {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		Iterator<String> it = c.iterator();
		c.add("An object");
		try {
			String s = it.next();
		} catch (ConcurrentModificationException e) {
			System.out.println(e);
		}
	}
}

    程序运行时发生了异常，因为在容器取得迭代器之后，又有东西被放入到了该容器中。当程序的不同部分修改同一个容器时，就可能导致容器的状态不一致，所以，此异常提醒你，应该修改代码。在此例中，应该在添加完所有的元素之后，再获取迭代器。

    ConcurrentHashMap、CopyOnWriteArrayList和CopyOnWriteArraySet都使用了可以避免ConcurrentModificationException的技术。

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