Relax Box

外观

Guava - Map增强工具类

约 2717 字大约 9 分钟

2026-05-25

日常开发中使用Map时经常会遇到很多复杂的处理场景，例如：多个键的Map、不仅可以根据键获取值也可以根据值获取键且不用遍历、重复键的Map、数字等范围内映射相同的值、内存中缓存对象等，Guava提供了以上场景的解决方案。

实现

根据不同的场景，使用不用的解决方案

场景解决方案具体实现
多个键的MapTableHashBasedTable、TreeBasedTable、ImmutableTable
不仅可以根据键获取值也可以根据值获取键且不用遍历BiMapHashBiMap、ImmutableBiMap
重复键的MapMultimapArrayListMultimap、LinkedListMultimap、LinkedHashMultimap、ImmutableListMultimap、ImmutableSetMultimap
数字等范围内映射相同的值RangeMapTreeRangeMap、ImmutableRangeMap
内存中缓存对象ClassToInstanceMapMutableClassToInstanceMap、ImmutableClassToInstanceMap

依赖

截止到今年最新的依赖包版本是 33.4.6-jre，很多人不知道如何找maven依赖，提供个官方仓库地址 https://mvnrepository.com/

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.4.6-jre</version>
</dependency>

示例

以下为具体使用的 Demo

Table

官方注释翻译：将一对有序键（称为行键和列键）与单个值相关联的集合。

// HashMap
Map<String, Integer> deptMap = new HashMap<>();
deptMap.put("A部门", 10);
deptMap.put("B部门", 20);
Map<String, Map<String, Integer>> companyMap = new HashMap<>();
companyMap.put("xx公司", deptMap);
// HashMap 获取值
Integer val = companyMap.get("xx公司").get("A部门");
System.out.println("HashMap 获取值: " + val);

// 创建Hash类型Table, 基于Hash表实现
// Table<R, C, V>中三个泛型: R-行, C-列, V-值
Table<String, String, Integer> hashTable = HashBasedTable.create();
hashTable.put("xx公司", "A部门", 10);
hashTable.put("xx公司", "B部门", 20);
hashTable.put("xx公司", "C部门", 30);

System.out.println("\nHash Table: " + hashTable);

// 创建Tree类型Table, 基于红黑树实现
Table<String, String, Integer> treeTable = TreeBasedTable.create();
treeTable.put("xx公司", "C部门", 30);
treeTable.put("xx公司", "B部门", 20);
treeTable.put("xx公司", "A部门", 10);

System.out.println("\nTree Table: " + treeTable);

// 创建不可变Table, 无法新增、更新或删除
Table<String, String, Integer> immutableTable = ImmutableTable.<String, String, Integer>builder()
        .put("xx公司", "C部门", 30)
        .put("xx公司", "B部门", 20)
        .put("xx公司", "A部门", 10)
        .build();

System.out.println("\nImmutable Table: " + immutableTable);

// Table 获取值
Integer val2 = hashTable.get("xx公司", "A部门");
System.out.println("\nTable 获取值: " + val2);

// Table 删除值
Integer remove = hashTable.remove("xx公司", "C部门");
System.out.println("\nTable 删除值: " + remove);

// 根据行获取列和值映射
Map<String, Integer> columnvalueMap = hashTable.row("xx公司");
System.out.println("\nTable 列和值 映射: " + columnvalueMap);

// 根据列获取行和值映射
Map<String, Integer> rowvalueMap = hashTable.column("A部门");
System.out.println("\nTable 行和值 映射: " + rowvalueMap);

// 获取key集合
Set<String> rowKeySet = hashTable.rowKeySet();
System.out.println("\nTable Row key 集合: " + rowKeySet);
Set<String> columnKeySet = hashTable.columnKeySet();
System.out.println("\nTable Column key 集合: " + columnKeySet);

// 获取值集合
Collection<Integer> values = hashTable.values();
System.out.println("\nTable 值集合: " + values);

// 判断包含行
boolean containsRow = hashTable.containsRow("xx公司");
System.out.println("\nTable 包含行: " + containsRow);

