Google Guava 实战之Map篇

本是古典何须时尚 2024-04-03 11:48 58阅读 0赞

#### 文章目录 ####

*  Google Guava 实战之Map篇
 *   *  一、导入依赖
     *  二、Map
     *   *  Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
         *  Maps.filterEntries():过滤map
         *  Maps.filterKeys():过滤key
         *  Maps.filterValues():过滤value
         *  Maps.uniqueIndex():根据属性值找对象
         *  Multimaps.index(): 根据属性值找对象
         *  Maps.immutableEntry():返回不可变的映射条目与指定的键和值
         *  Maps.subMap():返回的部分视图， map的键被包含range限制
         *  Maps.transformValues:返回一个map，其中每个值都通过函数进行转换

## Google Guava 实战之Map篇 ##

### 一、导入依赖 ###

<dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>27.0.1-jre</version>
            </dependency>

### 二、Map ###

#### Maps.difference(Map, Map)用来比较两个Map以获取所有不同点 ####

@Test
        public void test1(){
        
            Map<String, Object> map1 = new HashMap<>();
            map1.put("张三", 123);
            map1.put("李四", 457);
            map1.put("王五", 235);
            map1.put("马六", 752);
            map1.put("王八", 752);
    
            Map<String, Object> map2 = new HashMap<>();
            map2.put("张三", 345);
            map2.put("马六", 752);
            map2.put("田七", 125);
    
            /**
             * 1、difference
             * Maps.difference(Map, Map)用来比较两个Map以获取所有不同点。该方法返回MapDifference对象
             */
            MapDifference<String, Object> difference = Maps.difference(map1, map2);
            //是否有差异，返回boolean
            boolean areEqual = difference.areEqual();
            System.out.println("比较两个Map是否有差异:" + areEqual);
            //两个map的交集
            Map<String, Object> entriesInCommon = difference.entriesInCommon();
            System.out.println("两个map都有的部分（交集）===：" + entriesInCommon);
            //键相同但是值不同值映射项。返回的Map的值类型为MapDifference.ValueDifference，以表示左右两个不同的值
            Map<String, MapDifference.ValueDifference<Object>> entriesDiffering = difference.entriesDiffering();
            System.out.println("键相同但是值不同值映射项===：" + entriesDiffering);
            //键只存在于左边Map的映射项
            Map<String, Object> onlyOnLeft = difference.entriesOnlyOnLeft();
            System.out.println("键只存在于左边Map的映射项:" + onlyOnLeft);
            //键只存在于右边Map的映射项
            Map<String, Object> entriesOnlyOnRight = difference.entriesOnlyOnRight();
            System.out.println("键只存在于右边Map的映射项:" + entriesOnlyOnRight);
        }

> 输出结果

比较两个Map是否有差异:false
    两个map都有的部分（交集）===：{
        马六=752}
    键相同但是值不同值映射项===：{
        张三=(123, 345)}
    键只存在于左边Map的映射项:{
        李四=457, 王五=235, 王八=752}
    键只存在于右边Map的映射项:{
        田七=125}

#### Maps.filterEntries():过滤map ####

@Test
        public void test2(){
        
            Map<String, Object> map1 = new HashMap<>();
            map1.put("张三", 123);
            map1.put("李四", 457);
            map1.put("王五", 235);
            map1.put("马六", 752);
            map1.put("王八", 752);
    
            /**
             * 2.filterEntries
             * Maps.filterEntries():过滤map
             */
            Map<String, Object> filterEntries = Maps.filterEntries(map1, input -> {
        
                if (input.getValue().equals(123) && Objects.equals(input.getKey(), "张三")) {
        
                    return true;
                }
                return false;
            });
            System.out.println("过滤map=====filterEntries:" + filterEntries);
        }

> 输出结果

过滤map=====filterEntries:{
        张三=123}

#### Maps.filterKeys():过滤key ####

@Test
        public void test3(){
        
            Map<String, Object> map1 = new HashMap<>();
            map1.put("张三", 123);
            map1.put("李四", 457);
            map1.put("王五", 235);
            map1.put("马六", 752);
            map1.put("王八", 752);
    
            /**
             * 3.filterKeys
             * Maps.filterKeys():过滤key
             */
            Map<String, Object> filterKeysMap = Maps.filterKeys(map1, input -> input.equals("李四"));
            System.out.println("过滤key=====filterKeys:" + filterKeysMap);
        }

> 输出结果

过滤key=====filterKeys:{
        李四=457}

#### Maps.filterValues():过滤value ####

@Test
        public void test4(){
        
            Map<String, Object> map1 = new HashMap<>();
            map1.put("张三", 123);
            map1.put("李四", 457);
            map1.put("王五", 235);
            map1.put("马六", 752);
            map1.put("王八", 752);
    
            /**
             *4.filterValues
             * Maps.filterValues():过滤value
             */
            Map<String, Object> filterValuesMap = Maps.filterValues(map1, input -> Objects.equals(752, input));
            System.out.println("过滤value=====filterValues:" + filterValuesMap);
        }

> 输出结果

