引言

集合對于任何一門語言都是必須的。沒有集合我們寫不出一些復雜的邏輯。Guava繼承擴展了Google Collections的一些功能。 從 com.google.common.collect包下面的類的數量，我們就可以看出Collections的重要性。 雖然已經有了這么多的工具類，但是還是有很多場景我們沒有覆蓋到，我們希望我們能夠覆蓋到日常使用的哪些。 下面我們就在每天的編程中經常會使用的類做一下介紹. 這一章節中我們將涉及以下幾個方面:

• lists,maps,sets 等這些包含非常有用的靜態方法的類
• Range類，主要作用是表示一個連續集合的邊界值
• 不可變集合類
• Bimaps，可以像key-to-value方式一樣去操作value-key
• Table 類型的集合，可以代替我們之前為了表示一個表格而采用 嵌套Map的方式
• Mutimaps 可以支持一個唯一的key對映多個值
• FluentIterable
• Ordring 類 增強了Comparators的能力

FluentIterable 類

FluentIterable 類是一個Iterable的更加有力的版本，FluentIterable 采用了鏈式編程的方式，使得代碼的可讀性更好。

使用FluentIterable.filter方法

FluentIterable 接受一個Predicate 參數，每個參數都會執行Predicate指定的方法，如果為true就加入到Iterable中，如果沒有一個對象滿足條件，那么就返回一個空的Iterable對象。 下面的這個例子中,我們將展示怎樣結合from和fliter方法來返回合理的Iterable對象:

@Before public void setUp() { person1 = new Person("Wilma", "Flintstone", 30, "F"); person2 = new Person("Fred", "Flintstone", 32, "M"); person3 = new Person("Betty", "Rubble", 31, "F"); person4 = new Person("Barney", "Rubble", 33, "M"); personList = Lists.newArrayList(person1, person2, person3, person4); } @Test public void testFilter() throws Exception { Iterable<Person> personsFilteredByAge= FluentIterable.from(personList).filter(new Predicate<Person>() { @Override public boolean apply(Person input) { return input.getAge() > 31; } }); assertThat(Iterables.contains(filtered, person2), is(true)); assertThat(Iterables.contains(filtered, person4), is(true)); assertThat(Iterables.contains(filtered, person1), is(false)); assertThat(Iterables.contains(filtered, person3), is(false)); }

上面的代碼中我們使用setUp方法，我們創建了一個personList對象，使用Lists.newArrayList()方法，在Test 方法中，我們創建了一個personFilterByAge 的Precidate實例，通過FluentIterable.from（）將 personList作為參數傳遞給filter中。 Assert中我們驗證了是否滿足條件的對象都包含在了Iterable中。

使用FluentIterable.transForm 方法

FluentIterable.transform 方法是一個mapping的映射，將新的Function應用到每一個元素中， 結果中會產生一個新的Iterable對象，包含了轉換后的每一個對象。和filter方法不同的事，filter方法會改變原來的集合。而transfrom方法則是返回一個新的集合。 下面是具體的代碼:

@Test public void testTransform() throws Exception { List<String> transformedPersonList = FluentIterable.from(personList).transform(new Function<Person, String>() { @Override public String apply(Person input) { return Joiner.on('#').join(input.getLastName(), input.getFirstName(), input.getAge()); } }).toList(); assertThat(transformed.get(1), is("Flintstone#Fred#32")); }

在這個例子中，我們將personList中的每一個person對象用'#'將lastName，firstName，age連接在一起，這里我們使用FluentIterable的鏈式編程，FluentIterable.from().transForm().toList()方法，最后我們采用了toList()方法返回了一個List對象，除了toList()方法我們還有toSet,toMap,toSortedList，toSortedSet方法，其中toMap方法中，我們將fluentIterbale中的每一個對象當作key,對每一個key使用toMap中指定的Function方法得到value。 toSortedList和toSortedSet方法使用一個Comparator方法作為參數來指定順序。 這里還有很對方法我們沒有介紹到，并且我們還有很多實現Iterable接口的類，‘FluentIterable’ 是一個比較好用的類。

Lists

Lists 是List的一個工具類的實現，一個最大的便利是可以非常方便的創建一個新的List實例:

List<Person> personList = Lists.newArrayList();

使用Lists.partition方法

Lists.partition() 是一個非常有意思的方法，根據你傳入的參數將list分隔成多個子list,但是有個意外就是有可能最后一個list并沒有指定的那么多元素。 下面我們來看一個例子:

List<Person> personList = Lists.newArrayList(person1,person2,person3,person4); List<List<Person>> subList = Lists.partition(personList,2);