// 判断包含列
boolean containsColumn = hashTable.containsColumn("A部门");
System.out.println("\nTable 包含列: " + containsColumn);

// 判断包含行和列
boolean contains = hashTable.contains("xx公司", "A部门");
System.out.println("\nTable 包含行和列: " + contains);

// 判断包含值
boolean containsValue = hashTable.containsValue(10);
System.out.println("\nTable 包含值: " + containsValue);

// 行和列转置 - 行 转 列
Table<String, String, Integer> transposeTable = Tables.transpose(hashTable);

// 获取所有的行
Set<Table.Cell<String, String, Integer>> cells = transposeTable.cellSet();

// 遍历输出
System.out.println("\n遍历输出开始----------------------------");
cells.forEach(cell -> System.out.println(cell.getRowKey() + ", " + cell.getColumnKey() + ", " + cell.getValue()));
System.out.println("\n遍历输出结束----------------------------");

// 转换为嵌套的Map
Map<String, Map<String, Integer>> rowMap = hashTable.rowMap();
System.out.println("\nTable RowMap: " + rowMap);
Map<String, Map<String, Integer>> columnMap = hashTable.columnMap();
System.out.println("\nTable ColumnMap: " + columnMap);

输出结果

image.png

BiMap

双映射（或“双向映射”）是一种保留其值及其键的唯一性的映射。此约束使双映射能够支持“反向视图”，即另一个双映射，其中包含与此双映射相同的条目，但具有相反的键和值。

//创建BiMap, 底层为两个Hash表的Map
BiMap<Integer, String> biMap = HashBiMap.create();
biMap.put(1, "one");
biMap.put(2, "two");
biMap.put(3, "three");
biMap.put(4, "four");
biMap.put(5, "five");

System.out.println("BiMap: " + biMap);

//创建不可变BiMap, 无法新增、更新或删除
BiMap<Object, Object> immutableBiMap = ImmutableBiMap.builder().put(1, "one").put(2, "two").put(3, "three").put(4, "four").put(5, "five").build();

System.out.println("\nImmutable BiMap: " + immutableBiMap);

//通过key获取value
String value = biMap.get(1);
System.out.println("\nBiMap 根据key获取value: " + value);

Integer key = biMap.inverse().get("one");
System.out.println("\nBiMap 根据value获取key: " + key);

//翻转后修改
biMap.inverse().put("six", 6);
//返回双映射的逆视图, 并没有创建新对象, 还是之前的对象, 所以操作翻转后的BiMap会影响之前的BiMap
System.out.println("\nBiMap 被影响: " + biMap);

//底层是HashMap, key不可重复
//value不可重复
try {
    biMap.put(11, "one");
} catch (Exception e) {
    System.err.println("BiMap 替换value异常: " + e.getMessage());
}

//翻转后key不能重复
try {
    biMap.inverse().put("first", 1);
} catch (Exception e) {
    System.err.println("BiMap 替换key异常: " + e.getMessage());
}

//key和value可为null
biMap.put(null, null);
System.out.println("\nBiMap 根据Null key获取Null value: " + biMap.get(null));
System.out.println("\nBiMap 根据Null value获取Null key: " + biMap.inverse().get(null));

//强制替换key
biMap.forcePut(11, "one");
System.out.println("\nBiMap 获取新key: " + biMap.inverse().get("one"));

//values为Set集合
Set<String> values = biMap.values();
System.out.println("\nBiMap 不重复的value: " + values);

输出结果

image.png

Multimap

将键映射到值的集合，类似于 Map，但其中每个键可能与多个值相关联。

// 创建Multimap, key为HashMap, value为ArrayList
Multimap<String, Integer> arrayListMultimap = ArrayListMultimap.create();
arrayListMultimap.put("张三", 90);
arrayListMultimap.put("张三", 80);
arrayListMultimap.put("张三", 100);
arrayListMultimap.put("李四", 88);

System.out.println("Multimap key为HashMap, value为ArrayList: " + arrayListMultimap);

