集合-强大的集合工具类：java.util.Collections中未包含的集合工具

任何对JDK集合框架有经验的程序员都熟悉和喜欢java.util.Collections包含的工具方法。Guava沿着这些路线提供了更多的工具方法：适用于全部集合的静态方法。这是Guava最流行和成熟的部分之一。java

咱们用相对直观的方式把工具类与特定集合接口的对应关系概括以下：git

在找相似转化、过滤的方法？请看第四章，函数式风格。
程序员

静态工厂方法

在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第一条），咱们能够提升集合初始化大小的可读性：app

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的函数式方法将在第四章讨论。

常规方法

*译者注：懒视图意味着若是还没访问到某个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。

FluentIterable

除了上面和第四章提到的方法，FluentIterable还有一些便利方法用来把本身拷贝到不可变集合

Lists

除了静态工厂方法和函数式编程方法，Lists为List类型的对象提供了若干工具方法。

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提供以下静态工厂方法：

Sets

Sets工具类包含了若干好用的方法。

集合理论方法

咱们提供了不少标准的集合运算（Set-Theoretic）方法，这些方法接受Set参数并返回SetView，可用于：

• 直接看成Set使用，由于SetView也实现了Set接口；
• 用copyInto(Set)拷贝进另外一个可变集合；
• 用immutableCopy()对本身作不可变拷贝。

使用范例：

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工具方法

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提供以下静态工厂方法：

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对象，把不一样点的维恩图分解为：

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实现。

静态工厂方法

Maps提供以下静态工厂方法：

Multisets

标准的Collection操做会忽略Multiset重复元素的个数，而只关心元素是否存在于Multiset中，如containsAll方法。为此，Multisets提供了若干方法，以顾及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中的其余工具方法还包括：

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)一般针对的场景是：有一组对象，它们有共同的特定属性，咱们但愿按照这个属性的值查询对象，但属性值不必定是独一无二的。

比方说，咱们想把字符串按长度分组。

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()作反转。

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的方法容许你指定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