在之前的例子中，我們創建了一個List對象，里面包含了4個person對象，調用了partition方法后我們會得到一個List>對象，其中 第一個是[person1,person2] 第二個是[person3,person4],但是如果是調用的Lists.partition(personList,3)的話，那么第一個[person1,person2，person3]第二個就變成了[person4]

使用Sets

Sets 是 Set接口的一個工具類實現，包含了創建 HashSets,LinkedHashSets,TreeSets。

使用Sets.difference 方法

Sets.fifference 方法接受兩個set對象參數,返回一個SetView 包含了在第一個set存在，但是在第二個set中不存在的元素。 SetView是一個Sets類的靜態內部類，是一個不可變對象。 下面我們來看一個例子:

Set<String> s1 = Sets.newHashSet("1","2","3"); Set<String> s2 = Sets.newHashSet("2","3","4"); Sets.difference(s1,s2);

這時候 我們得到得SetView對象中有"1"這個元素，但是我們要是顛倒s1,s2那么得到得就會是"4"

使用Sets.symmetricDifference方法

這個方法返回的是 在第一個set中存在,或則在第二個set中存在，但是不在set1和set2都存在的。就是返回除了set1和set2交集之外的元素. 返回的結果也是也是一個不變對象.例子如下:

Set<String> s1 = Sets.newHashSet("1","2","3"); Set<String> s2 = Sets.newHashSet("2","3","4"); Sets.SetView setView = Sets.symmetricDifference(s1,s2); //Would return [1,4]

使用Sets.intersection 方法

這個方法返回兩個set的交集:

@Test public void testIntersection(){ Set<String> s1 = Sets.newHashSet("1","2","3"); Set<String> s2 = Sets.newHashSet("3","2","4"); Sets.SetView<String> sv = Sets.intersection(s1,s2); assertThat(sv.size()==2 && sv.contains("2") && sv.contains("3"),is(true));

Sets.union方法

這個方法返回兩個set的并集

@Test public void testUnion(){ Set<String> s1 = Sets.newHashSet("1","2","3"); Set<String> s2 = Sets.newHashSet("3","2","4"); Sets.SetView<String> sv = Sets.union(s1,s2); assertThat(sv.size()==4 && sv.contains("2") && sv.contains("3") && sv.contains("4") && sv.contains("1"),is(true)); }

Maps

Maps 是一個非常有必要的數據結構，在我們的日常的編程中經常會用到，快速簡單的創建使用map可以提高程序員的工作效率。 Maps 工具類正是提供了一些幫助。 首先我們要嘗試一下可以快速從一些Collection 中構建一個Map對象。 現在讓我關注一下這樣的一個問題: 我們有一個List對象，我們希望將它變成為一個map對象，以書的ISBN對象為key. 在沒有使用Maps之前，我們可能寫如下的代碼:

List<Book> books = someService.getBooks(); Map<String,Book> bookMap = new HashMap<String,Book>() for(Book book : books){ bookMap.put(book.getIsbn(),book); }

盡管上面的代碼簡潔明了，但是我們可以做到更簡單。

使用Maps.uniqueIndex 方法

Maps.uniqueIndex方法 接受兩個參數 一個是 Iterable對象，一個是 Function對象。 Iterable對象的元素作為 Map的value， Function對象接受 Iterable元素作為值 經過 apply返回的值作為Map的key。 例子如下:

List<Book> books = someService.getBooks(); Map<String,Book>bookMap = Maps.uniqueIndex(books.iterator(),new Function<Book, String>(){ @Override public String apply( Book input) { return input.getIsbn(); } };)

這個例子中我們提供了books 集合并且定義了一個Function抽取了book中的ISBN作為map的key。我們這里對于Function使用了匿名內部類，我們其實還可以使用依賴注入的方式，這樣我們就可以很簡單的將抽取算法改變。

使用Maps.asMap方法

Maps.uniqueIndex 方法使用Function去產生keys，Maps.asMap 剛好采用相反的方式。 Maps.asMap 用 set of objects 作為keys， 使用Function 對每一個key執行apply方法等到一個value值。 還有另外一個方法 Maps.toMap 接受相同的參數，但是返回值不一樣，Map.toMap返回一個不可變的Map. 這兩個方法的區別就是 對于 Maps.toMap 返回值的改動不會影響到原來的Map,但是 Maps.asMap的返回值改動會影響到原來的Map。

Transforming Maps

Maps 類中有很多非常有用方法用于改變map的值。 Maps.transfromEntries 方法使用一個實現了Maps.EntryTransformer接口的實例，原來的每個key對應的值轉換成一個新的值。 Maps.transformValues 使用一個實現了Function接口的實例,將原來的值轉換成一個新值。

Multimaps

盡管Map是一個非常好用的數據結構，但是我們經常會想要把key對應為多個Value。 我們可以自己實現這樣的功能，比如將一個key 對應的value 設計成是一個List. 但是GUAVA可以讓這個變得更加簡單，Multimaps 里面的一些靜態方法返回一個Map實例，這樣我們就可以像之前使用Map一樣，簡單的使用put(key,value)方法. 下面讓我們一起探究一下這個神奇的map。

ArrayListMultimap

ArrayListMultimap使用ArrayList 存儲給定的key對應的value. 我們可以按照如下方式創建ArrayListMultimap實例. 代碼樣例如下:

? ArrayListMultimap<String,String> multiMap = ArrayListMultimap.create(); ? ArrayListMutilmap<String,String> multiMap = ArrayListMultimap.create(numExcpectedKeys,numExpectedValuesPer Key); ? ArrayListMulitmap<String,String> mulitMap = ArrayListMultimap.create(listMultiMap);

下面我們來看一下具體的使用方式:

@Test public void testArrayListMultiMap(){ ArrayListMultimap<String,String> multiMap = ArrayListMultimap.create(); multiMap.put("Foo","1"); multiMap.put("Foo","2"); multiMap.put("Foo","3"); List<String> expected = Lists.newArrayList("1","2","3"); assertEquals(multiMap.get("Foo"),expected); }

這里我們只是簡單的向創建好的multiMap里put相同的key對應的value，然后我們再取出key對應的List對象進行比較.

下面讓我考慮一下林外一種使用方式。 如果我們針對一個key，不斷的put相同的value會是怎樣的一種情況呢，讓我們來看一下下面的例子:

@Test public void testArrayListMultimapSameKeyValue(){ ArrayListMultimap<String,String> multiMap = ArrayListMultimap.create(); multiMap.put("Bar","1"); multiMap.put("Bar","2"); multiMap.put("Bar","3"); multiMap.put("Bar","3"); multiMap.put("Bar","3"); List<String> expected = Lists. newArrayList("1","2","3","3","3"); assertEquals(multiMap.get("Bar"),expected); }

顯然 List是不要求里面的元素是唯一的。 上面的那個test顯然是能通過的。 下面讓我們來考慮一下另外一個例子:

multiMap.put("Foo","1"); multiMap.put("Foo","2"); multiMap.put("Foo","3"); multiMap.put("Bar","1"); multiMap.put("Bar","2"); multiMap.put("Bar","3");

那么調用multimap.size()方法返回的值是什么呢? 是6還是2. 方法size()返回的是每個list里面的元素之和，而不是返回list的個數. 另外調用values() 方法返回的是一個包含的6個值，而不是返回2個集合每個集合包含3個元素. 這個一開始看上去有點讓人想不通，但是我們要想到Multimap它其實不是一個真正的map，如果我們想像處理真正的Map去操作 我們可以調用下面的方法:

Map<String,Collection<String>> map = multiMap.asMap();

由返回的對象我們就可以很簡單的看出返回的是 一個key及對應的 Collection對象. 這里要注意的是 轉換成普通的map后，我們就不能簡單的調用map.put(key,value), 還有就是 對map的改動都會反映到原來的multimap中。

HashMultimap

HashMultiMap是基于Hash Tables,和ArrayListMultimap 不一樣的是，針對同一個key不斷put相同的value是不支持的，只會保留最后一個vaule值。 下面我們來看一下下面的例子:

HashMultimap<String,String> multiMap = HashMultimap.create(); multiMap.put("Bar","1"); multiMap.put("Bar","2"); multiMap.put("Bar","3"); multiMap.put("Bar","3"); multiMap.put("Bar","3");

上面的例子中我們針對bar插入了3次值， 但是當我們調用Multimap的size時，僅僅返回3. 除了不支持相同key-value的插入，其他的使用方式基本都一樣，我們這邊就不再啰嗦了。

Multimap總結

在我們講其他之前，我們先來了解一下Multimap的其他的一些實現類, 首先我們有3個不變類實現:
ImmutableListMultimap, ImmutableMultimap, and ImmutableSetMultimap, LinkedHashMultiMap 是一個有順序的集合，按照的是插入的順序。 最后我們還有一個 TreeMultimap，他的排序順序是按照自然順序或則也可以指定一個comparator。

BiMap

和一個key可以用多個value一樣，map還有一種方式可以使一個value對應一個key，這就是Bimap. BiMap中value的值是唯一的。下面讓我們看一個具體的例子:

BiMap<String,String> biMap = HashBiMap.create(); biMap.put("1","Tom"); //This call causes an IllegalArgumentException to be thrown! biMap.put("2","Tom");

在這個例子中我們嘗試將兩個相同的value加入到BiMap中，但是這回導致拋出"IlleagalArgumentException" 異常.

使用 BiMap.forcePut 方法

我們也可以是使用forcePut(key,value),這樣的話如果出現 value相同,那么就會將以前的key-value 移出，將新的put進去. 下面我們來看一下例子:

@Test public void testBiMapForcePut() throws Exception { BiMap<String,String> biMap = HashBiMap.create(); biMap.put("1","Tom"); biMap.forcePut("2","Tom"); assertThat(biMap.containsKey("1"),is(false)); assertThat(biMap.containsKey("2"),is(true)); }

使用Bimap.inverse方法

下面我們來看一下inverse方法的使用:

@Test public void testBiMapInverse() throws Exception { BiMap<String,String> biMap = HashBiMap.create(); biMap.put("1","Tom"); biMap.put("2","Harry"); assertThat(biMap.get("1"),is("Tom")); assertThat(biMap.get("2"),is("Harry")); BiMap<String,String> inverseMap = biMap.inverse(); assertThat(inverseMap.get("Tom"),is("1")); assertThat(inverseMap.get("Harry"),is("2")); }

這個就沒有什么要解釋的了，大家看了就懂。

Table

Maps 是一個非常強大的工具，但是有的時候我們僅僅使用一個Map是不夠的，我們希望能在map中使用map。 Guava的 Table 提供了類似的數據結構， 一個Table 集合包含兩個key,一個是行號,一個是列號，這兩個組合起來指向一個value。
在guava 中有很對對Table的實現，比如說 HashBaseTable, 采用Map>的方式存儲數據，使用Guava我們可以按照如下方式創建：

HashBasedTable<Integer,Integer,String> table = HashBasedTable.create(); //Creating table with 5 rows and columns initially HashBasedTable<Integer,Integer,String> table = HashBasedTable.create(5,5); //Creating a table from an existing table HashBasedTable<Integer,Integer,String> table = HashBasedTable.create(anotherTable);

Table operations

下面是針對Table的一些常見的操作:

HashBasedTable<Integer,Integer,String> table = HashBasedTable.create(); table.put(1,1,"Rook"); table.put(1,2,"Knight"); table.put(1,3,"Bishop"); boolean contains11 = table.contains(1,1); boolean containColumn2 = table.containsColumn(2); boolean containsRow1 = table.containsRow(1); boolan containsRook = table.containsValue("Rook"); table.remove(1,3); table.get(3,4);

Table views

Table提供非常好用的方法獲取行列數據:

Map<Integer,String> columnMap = table.column(1); Map<Integer,String> rowMap = table.row(2);

column() 方法返回一列數據，row方法返回兩行數據，要注意的是返回的Map結果是一個引用,對返回結果的改變會直接改變原有的數據集。

Table還有一些其他實現：

ArrayTable 就是一個簡單的二維 數組。int[][]...

ImmutableTable 這種Table創建后就不能夠被改變，可以調用ImmutableTable.Builder方法創建

TreeBaseedTable 這個table的 行，列 是排序的,既可以按照自然順序排序，也可以指定排序方法。

Range

Range 可以幫助我們創建一個開閉渠道的集合，通過下面的例子我們就可以了解Range的作用:

Range<Integer> numberRange = Range.closed(1,10); //both return true meaning inclusive numberRange.contains(10); numberRange.contains(1); Range<Integer> numberRange = Range.open(1,10); //both return false meaning exclusive numberRange.contains(10); numberRange.contains(1);

Ranges with arbitrary comparable objects

Range 可以和任何實現了Comparable接口的對象合作，這樣就可以非常簡單創建一個filter去過濾符合Range條件的對象。 下面這個是一個Person的例子:

public class Person implements Comparable<Person> { private String firstName; private String lastName; private int age; private String sex; @Override public int compareTo(Person o) { return ComparisonChain.start(). compare(this.firstName,o.getFirstName()). compare(this.lastName,o.getLastName()). compare(this.age,o.getAge()). compare(this.sex,o.getSex()).result(); }

我們希望能過獲取年齡在30-50之間的那些人. 所以我們可以創建一個Range對象

Range<Integer> ageRange = Range.closed(35,50);

接著我們創建一個返回年齡值的Function:

Function<Person,Integer> ageFunction = new Function<Person, Integer>() { @Override public Integer apply(Person person) { return person.getAge(); } };

最后我們利用Predicate的compose方法整合這兩個功能:

Predicate<Person> predicate = Predicates.compose(ageRange,ageFunction);

這樣我們就可以獲取年齡在[30,50]之間的Person對象了。

Immutable collections

縱觀整個章節，我們知道了很對創建collections的方法，但是絕大多數都是返回的可變集合對象，如果我們不是特別需要可變集合，一般來說我們最好返回一個不可變集合，原因有下面兩個:

不可變集合是線程安全的

他可以阻止一些不知道的改變影響到原來的數據

Guava 提供了非常多的可選的不變集合，這些個集合對有對應的可變版本.

Creating immutable collection instances

只是返回的結果不一樣，因此其他的功能我們就不多介紹，我們只是簡單的看一下如何創建一個不可變集合，每一個不可變集合都有一個Builder方法,可以采用鏈式編程的方式,下面我們來看一下具體的例子:

MultiMap<Integer,String> map = new ImmutableListMultimap.Builder<Integer,String>() .put(1,"Foo") .putAll(2,"Foo","Bar","Baz") .putAll(4,"Huey","Duey","Luey") .put(3,"Single").build();

上面我們采用了鏈式編程的方式將key-value加入到Map中，最后調用了build()方法。

Ordering

對集合進行排序在編程中是一個關鍵點，在寫代碼中，一個非常好用的Sort工具是非常必要的，Ordering類提供了一個非常強大和好用的抽象類。 Ordering 類實現了 Comparator接口并且定義了抽象方法compare.

Creating an Ordering instance

有兩種方式可以創建Ordering實例:

創建一個新的實例并且實現compare方法

使用Ordering.from 靜態方法創建實例，參數為一個為實現了Compare接口的Comparator。
總的來說 具體額排序的實現還是由我們自己實現的。Ordering只是在此基礎上加上了一些好用的封裝。

Reverse sorting

設想一下我們實現一個按照城市人口排序的Comparator.

public class CityByPopluation implements Comparator<City> { @Override public int compare(City city1, City city2) { return Ints.compare(city1.getPopulation(),city2. getPopulation()); } }

如果是我們使用上面的Comparator那么我們將得到的是城市人口從小到大的排序，那么如果我們想得到一個從大到小的排序呢? 我們就可以使用Ordering提供的方法

Ordering.from(cityByPopluation).reverse();

在這個例子中,我們調用了Ordering.from()方法創建了一個Ordering對象,然后調用reverse()方法。

Accounting for null

在排序的過程中，我們一般會考慮值為null的對象，我們是把他們放在最前面還是最后面? Ordering給我們提供一個比較簡單的方法:

Ordering.from(comparator).nullsFirst(); Ordering.from(comparator).nullsLast();

Secondary sorting

在我們排序的過程中，我們會經常會碰到equals的情況，那么這時候我們就可以定義一個secondary的排序，下面我們來考慮一下上面的例子中城市人口相等情況，這時候我們就可以再定義一個第二次排序.按照降雨量排序.

public class CityByRainfall implements Comparator<City> { @Override public int compare(City city1, City city2) { return Doubles.compare(city1.getAverageRainfall(),city2. getAverageRainfal l()); } }

我們可以按照如下的方式指定第二排序:

Ordering.from(cityByPopulation).compound(cityByRainfall);

下面看一個包含二次排序的例子:

@Test public void testSecondarySort(){ City city1 = cityBuilder.population(100000). averageRainfall(55.0).build(); City city2 = cityBuilder.population(100000). averageRainfall(45.0).build(); City city3 = cityBuilder.population(100000). averageRainfall(33.8).build(); List<City> cities = Lists.newArrayList(city1,city2,city3); Ordering<City> secondaryOrdering = Ordering. from(cityByPopulation).compound(cityByRainfall); Collections.sort(cities,secondaryOrdering); assertThat(cities.get(0),is(city3)); }

Retrieving minimum and maximum values

最后我們來看一下，Ordering類可以讓我們很方便的在一個集合里面找到最大值和最小值. 下面看一下代碼實例:

Ordering<City> ordering = Ordering.from(cityByPopluation); List<City> topFive = ordering.greatestOf(cityList,5); List<City> bottomThree = ordering.leastOf(cityList,3);

上面的代碼中我們可以簡單的獲取 城市人口排名前5 和 倒數3名的城市

Summary

這一章我們學習了：

• FluentIterable
• Multimap
• Table
• Range
• Immutable
• Ordering

總結

以上是生活随笔為你收集整理的guava翻译系列之Collections的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。