// 创建Multimap, key为HashMap, value为HashSet
Multimap<String, Integer> hashMultimap = HashMultimap.create();
hashMultimap.put("张三", 90);
hashMultimap.put("张三", 80);
hashMultimap.put("张三", 100);
hashMultimap.put("李四", 88);

System.out.println("Multimap key为HashMap, value为HashSet: " + hashMultimap);

// 创建Multimap, key为LinkedHashMap, value为LinkedList
Multimap<String, Integer> linkedListMultimap = LinkedListMultimap.create();
linkedListMultimap.put("张三", 90);
linkedListMultimap.put("张三", 80);
linkedListMultimap.put("张三", 100);
linkedListMultimap.put("李四", 88);

System.out.println("Multimap key为LinkedHashMap, value为LinkedList: " + linkedListMultimap);

// 创建Multimap, key为LinkedHashMap, value为LinkedHashMap
Multimap<String, Integer> linkedHashMultimap = LinkedHashMultimap.create();
linkedHashMultimap.put("张三", 90);
linkedHashMultimap.put("张三", 80);
linkedHashMultimap.put("张三", 100);
linkedHashMultimap.put("李四", 88);

System.out.println("Multimap key为LinkedHashMap, value为LinkedHashMap: " + linkedHashMultimap);

// 创建Multimap, key为TreeMap, value为TreeSet
Multimap<String, Integer> treeMultimap = TreeMultimap.create();
treeMultimap.put("张三", 90);
treeMultimap.put("张三", 80);
treeMultimap.put("张三", 100);
treeMultimap.put("李四", 88);

System.out.println("Multimap key为TreeMap, value为TreeSet: " + treeMultimap);

// 创建不可变Multimap, 无法新增、更新或删除, key为ImmutableMap, value为ImmutableList
Multimap<String, Integer> immutableListMultimap = ImmutableListMultimap.<String, Integer>builder()
        .put("张三", 90)
        .put("张三", 80)
        .put("张三", 100)
        .put("李四", 88)
        .build();

System.out.println("Multimap key为ImmutableMap, value为ImmutableList: " + immutableListMultimap);

// 创建不可变Multimap, 无法新增、更新或删除, key为ImmutableMap, value为ImmutableSet
Multimap<String, Integer> immutableSetMultimap = ImmutableSetMultimap.<String, Integer>builder()
        .put("张三", 90)
        .put("张三", 80)
        .put("张三", 100)
        .put("李四", 88)
        .build();

System.out.println("Multimap key为ImmutableMap, value为ImmutableSet: " + immutableSetMultimap);

// 获取值
Collection<Integer> values = arrayListMultimap.get("张三");
System.out.println("Multimap 获取值集合: " + values);

// 获取不存在key的值, 返回的是空集合, 而不是null
Collection<Integer> valuesByNotExistsKey = arrayListMultimap.get("王五");
System.out.println("Multimap 获取不存在的Key值集合: " + valuesByNotExistsKey);

// 获取值集合添加值
// 返回的是多重映射中关联的值的视图集合, 并没有创建新对象, 还是之前的对象, 所以操作值集合会影响之前的Multimap
values.add(60);
System.out.println("Multimap 被影响: " + arrayListMultimap);

// 获取大小
System.out.println("Multimap 大小:" + arrayListMultimap.size());

// 判断是否为空
System.out.println("Multimap 是否为空: " + arrayListMultimap.isEmpty());

// 包含key
System.out.println("Multimap 包含key: " + arrayListMultimap.containsKey("张三"));

// 包含value
System.out.println("Multimap 包含value: " + arrayListMultimap.containsValue(60));

// 包含key-value键值对
System.out.println("Multimap 包含key-value对: " + arrayListMultimap.containsEntry("张三", 60));

// 替换value
arrayListMultimap.replaceValues("张三", Arrays.asList(10, 20, 30));
System.out.println("Multimap 替换value: " + arrayListMultimap);

// 根据key-value删除
arrayListMultimap.remove("张三", 10);
System.out.println("Multimap 根据key-value删除: " + arrayListMultimap);

// 根据key删除
Collection<Integer> removeAll = arrayListMultimap.removeAll("张三");
System.out.println("Multimap 根据key删除: " + removeAll);

