Lists
Lists類主要提供了對List類的子類構造以及操作的靜態方法。在Lists類中支持構造ArrayList、LinkedList以及newCopyOnWriteArrayList對象的方法。
其中提供了以下構造ArrayList的函數：下面四個構造一個ArrayList對象，但是不顯式的給出申請空間的大小：
newArrayList()
newArrayList(E... elements)
newArrayList(Iterable<? extends E> elements)
newArrayList(Iterator<? extends E> elements)
以下兩個函數在構造ArrayList對象的時候給出了需要分配空間的大小:
newArrayListWithCapacity(int initialArraySize)
newArrayListWithExpectedSize(int estimatedSize)
如果你事先知道元素的個數，可以用newArrayListWithCapacity函數；如果你不能確定元素的個數，可以用newArrayListWithExpectedSize函數，在newArrayListWithExpectedSize函數里面調用了computeArrayListCapacity(int arraySize)函數，其實現如下：
@VisibleForTesting static int computeArrayListCapacity(int arraySize) {
checkArgument(arraySize >= 0);
// TODO(kevinb): Figure out the right behavior, and document it
return Ints.saturatedCast(5L + arraySize + (arraySize / 10));
}
返回的容量大小為5L + arraySize + (arraySize / 10)，當arraySize比較大的時候，給定大小和真正分配的容量之比為10/11。
Lists類還支持構造LinkedList、newCopyOnWriteArrayList對象，其函數接口為：
newLinkedList()
newLinkedList(Iterable<? extends E> elements)
newCopyOnWriteArrayList()
newCopyOnWriteArrayList(Iterable<? extends E> elements)
我們還可以將兩個（或三個）類型相同的數據存放在一個list中，這樣可以傳入到只有一個參數的函數或者需要減少參數的函數中，這些函數如下：
asList(@Nullable E first, E[] rest)
asList(@Nullable E first, @Nullable E second, E[] rest)
Lists類中transform函數可以根據傳進來的function對fromList進行相應的處理，并將處理得到的結果存入到新的list對象中，這樣有利于我們進行分析，函數接口如下：
public static <F, T> List<T> transform(
List<F> fromList, Function<? super F, ? extends T> function)
但是使用這個類的是需要注意一點，轉化之后的集合，不再支持 add 等修改集合的方法。如果使用遍歷方法去修改集合里面對象，并不會產生效果。原因在于轉化之后的 List 只是原 List 的視圖而已，所以獲取轉化后集合里的對象，比如調用 get 時，每次調用會是會使用 function 轉化方法。
使用例子：
Function<String, Integer> strlen = new Function<String, Integer>() {
public Integer apply(String from) {
Preconditions.checkNotNull(from);
return from.length();
}
};
List<String> from = Lists.newArrayList("abc", "defg", "hijkl");
List<Integer> to = Lists.transform(from, strlen);
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s has length %d\n", from.get(i), to.get(i));
}
Function<String, Boolean> isPalindrome = new Function<String, Boolean>() {
public Boolean apply(String from) {
Preconditions.checkNotNull(from);
return new StringBuilder(from).reverse().toString().equals(from);
}
};
from = Lists.newArrayList("rotor", "radar", "hannah", "level", "botox");
List<Boolean> to1 = Lists.transform(from, isPalindrome);
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}
// changes in the "from" list are reflected in the "to" list
System.out.printf("\nnow replace hannah with megan...\n\n");
from.set(2, "megan");
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}
Lists還可以將傳進來的String或者CharSequence分割為單個的字符，并存入到一個新的List對象中返回，如下：
ImmutableList<Character> wyp = Lists.charactersOf("wyp");
System.out.println(wyp);
將List對象里面的數據順序反轉可以用reverse函數實現，取得List對象里面的子序列可以用subList函數實現。
Maps
HashMap
Map<String, String> aNewMap = Maps.newHashMap();
ImmutableMap
創建不可變Map：
@Test
public void whenCreatingImmutableMap_thenCorrect() {
Map<String, Integer> salary = ImmutableMap.<String, Integer> builder()
.put("John", 1000)
.put("Jane", 1500)
.put("Adam", 2000)
.put("Tom", 2000)
.build();
assertEquals(1000, salary.get("John").intValue());
assertEquals(2000, salary.get("Tom").intValue());
}
salary初始化后，不能在更改，調用put方法會報java.lang.UnsupportedOperationException異常。
SortedMap
本節我們看下創建SortMap，下面示例我們使用Guava相應builder創建一個有序map：
@Test
public void whenUsingSortedMap_thenKeysAreSorted() {
ImmutableSortedMap<String, Integer> salary = new ImmutableSortedMap
.Builder<String, Integer>(Ordering.natural())
.put("John", 1000)
.put("Jane", 1500)
.put("Adam", 2000)
.put("Tom", 2000)
.build();
assertEquals("Adam", salary.firstKey());
assertEquals(2000, salary.lastEntry().getValue().intValue());
}
我們看到salary中記錄按照字母進行排序。
BiMap
本節我們討論如何使用BiMap，BiMap也可以反向把值映射到鍵，只要確保值唯一。
下面示例中，我們創建BiMap，并使用其inverse()方法：
@Test
public void whenCreateBiMap_thenCreated() {
BiMap<String, Integer> words = HashBiMap.create();
words.put("First", 1);
words.put("Second", 2);
words.put("Third", 3);
assertEquals(2, words.get("Second").intValue());
assertEquals("Third", words.inverse().get(3));
}
Multimap
本節我們使用Multimap ，對每個鍵關聯多個值：
@Test
public void whenCreateMultimap_thenCreated() {
Multimap<String, String> multimap = ArrayListMultimap.create();
multimap.put("fruit", "apple");
multimap.put("fruit", "banana");
multimap.put("pet", "cat");
multimap.put("pet", "dog");
assertThat(multimap.get("fruit"), containsInAnyOrder("apple", "banana"));
assertThat(multimap.get("pet"), containsInAnyOrder("cat", "dog"));
}
Multimap的get方法返回 java.util.Collection，上述測試代碼除了junit，還需要增加：
testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
Table
當需要多余一個鍵索引值時，需要Table。下面示例中，我們使用Table存儲城市之間距離：
@Test
public void whenCreatingTable_thenCorrect() {
Table<String,String,Integer> distance = HashBasedTable.create();
distance.put("London", "Paris", 340);
distance.put("New York", "Los Angeles", 3940);
distance.put("London", "New York", 5576);
assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
assertThat(distance.columnKeySet(),
containsInAnyOrder("Paris", "New York", "Los Angeles"));
assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
}
ClassToInstanceMap
把類作為鍵映射至對象：
@Test
public void whenCreatingClassToInstanceMap_thenCorrect() {
ClassToInstanceMap<Number> numbers = MutableClassToInstanceMap.create();
numbers.putInstance(Integer.class, 1);
numbers.putInstance(Double.class, 1.5);
assertEquals(1, numbers.get(Integer.class));
assertEquals(1.5, numbers.get(Double.class));
}
Integer，Double都繼承至Number，ClassToInstanceMap讓不同的子類作為key。
Multimap分組
通過Multimap對List進行分組，下面示例中是使用Multimaps.index方法依據list元素的長度進行分組。
@Test
public void whenGroupingListsUsingMultimap_thenGrouped() {
List<String> names = Lists.newArrayList("John", "Adam", "Tom");
Function<String,Integer> func = new Function<String,Integer>(){
public Integer apply(String input) {
return input.length();
}
};
Multimap<Integer, String> groups = Multimaps.index(names, func);
assertThat(groups.get(3), containsInAnyOrder("Tom"));
assertThat(groups.get(4), containsInAnyOrder("John", "Adam"));
}
