guava使用(1)-集合

1. 为什么要使用guava

Guava是一种基于开源的Java库,谷歌很多项目使用它的很多核心库。这个库是为了方便编码,并减少编码错误。这个库提供用于集合，缓存，支持原语，并发性，常见注解，字符串处理，I/O和验证的实用方法。

2. 集合

2.1 普通集合创建

        List<String> list = Lists.newArrayList();
        Set<String> set = Sets.newHashSet();
        Map<String, String> map = Maps.newHashMap();
        // 创建并初始化普通的集合
        ArrayList<String> arrayList = Lists.newArrayList("1", "2", "3");

        // jdk创建版本
        List<String> al = new ArrayList<>();
        al.add("1");
        al.add("2");
        al.add("3");

2.2 不可变集合创建

        ImmutableList iList = ImmutableList.of("1", "2", "3");
        ImmutableSet<String> iSet = ImmutableSet.of("1", "2");
        ImmutableMap<String, String> iMap = ImmutableMap.of("k1", "v1", "k2", "v2");

不可变集合的优点：

• 数据不可改变
• 线程安全
• 不需要同步逻辑
• 可以被自由的共享
• 容易设计和实现
• 内存和时间高效

2.3 新集合

      // 2.1 MultiSet: 无序+可重复   count()方法获取单词的次数  增强了可读性+操作简单
//        创建方式:  Multiset<String> set = HashMultiset.create();
        Multiset<String> multiset = HashMultiset.create();
        multiset.add("1");
        multiset.add("1");
        multiset.add("2");
        // 设置多个
        multiset.setCount("3",4);
        System.out.println(multiset.count("3"));
        System.out.println(multiset);

        // 2.2 Multimap: key-value  key可以重复，可以替代Map<String,List>
//        创建方式: Multimap<String, String> teachers = ArrayListMultimap.create();

        Map<String,List<String>> map0 = Maps.newHashMap();
        map0.put("classA",Lists.newArrayList("zhang1","zhang2"));
        map0.put("classB",Lists.newArrayList("zhang3"));
        map0.put("classC",Lists.newArrayList("zhang4","zhang5"));

        ArrayListMultimap<String,String> arrayListMultimap = ArrayListMultimap.create();
        arrayListMultimap.put("classA","zhang1");
        arrayListMultimap.put("classA","zhang2");
        arrayListMultimap.put("classB","zhang3");
        arrayListMultimap.put("classC","zhang4");
        arrayListMultimap.put("classC","zhang5");


        // 2.3 BiMap: 双向Map(Bidirectional Map) 键与值都不能重复
//        创建方式:  BiMap<String, String> biMap = HashBiMap.create();
        Map<String, String> map1 = Maps.newHashMap();
        map1.put("水果", "葡萄");
        map1.put("蔬菜", "萝卜");
        map1.put("动物", "大象");
        // 如果需要value找key
        for (Map.Entry entry : map1.entrySet()) {
             if(entry.getValue().equals("萝卜")){
                 System.out.println(entry.getKey());
             }
        }

        // 注意:value也要求唯一，除非使用forcePut覆盖
        BiMap<String, String> biMap = HashBiMap.create(map1);


//        Table: 双键的Map Map--> Table-->rowKey+columnKey+value  //和sql中的联合主键有点像，用于替代Map<K1,Map<K2,V>>
//        创建方式: Table<String, String, Integer> tables = HashBasedTable.create();

2.4 集合过滤

        List<Integer> immutableList = ImmutableList.of(1, 2, 3);
        Iterable<Integer> iterable = Iterables.filter(immutableList, Predicates.or(Predicates.equalTo(1), Predicates.equalTo(2)));

2.5 差集，交集和并集

      // 4.1 set的差集，交集和并集
        Set<Integer> set1 = Sets.newHashSet(1, 2, 3, 4);
        Set<Integer> set2 = Sets.newHashSet(4, 5);
        Sets.SetView union = Sets.union(set1, set2); //[1, 2, 3, 4, 5]
        Sets.SetView difference = Sets.difference(set1, set2);//[1, 2, 3]
        Sets.SetView intersection = Sets.intersection(set1, set2);//[4]

        // 4.2 map的差集，交集和并集
        HashMap<String, Integer> map1 = Maps.newHashMap();
        HashMap<String, Integer> map2 = Maps.newHashMap();

        map1.put("1", 1);map1.put("2", 2);map1.put("3", 3);
        map2.put("2", 20);map2.put("3", 3);map2.put("4", 4);

        MapDifference differenceMap = Maps.difference(map1, map2);
        Map entriesDiffering = differenceMap.entriesDiffering(); // 键相同但是值不同值映射项   {2=(2, 20)}
        Map entriesOnlyLeft = differenceMap.entriesOnlyOnLeft(); // 键只存在于左边Map的映射项 {1=1}
        Map entriesOnlyRight = differenceMap.entriesOnlyOnRight(); // 	键只存在于右边Map的映射项 {4=4}
        Map entriesInCommon = differenceMap.entriesInCommon(); // 	两个Map中都有的映射项 {3=3}

2.6 Iterables

        List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5, 1, 2, 3);
        List<Integer> list2 = Lists.newArrayList(6);
        Iterable<List<Integer>> partition = Iterables.partition(list1, 2); // 按指定大小分割 [[1, 2], [3, 4], [5, 1], [2, 3]]
        Iterable<Integer> concat = Iterables.concat(list1, list2); // 合并元素 [1, 2, 3, 4, 5, 1, 2, 3, 6]
        Iterable<Integer> limit = Iterables.limit(list1, 3); //  限制元素数量 [1, 2, 3]
        Iterable<Integer> skip = Iterables.skip(list1, 3); // 跳过部分元素 [4, 5, 1, 2, 3]
        Iterables.removeIf(list1, ele -> ele % 2 == 1); // 移除指定条件的元素 [2, 4, 2]