代码编织梦想

在Java开发中,我们经常使用Map数据结构来存储键值对,其中键是唯一的,可以快速查找到对应的值。但在某些场景下,我们可能需要一个更复杂的映射结构,其中键由两部分组成,类似于一个二维表格的行和列。Guava库中的Table接口正是为了满足这种需求而设计的。

提升编程效率的利器: 解析Google Guava库之集合篇Immutable(一)
提升编程效率的利器: 解析Google Guava库之集合篇Multimap(二)
提升编程效率的利器: 解析Google Guava库之集合篇BitMap(三)

一、什么是Guava Table?

Guava的Table是一种特殊的数据结构,它允许你使用两个键(通常被称为行键和列键)来映射一个值。你可以将Table视为一个二维的Map,其中每个单元格都由行键和列键唯一确定,并存储一个值。

二、Guava Table的实现类

Guava提供了几种Table的实现类,每种都有其特定的用途和性能特点:

  • HashBasedTable:这是最常用的实现,它基于哈希表来存储数据。HashBasedTable提供了快速的插入、查找和删除操作,并且不保证任何特定的键顺序。

  • TreeBasedTable:这个实现基于红黑树,它根据键的自然顺序或者提供的比较器对行键和列键进行排序。TreeBasedTable在按键顺序遍历数据时非常高效,但插入和查找操作可能比哈希表慢。

  • ImmutableTable:这是一个不可变的Table实现,它在创建时接收所有数据,并且之后不允许修改。ImmutableTable对于需要共享或发布不可变数据集的情况非常有用,同时它提供了高效的内存使用。

  • 除了上述标准实现外,你还可以通过实现Table接口来创建自定义的Table。这允许你根据特定需求定制存储和检索数据的方式。

三、如何使用Guava Table?

下面是一个Guava Table 使用示例,该示例将展示如何创建一个Table、向其添加数据、检索数据、修改数据、遍历数据,以及一些其他高级特性的使用。

import com.google.common.collect.HashBasedTable;  
import com.google.common.collect.Table;  
  
import java.util.Map;  
import java.util.Set;  
  
public class GuavaTableAdvancedExample {  
  
    public static void main(String[] args) {  
        // 创建一个Table实例  
        Table<String, String, Integer> workHoursTable = HashBasedTable.create();  
  
        // 添加数据  
        workHoursTable.put("Alice", "ProjectA", 40);  
        workHoursTable.put("Bob", "ProjectA", 30);  
        workHoursTable.put("Alice", "ProjectB", 20);  
        workHoursTable.put("Charlie", "ProjectC", 50);  
  
        // 检索数据  
        Integer aliceProjectAHours = workHoursTable.get("Alice", "ProjectA");  
        System.out.println("Alice worked " + aliceProjectAHours + " hours on ProjectA.");  
  
        // 使用row()方法获取特定行的映射  
        Map<String, Integer> aliceWorkHours = workHoursTable.row("Alice");  
        System.out.println("Alice's work hours: " + aliceWorkHours);  
  
        // 使用column()方法获取特定列的映射  
        Map<String, Integer> projectAWorkHours = workHoursTable.column("ProjectA");  
        System.out.println("Work hours on ProjectA: " + projectAWorkHours);  
  
        // 遍历表格  
        for (Table.Cell<String, String, Integer> cell : workHoursTable.cellSet()) {  
            System.out.println(cell.getRowKey() + " worked " + cell.getValue() + " hours on " + cell.getColumnKey() + ".");  
        }  
  
        // 修改数据  
        workHoursTable.put("Alice", "ProjectA", aliceProjectAHours + 5); // Alice在ProjectA上多工作了5小时  
        System.out.println("After update, Alice worked " + workHoursTable.get("Alice", "ProjectA") + " hours on ProjectA.");  
  
        // 检查是否包含某个键值对  
        boolean hasBobOnProjectB = workHoursTable.contains("Bob", "ProjectB");  
        System.out.println("Does Bob work on ProjectB? " + hasBobOnProjectB);  
  
        // 检查行键或列键是否存在  
        boolean hasRowKeyCharlie = workHoursTable.containsRow("Charlie");  
        boolean hasColumnKeyProjectD = workHoursTable.containsColumn("ProjectD");  
        System.out.println("Does the table have a row for Charlie? " + hasRowKeyCharlie);  
        System.out.println("Does the table have a column for ProjectD? " + hasColumnKeyProjectD);  
  
        // 获取所有的行键、列键或值  
        Set<String> allRowKeys = workHoursTable.rowKeySet();  
        Set<String> allColumnKeys = workHoursTable.columnKeySet();  
        Set<Integer> allValues = workHoursTable.values();  
  
        System.out.println("All row keys: " + allRowKeys);  
        System.out.println("All column keys: " + allColumnKeys);  
        System.out.println("All values: " + allValues);  
  
        // 移除数据  
        workHoursTable.remove("Alice", "ProjectB"); // Alice不再在ProjectB上工作  
        System.out.println("After removal, Alice's work hours on ProjectB: " + workHoursTable.get("Alice", "ProjectB"));  
    }  
}

