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);
    }
}