// 获取key集合
Set<String> keySet = arrayListMultimap.keySet();
System.out.println("Multimap 获取key集合(HashSet): " + keySet);
Multiset<String> keys = arrayListMultimap.keys();
System.out.println("Multimap 获取key集合(MultiSet): " + keys);

// 获取所有的key-value
Collection<Map.Entry<String, Integer>> entries = arrayListMultimap.entries();
System.out.println("遍历key-value开始--------------------------");
entries.forEach(entry -> System.out.println(entry.getKey() + " : " + entry.getValue()));
System.out.println("遍历key-value结束--------------------------");

// 转换为Map<K, Collection<V>>
Map<String, Collection<Integer>> collectionMap = arrayListMultimap.asMap();
System.out.println("Multimap 转换为Map<K, Collection<V>>: " + collectionMap);

输出结果

image.png

RangeMap

从不相交的非空范围到非 null 值的映射。查询查找与包含指定键的范围（如果有）关联的值。

// if-else
int score = 88;
String rank;
if (0 <= score && score < 60) {
    rank = "不及格";
} else if (60 <= score && score <= 84) {
    rank = "及格";
} else if (84 < score && score <= 100) {
    rank = "优秀";
} else {
    rank = "无效";
}

System.out.println("if-else 获取值: " + rank);

// 创建RangeMap, 基于TreeMap（红黑树）实现
RangeMap<Integer, String> treeRangeMap = TreeRangeMap.create();
treeRangeMap.put(Range.closedOpen(0, 60), "不及格");
treeRangeMap.put(Range.closed(60, 84), "及格");
treeRangeMap.put(Range.openClosed(84, 100), "优秀");
treeRangeMap.put(Range.lessThan(0), "无效");
treeRangeMap.put(Range.greaterThan(100), "无效");

rank = treeRangeMap.get(score);
System.out.println("RangeMap 获取值: " + rank);

// 创建不可变RangeMap, 无法新增、更新或删除
ImmutableRangeMap<Integer, String> immutableRangeMap = ImmutableRangeMap.<Integer, String>builder()
        .put(Range.closedOpen(0, 60), "不及格")
        .put(Range.closed(60, 84), "及格")
        .put(Range.openClosed(84, 100), "优秀")
        .put(Range.lessThan(0), "无效")
        .put(Range.greaterThan(100), "无效")
        .build();

rank = immutableRangeMap.get(score);
System.out.println("ImmutableRangeMap 获取值: " + rank);

// 获取key-value对
Map.Entry<Range<Integer>, String> entry = treeRangeMap.getEntry(88);
System.out.println("RangeMap 获取key-value对: " + entry.getKey() + " : " + entry.getValue());

// 返回不可变的升序的Map
Map<Range<Integer>, String> asMapOfRanges = treeRangeMap.asMapOfRanges();
System.out.println("RangeMap 不可变的升序的Map: " + asMapOfRanges);

// 返回不可变的降序的Map
Map<Range<Integer>, String> asDescendingMapOfRanges = treeRangeMap.asDescendingMapOfRanges();
System.out.println("RangeMap 不可变的降序的Map: " + asDescendingMapOfRanges);

// 相连范围合并
RangeMap<Integer, String> treeRangeMap2 = TreeRangeMap.create();
treeRangeMap2.putCoalescing(Range.closedOpen(0, 60), "不及格");
treeRangeMap2.putCoalescing(Range.closed(60, 84), "及格");
treeRangeMap2.putCoalescing(Range.openClosed(84, 100), "及格"); // 或者 [60..84]范围合并
treeRangeMap2.putCoalescing(Range.lessThan(0), "无效");
treeRangeMap2.putCoalescing(Range.greaterThan(100), "无效");
System.out.println("RangeMap 不合并相连范围: " + treeRangeMap.asMapOfRanges());
System.out.println("RangeMap 合并相连范围: " + treeRangeMap2.asMapOfRanges());

// 最小范围
Range<Integer> span = treeRangeMap.span();
System.out.println("RangeMap 最小范围: " + span);