在这个示例中,我们创建了一个HashBasedTable来存储员工在不同项目上的工作时间。我们展示了如何添加数据、检索特定员工在某个项目上的工作小时数、获取特定员工或特定项目的所有工作时间、遍历整个表格、修改数据、检查键的存在性、获取所有的键或值,以及移除数据。通过这个例子,你应该能够熟悉Guava Table的大部分常用方法。

如果你不使用table,那就需要用嵌套Map实现,代码可能就是下面这样

需要注意的是,与Guava Table相比,嵌套的Map在处理某些操作时可能会更加繁琐,例如检查列键是否存在,因为你需要遍历所有的内部Map。此外,嵌套的Map也没有Guava Table提供的一些高级功能和优化。

 // 创建一个嵌套的Map来模拟Table  
        Map<String, Map<String, Integer>> workHoursMap = new HashMap<>();  
  
        // 添加数据  
        addWorkHours(workHoursMap, "Alice", "ProjectA", 40);  
        addWorkHours(workHoursMap, "Bob", "ProjectA", 30);  
        addWorkHours(workHoursMap, "Alice", "ProjectB", 20);  
        addWorkHours(workHoursMap, "Charlie", "ProjectC", 50);  
  
        // 检索数据  
        Integer aliceProjectAHours = getWorkHours(workHoursMap, "Alice", "ProjectA");  
        System.out.println("Alice worked " + aliceProjectAHours + " hours on ProjectA.");  
  
        // 遍历嵌套Map  
        for (Map.Entry<String, Map<String, Integer>> entry : workHoursMap.entrySet()) {  
            String employee = entry.getKey();  
            Map<String, Integer> projects = entry.getValue();  
            for (Map.Entry<String, Integer> projectEntry : projects.entrySet()) {  
                String project = projectEntry.getKey();  
                Integer hours = projectEntry.getValue();  
                System.out.println(employee + " worked " + hours + " hours on " + project + ".");  
            }  
        }  
  
        // 修改数据  
        setWorkHours(workHoursMap, "Alice", "ProjectA", aliceProjectAHours + 5); // Alice在ProjectA上多工作了5小时  
        System.out.println("After update, Alice worked " + getWorkHours(workHoursMap, "Alice", "ProjectA") + " hours on ProjectA.");  
  
        // 检查是否包含某个键值对  
        boolean hasBobOnProjectB = containsWorkHours(workHoursMap, "Bob", "ProjectB");  
        System.out.println("Does Bob work on ProjectB? " + hasBobOnProjectB);  
  
        // 检查行键是否存在  
        boolean hasRowKeyCharlie = workHoursMap.containsKey("Charlie");  
        System.out.println("Does the nested map have an entry for Charlie? " + hasRowKeyCharlie);  
  
        // 检查列键是否存在(需要遍历所有内部Map)  
        boolean hasColumnKeyProjectD = false;  
        for (Map<String, Integer> projectMap : workHoursMap.values()) {  
            if (projectMap.containsKey("ProjectD")) {  
                hasColumnKeyProjectD = true;  
                break;  
            }  
        }  
        System.out.println("Does any employee work on ProjectD? " + hasColumnKeyProjectD);  
  
        // 移除数据  
        removeWorkHours(workHoursMap, "Alice", "ProjectB"); // Alice不再在ProjectB上工作  
        System.out.println("After removal, Alice's work hours on ProjectB: " + getWorkHours(workHoursMap, "Alice", "ProjectB"));  
    }  
  
    private static void addWorkHours(Map<String, Map<String, Integer>> workHoursMap, String rowKey, String columnKey, Integer value) {  
        workHoursMap.putIfAbsent(rowKey, new HashMap<>());  
        workHoursMap.get(rowKey).put(columnKey, value);  
    }  
  
    private static Integer getWorkHours(Map<String, Map<String, Integer>> workHoursMap, String rowKey, String columnKey) {  
        Map<String, Integer> projectMap = workHoursMap.get(rowKey);  
        return projectMap != null ? projectMap.get(columnKey) : null;  
    }  
  
    private static void setWorkHours(Map<String, Map<String, Integer>> workHoursMap, String rowKey, String columnKey, Integer value) {  
        workHoursMap.putIfAbsent(rowKey, new HashMap<>());  
        workHoursMap.get(rowKey).put(columnKey, value);  
    }  
  
    private static boolean containsWorkHours(Map<String, Map<String, Integer>> workHoursMap, String rowKey, String columnKey) {  
        Map<String, Integer> projectMap = workHoursMap.get(rowKey);  
        return projectMap != null && projectMap.containsKey(columnKey);  
    }  
  
    private static void removeWorkHours(Map<String, Map<String, Integer>> workHoursMap, String rowKey, String columnKey) {  
        Map<String, Integer> projectMap = workHoursMap.get(rowKey);  
        if (projectMap != null) {  
            projectMap.remove(columnKey);  
            if (projectMap.isEmpty()) {  
                workHoursMap.remove(rowKey);  
            }  
        }  
    }  

