Maps
@Test
public void maps() {
Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
Map<String, Integer> right = ImmutableMap.of("b", 2, "c", 4, "d", 5);
MapDifference<String, Integer> diff = Maps.difference(left, right);
// 兩個 map 都有出現的 key-value pair
Map<String, Integer> entriesInCommon = diff.entriesInCommon(); // {"b" => 2}
assertEquals("{b=2}", entriesInCommon.toString());
// 有相同的 key，不同的 values
Map<String, MapDifference.ValueDifference<Integer>> entriesDiffering = diff.entriesDiffering(); // {"c" => (3, 4)}
assertEquals("{c=(3, 4)}", entriesDiffering.toString());
// 出現在 left，沒有出現在 right 的 key-value pair
Map<String, Integer> entriesOnlyOnLeft = diff.entriesOnlyOnLeft(); // {"a" => 1}
assertEquals("{a=1}", entriesOnlyOnLeft.toString());
// 出現在 right，沒有出現在 left
Map<String, Integer> entriesOnlyOnRight = diff.entriesOnlyOnRight(); // {"d" => 5}
assertEquals("{d=5}", entriesOnlyOnRight.toString());
}uniqueIndex
@Test
public void maps_uniqueIndex() {
// nickname屬性能唯一確定一個WebUser
ArrayList<User> users = Lists.newArrayList(new User(1,"one"),new User(2,"two"),new User(3,"three"),new User(4,"four"));
// 以 name 為 key，User為值的map
ImmutableMap<String, User> map = Maps.uniqueIndex(users,new com.google.common.base.Function<User, String>() {
@Override
public String apply(User user) {
return user.getName();
}
});
System.out.println("map:" + map);
System.out.println("name:" + map.get("two").getName());
assertEquals("{one=User(id=1,name=one), two=User(id=2,name=two), three=User(id=3,name=three), four=User(id=4,name=four)}", map.toString());
}
class User {
private int id;
private String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return this.name;
}
public String toString() {
return "User(id="+id+",name="+name+")";
}
}Multisets
@Test
public void multisets() {
Multiset<String> multiset1 = HashMultiset.create();
multiset1.add("a", 2);
Multiset<String> multiset2 = HashMultiset.create();
multiset2.add("a", 5);
// returns true: all unique elements are contained,
boolean containsAll = multiset1.containsAll(multiset2);
assertTrue(containsAll);
// containsOccurrences(Multiset sup, Multiset sub)
// if sub.count(o) <= sup.count(o) for all o -> return true
// even though multiset1.count("a") == 2 < multiset2.count("a") == 5
// supCountA=2, subCountA=5
// System.out.println("multiset1 CountA="+multiset1.count("a")+", multiset2 CountA="+multiset2.count("a"));
boolean containsOccurrences = Multisets.containsOccurrences(multiset1, multiset2); // returns false
assertFalse(containsOccurrences);
// retainOccurrences(Multiset removeFrom, Multiset toRetain)
// 確保 removeFrom.count(o) <= toRetain.count(o) for all o
boolean retainOccurrences = Multisets.retainOccurrences(multiset1, multiset2);
assertFalse(retainOccurrences);
System.out.println("multiset1 CountA="+multiset1.count("a")+", multiset2 CountA="+multiset2.count("a"));
// intersection of two multisets
Multiset<String> intersection = Multisets.intersection(multiset1, multiset2);
assertEquals(2, intersection.count("a"));
// removeOccurrences(Multiset removeFrom, Multiset toRemove)
// 自 removeFrom 中，移除 toRemove 的 element 出現的次數
Multisets.removeOccurrences(multiset2, multiset1); // multiset2 now contains 3 occurrences of "a"
assertEquals(3, multiset2.count("a"));
// 移除 multiset2 中所有的元素
multiset2.removeAll(multiset1); // removes all occurrences of "a" from multiset2, even though multiset1.count("a") == 2
assertTrue(multiset2.isEmpty()); // returns true
Multiset<String> multiset = HashMultiset.create();
multiset.add("a", 3);
multiset.add("b", 5);
multiset.add("c", 1);
// 次數從大到小的順序，排列 multiset
ImmutableMultiset<String> highestCountFirst = Multisets.copyHighestCountFirst(multiset);
assertEquals("[b x 5, a x 3, c]", highestCountFirst.toString());
}Multimaps
@Test
public void mutlimaps() {
ImmutableSet<String> 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();
}
};
// Multimaps.index(Iterable, Function)
// 以 Function apply 的結果分類，將相同字串長度的元素，放在一起
ImmutableListMultimap<Integer, String> digitsByLength = Multimaps.index(digits, lengthFunction);
/*
* digitsByLength maps:
* 3 => {"one", "two", "six"}
* 4 => {"zero", "four", "five", "nine"}
* 5 => {"three", "seven", "eight"}
*/
assertEquals("{4=[zero, four, five, nine], 3=[one, two, six], 5=[three, seven, eight]}", digitsByLength.toString());
////////
// Multimaps.invertFrom(Multimap toInvert, Multimap dest)
// 如果要得到 Immutablemiltimap 就呼叫 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.<Integer, String>create());
// note that we choose the implementation, so if we use a TreeMultimap, we get results in order
/*
* inverse maps:
* 1 => {"a"}
* 2 => {"a", "b", "c"}
* 3 => {"c"}
* 4 => {"a", "b"}
* 5 => {"c"}
* 6 => {"b"}
*/
assertEquals("{1=[a], 2=[a, b, c], 3=[c], 4=[a, b], 5=[c], 6=[b]}", inverse.toString());
/////
// forMap(Map) 將 Map 轉換為 SetMultimap
// 特別適合用在 Multimaps.invertFrom
Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 1, "c", 2);
SetMultimap<String, Integer> multimap2 = Multimaps.forMap(map);
// multimap maps ["a" => {1}, "b" => {1}, "c" => {2}]
Multimap<Integer, String> inverse2 = Multimaps.invertFrom(multimap2, HashMultimap.<Integer, String> create());
// inverse maps [1 => {"a", "b"}, 2 => {"c"}]
assertEquals("{1=[a, b], 2=[c]}", inverse2.toString());
}Tables
@Test
public void tables() {
// Tables.newCustomTable(Map, Supplier<Map>)
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();
}
});
table.put("a", 'x', 1);
table.put("a", 'y', 2);
table.put("a", 'z', 3);
table.put("b", 'x', 4);
table.put("b", 'y', 5);
table.put("b", 'z', 6);
assertEquals("{a={x=1, y=2, z=3}, b={x=4, y=5, z=6}}", table.toString());
// transpose 轉置矩陣
assertEquals("{x={a=1, b=4}, y={a=2, b=5}, z={a=3, b=6}}", Tables.transpose(table).toString());
}