// 子范围Map
RangeMap<Integer, String> subRangeMap = treeRangeMap.subRangeMap(Range.closed(70, 90));
System.out.println("RangeMap 子范围Map: " + subRangeMap);

// 合并范围
treeRangeMap.merge(Range.closed(60, 100), "及格", (s, s2) -> s2);
System.out.println("RangeMap 合并Map: " + treeRangeMap);

// 移除范围
treeRangeMap.remove(Range.open(90, 95));
System.out.println("RangeMap 移除范围: " + treeRangeMap);

// 清除所有范围
treeRangeMap.clear();
System.out.println("RangeMap 清除所有范围: " + treeRangeMap);

输出结果

image.png

ClassToInstanceMap

映射，其每个条目将一个 Java 原始类型 映射到该类型的实例。除了实现 Map之外，还提供额外的类型安全操作 putInstance 和 getInstance 。与任何其他 Map<Class, Object>映射一样，此映射可能包含基元类型的条目，并且基元类型及其相应的包装器类型可以映射到不同的值。

static class UserBean {
    private final Integer id;
    private final String username;

    public UserBean(Integer id, String username) {
        this.id = id;
        this.username = username;
    }

    @Override
    public String toString() {
        return "UserBean{" + "id=" + id + ", username='" + username + '\'' + '}';
    }
}
public static void main(String[] args) {
    // 创建Bean
    UserBean userBean = new UserBean(1, "张三");

    // HashMap
    HashMap<Class, Object> hashMap = new HashMap<>();
    hashMap.put(UserBean.class, userBean);

    // 获取值，需要强转
    UserBean value = (UserBean) hashMap.get(UserBean.class);
    System.out.println("HashMap 获取对象实例: " + value);
    System.out.println("HashMap 获取对象实例等于创建的Bean: " + (value == userBean));

    // 创建ClassToInstanceMap
    ClassToInstanceMap<Object> classToInstanceMap = MutableClassToInstanceMap.create();
    classToInstanceMap.putInstance(UserBean.class, userBean);

    // 获取值，无需强转
    UserBean value2 = classToInstanceMap.getInstance(UserBean.class);
    System.out.println("\nClassToInstanceMap 获取对象实例: " + value2);
    System.out.println("ClassToInstanceMap 获取对象实例等于创建的Bean: " + (value2 == userBean));

    // 创建不可变ClassToInstanceMap, 无法新增、更新或删除
    ClassToInstanceMap<UserBean> immutableClassToInstanceMap = ImmutableClassToInstanceMap.<UserBean>builder()
        .put(UserBean.class, userBean)
        .build();

    // 获取值，无需强转
    UserBean value3 = immutableClassToInstanceMap.getInstance(UserBean.class);
    System.out.println("\nImmutableClassToInstanceMap 获取对象实例: " + value3);
    System.out.println("ImmutableClassToInstanceMap 获取对象实例等于创建的Bean: " + (value3 == userBean));


    // 限制类型，避免使用HashMap存储对象时，因为使用Object值类型而在添加缓存时需要今天类型校验
    ClassToInstanceMap<Collection> classToInstanceMap1 = MutableClassToInstanceMap.create();
    classToInstanceMap1.put(ArrayList.class, new ArrayList());
    classToInstanceMap1.put(HashSet.class, new HashSet());
    // 编译保存: 'put(java.lang.Class<? extends java.util.@org.checkerframework.checker.nullness.qual.NonNull Collection>, java.util.Collection)' in 'com.google.common.collect.MutableClassToInstanceMap' cannot be applied to '(java.lang.Class<java.util.HashMap>, java.util.HashMap)'
    //        classToInstanceMap1.put(HashMap.class, new HashMap());
}

输出结果

image.png

版权归属：今朝· Liushigong · Relax Box

许可证：署名-非商业性 4.0 国际 (CC-BY-NC-4.0)

「放轻松，慢慢来」盒子 — 记录日常思考、学习笔记与技术总结
Copyright © 2023 - 2026 今朝（Liushigong） | 京ICP备20031061号