过滤value=====filterValues:{
        马六=752, 王八=752}

#### Maps.uniqueIndex():根据属性值找对象 ####

@Test
        public void test4(){
        
            /**
             * 5.uniqueIndex
             * Maps.uniqueIndex():根据属性值找对象
             * 有一组对象，它们在某个属性上分别有独一无二的值，而我们希望能够按照这个属性值查找对象
             * 注：Maps.uniqueIndex():必须属性值唯一
             *否则报错：Exception in thread "main" java.lang.IllegalArgumentException: Multiple entries with same key:xxxxx. To index multiple values under a key, use Multimaps.index.
             */
            List<User> users = new ArrayList<>();
            users.add(new User("zhangsan", 24));
            users.add(new User("lisi", 27));
            users.add(new User("wangwu", 28));
    //        users.add(new User("wangwu",30));
            ImmutableMap<Object, User> uniqueIndex = Maps.uniqueIndex(users, new Function<User, Object>() {
        
                @Nullable
                @Override
                public Object apply(@Nullable User user) {
        
                    return user.getUserName();
                }
            });
            System.out.println("Maps.uniqueIndex()===========uniqueIndex:" + uniqueIndex);
        }
    
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class User{
        
            private String userName;
            private Integer age;
        }

> 输出结果

Maps.uniqueIndex()===========uniqueIndex:{
        zhangsan=MapTest.User(userName=zhangsan, age=24), lisi=MapTest.User(userName=lisi, age=27), wangwu=MapTest.User(userName=wangwu, age=28)}

#### Multimaps.index(): 根据属性值找对象 ####

@Test
        public void test4(){
        
    
            List<User> users = new ArrayList<>();
            users.add(new User("zhangsan", 24));
            users.add(new User("lisi", 27));
            users.add(new User("wangwu", 28));
            users.add(new User("wangwu", 30));
            users.add(new User("lisi", 23));
    
            /**
             * 6.index
             * Multimaps.index(): 根据属性值找对象
             * 如果您的索引可能将多个值与每个键相关联
             */
            ImmutableListMultimap<Object, User> multimap = Multimaps.index(users, new Function<User, Object>() {
        
                @Nullable
                @Override
                public Object apply(@Nullable User user) {
        
                    return user.getUserName();
                }
            });
            System.out.println("Multimaps.index()=========multimap:" + multimap);
        }

> 输出结果

Multimaps.index()=========multimap:{
        zhangsan=[MapTest.User(userName=zhangsan, age=24)], lisi=[MapTest.User(userName=lisi, age=27), MapTest.User(userName=lisi, age=23)], wangwu=[MapTest.User(userName=wangwu, age=28), MapTest.User(userName=wangwu, age=30)]}

#### Maps.immutableEntry():返回不可变的映射条目与指定的键和值 ####

@Test
        public void test4(){
        
            /**
             * 7.immutableEntry
             * Maps.immutableEntry():返回不可变的映射条目与指定的键和值
             */
            Map.Entry<String, Integer> immutableEntry = Maps.immutableEntry("李四", 457);
            System.out.println("Maps.immutableEntry:===============immutableEntry:" + immutableEntry);
    
    
        }

> 输出结果

Maps.immutableEntry:===============immutableEntry:李四=457

#### Maps.subMap():返回的部分视图， map的键被包含range限制 ####

@Test
        public void test4(){
        
            /**
             * 8.subMap
             * Maps.subMap():返回的部分视图， map的键被包含range限制
             */
            TreeMap<Integer, String> TreeMap = Maps.newTreeMap();
            TreeMap.put(1, "aaa");
            TreeMap.put(4, "bbb");
            TreeMap.put(2, "ccc");
            TreeMap.put(6, "ddd");
            //返回包含严格大于所有值的范围lower ，比严格小于uppe
            Range<Integer> range = Range.open(0, 3);
            NavigableMap<Integer, String> navigableMap = Maps.subMap(TreeMap, range);
            System.out.println("Maps.subMap()=================navigableMap:" + navigableMap);
    
        }

> 输出结果

Maps.subMap()=================navigableMap:{
        1=aaa, 2=ccc}

#### Maps.transformValues:返回一个map，其中每个值都通过函数进行转换 ####

@Test
    	public void test4(){
        
    
            Map<String, Object> map1 = new HashMap<>();
            map1.put("张三", 123);
            map1.put("李四", 457);
            map1.put("王五", 235);
            map1.put("马六", 752);
            map1.put("王八", 752);
    
            /**
             * 9.transformValues
             * Maps.transformValues:返回一个map，其中每个值都通过函数进行转换。
             */
            Map<String, Object> transformValues = Maps.transformValues(map1, new Function<Object, Object>() {
        
                @Nullable
                @Override
                public Object apply(@Nullable Object input) {
        
                    Integer value = Integer.valueOf(input.toString());
                    return value / 2;
                }
            });
            System.out.println("Maps.transformValues===============transformValues:" + transformValues);
    
        }

> 输出结果

Maps.transformValues===============transformValues:{
        李四=228, 张三=61, 马六=376, 王五=117, 王八=376}