四、Guava Table的优势

使用Guava的Table而不是嵌套的Map有几个优势:

  • 类型安全:Table明确指定了行键、列键和值的类型,减少了类型转换的错误。
  • 更易用:Table提供了直观的API来插入、检索和遍历数据,使代码更易于阅读和维护。
  • 内存效率:Table实现类针对其特定用途进行了优化,以提供高效的内存使用。
  • 不变性:通过ImmutableTable,你可以创建不可变的表格,这对于并发编程和不可变对象模式非常有用。

五、总结

Guava的Table接口提供了一种强大且灵活的方式来处理需要使用两个键映射到一个值的情况。通过使用不同的实现类,你可以根据性能需求和特定场景选择最合适的Table。在需要处理二维数据或更复杂键结构的项目中,使用Guava的Table可以大大简化代码并提高开发效率。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_26664043/article/details/135902212

hashbasedtable-爱代码爱编程

OverviewPackageClassUseTreeDeprecatedIndexHelp Prev ClassNext Class FramesNo Frames All Classes Summary: Nested | Field | Constr | Method Detail: Fiel

guava类库学习--table(双键的map)-爱代码爱编程

Table是Guava提供的一个接口 Interface Table<R,C,V>,由rowKey+columnKey+value组成 它有两个键,一个值,和一个n行三列的数据表类似,n行取决于Table对对象

guava之table_qunimdejiangyou的博客-爱代码爱编程

在guava库中还提供了一种二维表结构:Table。使用Table可以实现二维矩阵的数据结构,可以是稀溜矩阵。通常来说,当你想使用多个键做索引的时候,你可能会用类似Map(FirstName, Map(LastName, P

guava table_陌上花开ft的博客-爱代码爱编程_guava table

1、guava的table类,可代替map<string,map<string,string>>,使用非常方便。 import com.google.common.collect.HashBased

hashbasedtable用法实例_꧁༺娛༒樂༻꧂的博客-爱代码爱编程_hashbasetable

import com.google.common.collect.HashBasedTable; import com.google.common.collect.Table; import java.util.Map; i

java hashbasedtable_Guava学习笔记:Guava新集合-Table等-爱代码爱编程

Table 当我们需要多个索引的数据结构的时候,通常情况下,我们只能用这种丑陋的Map>来实现。为此Guava提供了一个新的集合类型-Table集合类型,来支持这种数据结构的使用场景。Table支持“row”和“column”,而且提供多种视图。 @Testpublic voidTableTest(){ Table aTable =Hash

java hashbasedtable_实用的开源工具库Guava之Table-爱代码爱编程

Table接口 Table是Guava在jdk的基础上新增的一种新集合类型,是一个有序的键值对集合。可能通过行和列取出对应的值。而Table有可能是稀疏的,不是每个行列对都会有值。可以通过行(列)键值或取出一行(列)的数据,也可以同时使用,取出唯一的映射值。返回集合的方法是返回Tabale的中对象的引用,修改集合会修改表,修改表也会修改集合中的对象。

Google工具库guava中集合类型Table-爱代码爱编程

一、简介 Table:它具有两个key[行, 列],对应一个值 Table是Guava提供的一个接口 Interface Table<R,C,V> Table可以看成:Table<R,C,V> == Map<R,Map<C,V>> Table接口有以下实现: HashBasedTable:基于

guava类库——table详解_西凉的悲伤的博客-爱代码爱编程

目录 前言一、使用Guava二、Table的创建和介绍三、通过行和列来获取值四、通过行和列来删除值五、判断行、列、值是否存在六、Table的遍历七、Table转Map八、Table翻转行和列九、Table的行列值转为

guava提供的map扩展操作代码示例-爱代码爱编程

文章目录 HashBasedTable(双键Map)HashBiMap(双向查找Map)TreeRangeMap(范围Map) HashBasedTable(双键Map) 双键数据结构类型,底层由Linked