Guava工具总结
Table双键Map
public class OTest {
public static void main(String[] args) {
Map<String, Map<String, Integer>> map = new HashMap<>();
//存放元素
Map<String, Integer> workMap = new HashMap<>();
workMap.put("Jan", 20);
workMap.put("Feb", 28);
map.put("Hydra", workMap);
Map<String, Integer> workMap2 = new HashMap<>();
workMap2.put("Jan", 18);
workMap2.put("Feb", 16);
map.put("Trunks", workMap2);
//取出元素
Integer dayCount = map.get("Hydra").get("Jan");
System.out.println(dayCount);
// 1、定义 一个表格
Table<String, String, Integer> table = HashBasedTable.create();
//存放元素
table.put("Hydra", "Jan", 20);
table.put("Hydra", "Feb", 28);
table.put("Trunks", "Jan", 28);
table.put("Trunks", "Feb", 16);
// 1、取出元素
Integer dayCount2 = table.get("Hydra", "Jan");
System.out.println(dayCount2);
// 2、rowKey或columnKey的集合
Set<String> rowKeys = table.rowKeySet();
System.out.println(rowKeys);
Set<String> columnKeys = table.columnKeySet();
System.out.println(columnKeys);
// 3、value集合
Collection<Integer> values = table.values();
System.out.println(values);
// 4、转为嵌套的Map
Map<String, Map<String, Integer>> map2 = table.rowMap();
System.out.println(map2);
Map<String, Map<String, Integer>> map3 = table.columnMap();
System.out.println(map3);
}
}
BiMap双向Map
public class OTest2 {
public static void main(String[] args) {
BiMap<String, String> biMap = HashBiMap.create();
biMap.put("Hydra", "Programmer");
biMap.put("Tony", "IronMan");
biMap.put("Thanos", "Titan");
//使用key获取value
System.out.println(biMap.get("Tony"));
BiMap<String, String> inverse = biMap.inverse();
//使用value获取key
System.out.println(inverse.get("Titan"));
// 1、反转后操作的影响上面我们用inverse方法反转了原来BiMap的键值映射，但是这个反转后的BiMap并不是一个新的对象，
// 它实现了一种视图的关联，所以对反转后的BiMap执行的所有操作会作用于原先的BiMap上。
HashBiMap<String, String> biMap1 = HashBiMap.create();
biMap1.put("Hydra", "Programmer");
biMap1.put("Tony", "IronMan");
biMap1.put("Thanos", "Titan");
BiMap<String, String> inverse1 = biMap1.inverse();
inverse1.put("IronMan", "Stark");
System.out.println(biMap1);
// 2、value不可重复
// BiMap的底层继承了Map，我们知道在Map中key是不允许重复的，而双向的BiMap中key和value可以认为处于等价地位，因此在这个基础上加了限制，value也是不允许重复的。看一下下面的代码：
// 这样代码无法正常结束，会抛出一个IllegalArgumentException异常：
try {
HashBiMap<String,String> biMap2 = HashBiMap.create();
biMap2.put("Tony","IronMan");
biMap2.put("Stark","IronMan");
} catch (Exception e) {
if (e instanceof IllegalArgumentException) {
System.out.println("IllegalArgumentException异常");
}
}
// 3、获取value为set集合
Set<String> values = biMap.values();
System.out.println(values);
}
}
Multimap - 多值Map
public class OTest3 {
public static void main(String[] args) {
Multimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put("day", 1);
multimap.put("day", 2);
multimap.put("day", 8);
multimap.put("month", 3);
System.out.println(multimap);
// 1、获取值的集合
Collection<Integer> day = multimap.get("day");
// 如果在创建时指定为ArrayListMultimap类型，那么get方法将返回一个List
ArrayListMultimap<String, Integer> multimap2 = ArrayListMultimap.create();
List<Integer> day2 = multimap2.get("day");
System.out.println(day2);
// 同理，你还可以创建HashMultimap、TreeMultimap等类型的Multimap。
// Multimap的get方法会返回一个非null的集合，但是这个集合的内容可能是空，看一下下面的例子
System.out.println(multimap.get("day"));
System.out.println(multimap.get("year"));
// 2、操作get后的集合
// 和BiMap的使用类似，使用get方法返回的集合也不是一个独立的对象，可以理解为集合视图的关联，对这个新集合的操作仍然会作用于原始的Multimap上，看一下下面的例子：
ArrayListMultimap<String, Integer> multimap3 = ArrayListMultimap.create();
multimap3.put("day", 1);
multimap3.put("day", 2);
multimap3.put("day", 8);
multimap3.put("month", 3);
List<Integer> day3 = multimap3.get("day");
List<Integer> month3 = multimap3.get("month");
//这个0是下标
day3.remove(0);
month3.add(12);
System.out.println(multimap);
// 3、转换为Map
// 使用asMap方法，可以将Multimap转换为Map<K,Collection>的形式，同样这个Map也可以看做一个关联的视图，在这个Map上的操作会作用于原始的Multimap。
Map<String, Collection<Integer>> map = multimap.asMap();
for (String key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
map.get("day").add(20);
System.out.println(multimap);
}
}
RangeMap范围Map
public class OTest4 {
public static void main(String[] args) {
// 先看一个例子，假设我们要根据分数对考试成绩进行分类，那么代码中就会出现这样丑陋的if-else
System.out.println(getRank(80));
// 而guava中的RangeMap描述了一种从区间到特定值的映射关系，让我们能够以更为优雅的方法来书写代码。下面用RangeMap改造上面的代码并进行测试：
RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
rangeMap.put(Range.closedOpen(0, 60), "fail");
rangeMap.put(Range.closed(60, 90), "satisfactory");
rangeMap.put(Range.openClosed(90, 100), "excellent");
System.out.println(rangeMap.get(59));
System.out.println(rangeMap.get(60));
System.out.println(rangeMap.get(90));
System.out.println(rangeMap.get(91));
rangeMap.remove(Range.closed(70,80));
System.out.println(rangeMap.get(75));
}
public static String getRank(int score) {
if (0 <= score && score < 60) {
return "fail";
} else if (60 <= score && score <= 90) {
return "satisfactory";
} else if (90 < score && score <= 100) {
return "excellent";
}
return null;
}
}
ClassToInstanceMap实例Map
public class OTest5 {
public static void main(String[] args) {
ClassToInstanceMap<Object> instanceMap = MutableClassToInstanceMap.create();
SysUser user = new SysUser();
SysDept dept = new SysDept();
instanceMap.putInstance(SysUser.class, user);
instanceMap.putInstance(SysDept.class, dept);
// 使用ClassToInstanceMap这种方式有什么好处呢？
// 首先，这里最明显的就是在取出对象时省去了复杂的强制类型转换，避免了手动进行类型转换的错误。
// 其次，我们可以看一下ClassToInstanceMap接口的定义，它是带有泛型的：
// public interface ClassToInstanceMap<B> extends Map<Class<? extends B>,B>{...}
ClassToInstanceMap<Map> instanceMap2 = MutableClassToInstanceMap.create();
HashMap<String, Object> hashMap = new HashMap<>();
TreeMap<String, Object> treeMap = new TreeMap<>();
ArrayList<Object> list = new ArrayList<>();
instanceMap.putInstance(HashMap.class, hashMap);
instanceMap.putInstance(TreeMap.class, treeMap);
System.out.println(instanceMap2);
// 这样是可以正常执行的，因为HashMap和TreeMap都集成了Map父类，但是如果想放入其他类型，就会编译报错：
// instanceMap2.putInstance(ArrayList.class, list);
}
}
