强大的集合工具类：java.util.Collections 中未包含的集合工具
尚未完成: Queues, Tables 工具类任何对 JDK 集合框架有经验的程序员都熟悉和喜欢 java.util.Collections 包含的工具方法。Guava 沿着这些路线提供了更多的工具方法：适用于所有集合的静态方法。这是 Guava 最流行和成熟的部分之一。
我们用相对直观的方式把工具类与特定集合接口的对应关系归纳如下：
| 集合接口 | 属于JDK还是Guava | 对应的Guava工具类 |
| Collection | JDK | Collections2：不要和 java.util.Collections 混淆 |
| List | JDK | Lists |
| Set | JDK | Sets |
| SortedSet | JDK | Sets |
| Map | JDK | Maps |
| SortedMap | JDK | Maps |
| Queue | JDK | Queues |
| Multiset | Guava | Multisets |
| Multimap | Guava | Multimaps |
| BiMap | Guava | Maps |
| Table | Guava | Tables |
在找类似转化、过滤的方法？请看第四章，函数式风格。
静态工厂方法
在 JDK 7之前，构造新的范型集合时要讨厌地重复声明范型：
List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();
我想我们都认为这很讨厌。因此 Guava 提供了能够推断范型的静态工厂方法：
List<TypeThatsTooLongForItsOwnGood> list = Lists.newArrayList();
Map<KeyType, LongishValueType> map = Maps.newLinkedHashMap();
可以肯定的是，JDK7 版本的钻石操作符(<>)没有这样的麻烦：
List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<>();
但 Guava 的静态工厂方法远不止这么简单。用工厂方法模式，我们可以方便地在初始化时就指定起始元素。
Set<Type> copySet = Sets.newHashSet(elements);
List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");
此外，通过为工厂方法命名（Effective Java 第一条），我们可以提高集合初始化大小的可读性：
List<Type> exactly100 = Lists.newArrayListWithCapacity(100);
List<Type> approx100 = Lists.newArrayListWithExpectedSize(100);
Set<Type> approx100Set = Sets.newHashSetWithExpectedSize(100);
确切的静态工厂方法和相应的工具类一起罗列在下面的章节。
注意：Guava 引入的新集合类型没有暴露原始构造器，也没有在工具类中提供初始化方法。而是直接在集合类中提供了静态工厂方法，例如：
Multiset<String> multiset = HashMultiset.create();
Iterables
在可能的情况下，Guava 提供的工具方法更偏向于接受 Iterable 而不是 Collection 类型。在 Google，对于不存放在主存的集合——比如从数据库或其他数据中心收集的结果集，因为实际上还没有攫取全部数据，这类结果集都不能支持类似 size()的操作 ——通常都不会用 Collection 类型来表示。
因此，很多你期望的支持所有集合的操作都在 Iterables 类中。大多数 Iterables 方法有一个在 Iterators 类中的对应版本，用来处理 Iterator。
截至 Guava 1.2 版本，Iterables 使用 FluentIterable 类进行了补充，它包装了一个 Iterable 实例，并对许多操作提供了”fluent”（链式调用）语法。
下面列出了一些最常用的工具方法，但更多 Iterables 的函数式方法将在第四章讨论。
常规方法
| concat(Iterable<Iterable>) | 串联多个 iterables 的懒视图* | concat(Iterable...) |
| frequency(Iterable, Object) | 返回对象在 iterable 中出现的次数 | 与 Collections.frequency (Collection, Object)比较；Multiset |
| partition(Iterable, int) | 把 iterable 按指定大小分割，得到的子集都不能进行修改操作 | Lists.partition(List, int)；paddedPartition(Iterable, int) |
| getFirst(Iterable, T default) | 返回 iterable 的第一个元素，若 iterable 为空则返回默认值 | 与Iterable.iterator(). next()比较;FluentIterable.first() |
| getLast(Iterable) | 返回 iterable 的最后一个元素，若 iterable 为空则抛出NoSuchElementException |
getLast(Iterable, T default)； FluentIterable.last() |
| elementsEqual(Iterable, Iterable) | 如果两个 iterable 中的所有元素相等且顺序一致，返回 true | 与 List.equals(Object)比较 |
| unmodifiableIterable(Iterable) | 返回 iterable 的不可变视图 | 与 Collections. unmodifiableCollection(Collection)比较 |
| limit(Iterable, int) | 限制 iterable 的元素个数限制给定值 | FluentIterable.limit(int) |
| getOnlyElement(Iterable) | 获取 iterable 中唯一的元素，如果 iterable 为空或有多个元素，则快速失败 | getOnlyElement(Iterable, T default) |
译者注：懒视图意味着如果还没访问到某个 iterable 中的元素，则不会对它进行串联操作。
Iterable<Integer> concatenated = Iterables.concat(
Ints.asList(1, 2, 3),
Ints.asList(4, 5, 6)); // concatenated包括元素 1, 2, 3, 4, 5, 6
String lastAdded = Iterables.getLast(myLinkedHashSet);
String theElement = Iterables.getOnlyElement(thisSetIsDefinitelyASingleton);
//如果set不是单元素集，就会出错了！
与 Collection 方法相似的工具方法
通常来说，Collection 的实现天然支持操作其他 Collection，但却不能操作 Iterable。
下面的方法中，如果传入的 Iterable 是一个 Collection 实例，则实际操作将会委托给相应的 Collection 接口方法。例如，往 Iterables.size 方法传入是一个 Collection 实例，它不会真的遍历 iterator 获取大小，而是直接调用 Collection.size。
| 方法 | 类似的 Collection 方法 | 等价的 FluentIterable 方法 |
| addAll(Collection addTo, Iterable toAdd) | Collection.addAll(Collection) | |
| contains(Iterable, Object) | Collection.contains(Object) | FluentIterable.contains(Object) |
| removeAll(Iterable removeFrom, Collection toRemove) | Collection.removeAll(Collection) | |
| retainAll(Iterable removeFrom, Collection toRetain) | Collection.retainAll(Collection) | |
| size(Iterable) | Collection.size() | FluentIterable.size() |
| toArray(Iterable, Class) | Collection.toArray(T[]) | FluentIterable.toArray(Class) |
| isEmpty(Iterable) | Collection.isEmpty() | FluentIterable.isEmpty() |
| get(Iterable, int) | List.get(int) | FluentIterable.get(int) |
| toString(Iterable) | Collection.toString() | FluentIterable.toString() |
FluentIterable
除了上面和第四章提到的方法，FluentIterable 还有一些便利方法用来把自己拷贝到不可变集合
| ImmutableList | |
| ImmutableSet | toImmutableSet() |
| ImmutableSortedSet | toImmutableSortedSet(Comparator) |
Lists
除了静态工厂方法和函数式编程方法，Lists 为 List 类型的对象提供了若干工具方法。
| 方法 | 描述 |
| partition(List, int) | 把 List 按指定大小分割 |
| reverse(List) | 返回给定 List 的反转视图。注: 如果 List 是不可变的，考虑改用 ImmutableList.reverse()。 |
List countUp = Ints.asList(1, 2, 3, 4, 5);
List countDown = Lists.reverse(theList); // {5, 4, 3, 2, 1}
List<List> parts = Lists.partition(countUp, 2);//{{1,2}, {3,4}, {5}}
静态工厂方法
Lists 提供如下静态工厂方法：
| 具体实现类型 | 工厂方法 |
| ArrayList | basic, with elements, from Iterable, with exact capacity, with expected size, from Iterator |
| LinkedList | basic, from Iterable |
Sets
Sets 工具类包含了若干好用的方法。
集合理论方法
我们提供了很多标准的集合运算（Set-Theoretic）方法，这些方法接受 Set 参数并返回 SetView，可用于：
- 直接当作 Set 使用，因为 SetView 也实现了 Set 接口；
- 用 copyInto(Set) 拷贝进另一个可变集合；
- 用 [immutableCopy()](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Sets.SetView.html#immutableCopy())对自己做不可变拷贝。
| 方法 |
| union(Set, Set) |
| intersection(Set, Set) |
| difference(Set, Set) |
| symmetricDifference(Set, Set) |
使用范例：
Set<String> wordsWithPrimeLength = ImmutableSet.of("one", "two", "three", "six", "seven", "eight");
Set<String> primes = ImmutableSet.of("two", "three", "five", "seven");
SetView<String> intersection = Sets.intersection(primes,wordsWithPrimeLength);
// intersection包含"two", "three", "seven"
return intersection.immutableCopy();//可以使用交集，但不可变拷贝的读取效率更高
其他 Set 工具方法
| 方法 | 描述 | 另请参见 |
| cartesianProduct(List<Set>) | 返回所有集合的笛卡儿积 | cartesianProduct(Set...) |
| powerSet(Set) | 返回给定集合的所有子集 |
Set<String> animals = ImmutableSet.of("gerbil", "hamster");
Set<String> fruits = ImmutableSet.of("apple", "orange", "banana");
Set<List<String>> product = Sets.cartesianProduct(animals, fruits);
// {{"gerbil", "apple"}, {"gerbil", "orange"}, {"gerbil", "banana"},
// {"hamster", "apple"}, {"hamster", "orange"}, {"hamster", "banana"}}
Set<Set<String>> animalSets = Sets.powerSet(animals);
// {{}, {"gerbil"}, {"hamster"}, {"gerbil", "hamster"}}
静态工厂方法
Sets 提供如下静态工厂方法：
| 具体实现类型 | 工厂方法 |
| HashSet | basic, with elements, from Iterable, with expected size, from Iterator |
| LinkedHashSet | basic, from Iterable, with expected size |
| TreeSet | basic, with Comparator, from Iterable |
Maps
Maps 类有若干值得单独说明的、很酷的方法。
uniqueIndex
Maps.uniqueIndex(Iterable,Function) 通常针对的场景是：有一组对象，它们在某个属性上分别有独一无二的值，而我们希望能够按照这个属性值查找对象——译者注：这个方法返回一个 Map，键为 Function 返回的属性值，值为 Iterable 中相应的元素，因此我们可以反复用这个 Map 进行查找操作。
比方说，我们有一堆字符串，这些字符串的长度都是独一无二的，而我们希望能够按照特定长度查找字符串：
ImmutableMap<Integer, String> stringsByIndex = Maps.uniqueIndex(strings,
new Function<String, Integer> () {
public Integer apply(String string) {
return string.length();
}
});
如果索引值不是独一无二的，请参见下面的 Multimaps.index 方法。
difference
Maps.difference(Map, Map) 用来比较两个 Map 以获取所有不同点。该方法返回 MapDifference 对象，把不同点的维恩图分解为：
| entriesInCommon() | 两个 Map 中都有的映射项，包括匹配的键与值 |
| entriesDiffering() | 键相同但是值不同值映射项。返回的 Map 的值类型为 MapDifference.ValueDifference，以表示左右两个不同的值 |
| entriesOnlyOnLeft() | 键只存在于左边 Map 的映射项 |
| entriesOnlyOnRight() | 键只存在于右边 Map 的映射项 |
Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
MapDifference<String, Integer> diff = Maps.difference(left, right);
diff.entriesInCommon(); // {"b" => 2}
diff.entriesInCommon(); // {"b" => 2}
diff.entriesOnlyOnLeft(); // {"a" => 1}
diff.entriesOnlyOnRight(); // {"d" => 5}
处理 BiMap 的工具方法
Guava 中处理 BiMap 的工具方法在 Maps 类中，因为 BiMap 也是一种 Map 实现。
| BiMap工具方法 | 相应的 Map 工具方法 |
| synchronizedBiMap(BiMap) | Collections.synchronizedMap(Map) |
| unmodifiableBiMap(BiMap) | Collections.unmodifiableMap(Map) |
静态工厂方法
Maps 提供如下静态工厂方法：
| 具体实现类型 | 工厂方法 |
| HashMap | basic, from Map, with expected size |
| LinkedHashMap | basic, from Map |
| TreeMap | basic, from Comparator, from SortedMap |
| EnumMap | from Class, from Map |
| ConcurrentMap：支持所有操作 | basic |
| IdentityHashMap | basic |
Multisets
标准的 Collection 操作会忽略 Multiset 重复元素的个数，而只关心元素是否存在于 Multiset 中，如 containsAll 方法。为此，Multisets 提供了若干方法，以顾及 Multiset 元素的重复性：
| 方法 | 说明 | 和 Collection 方法的区别 |
| containsOccurrences(Multiset sup, Multiset sub) | 对任意 o，如果 sub.count(o)<=super.count(o)，返回 true | Collection.containsAll忽略个数，而只关心 sub 的元素是否都在 super 中 |
| removeOccurrences(Multiset removeFrom, Multiset toRemove) | 对 toRemove 中的重复元素，仅在 removeFrom 中删除相同个数。 | Collection.removeAll 移除所有出现在 toRemove 的元素 |
| retainOccurrences(Multiset removeFrom, Multiset toRetain) | 修改 removeFrom，以保证任意 o 都符合removeFrom.count(o)<=toRetain.count(o) | Collection.retainAll 保留所有出现在 toRetain 的元素 |
| intersection(Multiset, Multiset) | 返回两个 multiset 的交集; | 没有类似方法 |
Multiset<String> multiset1 = HashMultiset.create();
multiset1.add("a", 2);
Multiset<String> multiset2 = HashMultiset.create();
multiset2.add("a", 5);
multiset1.containsAll(multiset2); //返回true；因为包含了所有不重复元素，
//虽然multiset1实际上包含2个"a"，而multiset2包含5个"a"
Multisets.containsOccurrences(multiset1, multiset2); // returns false
multiset2.removeOccurrences(multiset1); // multiset2 现在包含3个"a"
multiset2.removeAll(multiset1);//multiset2移除所有"a"，虽然multiset1只有2个"a"
multiset2.isEmpty(); // returns true
Multisets 中的其他工具方法还包括：
| copyHighestCountFirst(Multiset) | 返回 Multiset 的不可变拷贝，并将元素按重复出现的次数做降序排列 |
| unmodifiableMultiset(Multiset) | 返回 Multiset 的只读视图 |
| unmodifiableSortedMultiset(SortedMultiset) | 返回 SortedMultiset 的只读视图 |
Multiset<String> multiset = HashMultiset.create();
multiset.add("a", 3);
multiset.add("b", 5);
multiset.add("c", 1);
ImmutableMultiset highestCountFirst = Multisets.copyHighestCountFirst(multiset);
//highestCountFirst，包括它的entrySet和elementSet，按{"b", "a", "c"}排列元素
Multimaps
Multimaps 提供了若干值得单独说明的通用工具方法
index
作为 Maps.uniqueIndex 的兄弟方法，[Multimaps.index(Iterable, Function)](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Multimaps.html#index(java.lang.Iterable, com.google.common.base.Function))通常针对的场景是：有一组对象，它们有共同的特定属性，我们希望按照这个属性的值查询对象，但属性值不一定是独一无二的。
比方说，我们想把字符串按长度分组。
ImmutableSet digits = ImmutableSet.of("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine");
Function<String, Integer> lengthFunction = new Function<String, Integer>() {
public Integer apply(String string) {
return string.length();
}
};
ImmutableListMultimap<Integer, String> digitsByLength= Multimaps.index(digits, lengthFunction);
/*
* digitsByLength maps:
* 3 => {"one", "two", "six"}
* 4 => {"zero", "four", "five", "nine"}
* 5 => {"three", "seven", "eight"}
*/
invertFrom
鉴于 Multimap 可以把多个键映射到同一个值（译者注：实际上这是任何 map 都有的特性），也可以把一个键映射到多个值，反转 Multimap 也会很有用。Guava 提供了 invertFrom(Multimap toInvert,
Multimap dest) 做这个操作，并且你可以自由选择反转后的 Multimap 实现。
注：如果你使用的是 ImmutableMultimap，考虑改用 [ImmutableMultimap.inverse()](http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/ImmutableMultimap.html#inverse())做反转。
ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.putAll("b", Ints.asList(2, 4, 6));
multimap.putAll("a", Ints.asList(4, 2, 1));
multimap.putAll("c", Ints.asList(2, 5, 3));
TreeMultimap<Integer, String> inverse = Multimaps.invertFrom(multimap, TreeMultimap<String, Integer>.create());
//注意我们选择的实现，因为选了TreeMultimap，得到的反转结果是有序的
/*
* inverse maps:
* 1 => {"a"}
* 2 => {"a", "b", "c"}
* 3 => {"c"}
* 4 => {"a", "b"}
* 5 => {"c"}
* 6 => {"b"}
*/
forMap
想在 Map 对象上使用 Multimap 的方法吗？forMap(Map)把 Map 包装成 SetMultimap。这个方法特别有用，例如，与 Multimaps.invertFrom 结合使用，可以把多对一的 Map 反转为一对多的 Multimap。
Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 1, "c", 2);
SetMultimap<String, Integer> multimap = Multimaps.forMap(map);
// multimap：["a" => {1}, "b" => {1}, "c" => {2}]
Multimap<Integer, String> inverse = Multimaps.invertFrom(multimap, HashMultimap<Integer, String>.create());
// inverse：[1 => {"a","b"}, 2 => {"c"}]
包装器
Multimaps 提供了传统的包装方法，以及让你选择 Map 和 Collection 类型以自定义 Multimap 实现的工具方法。
| 只读包装 | Multimap | ListMultimap | SetMultimap | SortedSetMultimap |
| 同步包装 | Multimap | ListMultimap | SetMultimap | SortedSetMultimap |
| 自定义实现 | Multimap | ListMultimap | SetMultimap | SortedSetMultimap |
自定义 Multimap 的方法允许你指定 Multimap 中的特定实现。但要注意的是：
- Multimap 假设对 Map 和 Supplier 产生的集合对象有完全所有权。这些自定义对象应避免手动更新，并且在提供给 Multimap 时应该是空的，此外还不应该使用软引用、弱引用或虚引用。
- 无法保证修改了 Multimap 以后，底层 Map 的内容是什么样的。
- 即使 Map 和 Supplier 产生的集合都是线程安全的，它们组成的 Multimap 也不能保证并发操作的线程安全性。并发读操作是工作正常的，但需要保证并发读写的话，请考虑用同步包装器解决。
- 只有当 Map、Supplier、Supplier 产生的集合对象、以及 Multimap 存放的键值类型都是可序列化的，Multimap 才是可序列化的。
- Multimap.get(key)返回的集合对象和 Supplier 返回的集合对象并不是同一类型。但如果 Supplier 返回的是随机访问集合，那么 Multimap.get(key)返回的集合也是可随机访问的。
请注意，用来自定义 Multimap 的方法需要一个 Supplier 参数，以创建崭新的集合。下面有个实现 ListMultimap 的例子——用 TreeMap 做映射，而每个键对应的多个值用 LinkedList 存储。
ListMultimap<String, Integer> myMultimap = Multimaps.newListMultimap(
Maps.<String, Collection>newTreeMap(),
new Supplier<LinkedList>() {
public LinkedList get() {
return Lists.newLinkedList();
}
});
Tables
Tables 类提供了若干称手的工具方法。
自定义 Table
堪比 Multimaps.newXXXMultimap(Map, Supplier)工具方法，Tables.newCustomTable(Map, Supplier<Map>) 允许你指定 Table 用什么样的 map 实现行和列。
// 使用LinkedHashMaps替代HashMaps
Table<String, Character, Integer> table = Tables.newCustomTable(
Maps.<String, Map<Character, Integer>>newLinkedHashMap(),
new Supplier<Map<Character, Integer>> () {
public Map<Character, Integer> get() {
return Maps.newLinkedHashMap();
}
});
transpose
transpose(Table<R, C, V>)方法允许你把 Table<C, R, V>转置成 Table<R, C, V>。例如，如果你在用 Table 构建加权有向图，这个方法就可以把有向图反转。
包装器
还有很多你熟悉和喜欢的 Table 包装类。然而，在大多数情况下还请使用 ImmutableTable
| Unmodifiable | Table | RowSortedTable |