Guide de la table de goyave

1. Vue d'ensemble

Dans ce tutoriel, nous allons montrer comment utiliser l'interfaceTable de Google Guava et ses multiples implémentations.

LeTable de Guava est une collection qui représente un tableau comme une structure contenant des lignes, des colonnes et les valeurs de cellule associées. La rangée et la colonne agissent comme une paire de clés ordonnée.

**2. Table de Google Guava**

Voyons comment utiliser la classeTable.

2.1. Dépendance Maven

Commençons par ajouter la dépendance de la bibliothèque Guava de Google dans lespom.xml:


    com.google.guava
    guava
    21.0

La dernière version de la dépendance peut être vérifiéehere.

2.2. Sur

Si nous devions représenter lesTable de Guava en utilisant lesCollections présents dans le noyau Java, alors la structure serait une carte de lignes où chaque ligne contient une carte de colonnes avec les valeurs de cellule associées.

Table représente une carte spéciale où deux clés peuvent être spécifiées de manière combinée pour faire référence à une seule valeur.

Cela revient à créer une carte de cartes, par exemple,Map<UniversityName, Map<CoursesOffered, SeatAvailable>>. Table serait également un moyen parfait de représenter le plateau de jeu Battleships.

3. Créer

Vous pouvez créer une instance deTable de plusieurs manières:

En utilisant la méthodecreate de la classeHashBasedTable qui utiliseLinkedHashMap en interne:
```
Table universityCourseSeatTable
  = HashBasedTable.create();
```
Si nous avons besoin d'unTable dont les clés de ligne et les clés de colonne doivent être ordonnées par leur ordre naturel ou en fournissant des comparateurs, vous pouvez créer une instance deTable en utilisant la méthodecreate de une classe appeléeTreeBasedTable, qui utiliseTreeMap en interne:
```
Table universityCourseSeatTable
  = TreeBasedTable.create();
```

Si nous connaissons au préalable les clés de ligne et les clés de colonne et que la taille de la table est fixe, utilisez la méthodecreate de la classeArrayTable:

List universityRowTable
  = Lists.newArrayList("Mumbai", "Harvard");
List courseColumnTables
  = Lists.newArrayList("Chemical", "IT", "Electrical");
Table universityCourseSeatTable
  = ArrayTable.create(universityRowTable, courseColumnTables);

Si nous avons l'intention de créer une instance immuable deTable dont les données internes ne changeront jamais, utilisez la classeImmutableTable (création qui suit un modèle de générateur):
```
Table universityCourseSeatTable
  = ImmutableTable. builder()
  .put("Mumbai", "Chemical", 120).build();
```

4. En utilisant

Commençons par un exemple simple montrant l'utilisation deTable.

4.1. Récupération

Si nous connaissons la clé de ligne et la clé de colonne, nous pouvons obtenir la valeur associée à la ligne et à la clé de colonne:

@Test
public void givenTable_whenGet_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    int seatCount
      = universityCourseSeatTable.get("Mumbai", "IT");
    Integer seatCountForNoEntry
      = universityCourseSeatTable.get("Oxford", "IT");

    assertThat(seatCount).isEqualTo(60);
    assertThat(seatCountForNoEntry).isEqualTo(null);
}

4.2. Vérification d'une entrée

On peut vérifier la présence d'une entrée dans unTable en se basant sur:

Clé de rangée
Clé de colonne
Clé de ligne et clé de colonne
Valeur

Voyons comment vérifier la présence d'une entrée:

@Test
public void givenTable_whenContains_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    boolean entryIsPresent
      = universityCourseSeatTable.contains("Mumbai", "IT");
    boolean courseIsPresent
      = universityCourseSeatTable.containsColumn("IT");
    boolean universityIsPresent
      = universityCourseSeatTable.containsRow("Mumbai");
    boolean seatCountIsPresent
      = universityCourseSeatTable.containsValue(60);

    assertThat(entryIsPresent).isEqualTo(true);
    assertThat(courseIsPresent).isEqualTo(true);
    assertThat(universityIsPresent).isEqualTo(true);
    assertThat(seatCountIsPresent).isEqualTo(true);
}

4.3. Suppression

Nous pouvons supprimer une entrée desTable en fournissant à la fois la clé de ligne et la clé de colonne:

@Test
public void givenTable_whenRemove_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);

    int seatCount
      = universityCourseSeatTable.remove("Mumbai", "IT");

    assertThat(seatCount).isEqualTo(60);
    assertThat(universityCourseSeatTable.remove("Mumbai", "IT")).
      isEqualTo(null);
}

4.4. Clé de ligne vers la carte des valeurs de cellule

Nous pouvons obtenir une représentationMap avec la clé en tant que ligne et la valeur enCellValue en fournissant la clé de colonne:

@Test
public void givenTable_whenColumn_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    Map universitySeatMap
      = universityCourseSeatTable.column("IT");

    assertThat(universitySeatMap).hasSize(2);
    assertThat(universitySeatMap.get("Mumbai")).isEqualTo(60);
    assertThat(universitySeatMap.get("Harvard")).isEqualTo(120);
}

4.5. Représentation cartographique d'unTable

Nous pouvons obtenir une représentationMap<UniversityName, Map<CoursesOffered, SeatAvailable>> en utilisant la méthodecolumnMap:

@Test
public void givenTable_whenColumnMap_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    Map> courseKeyUniversitySeatMap
      = universityCourseSeatTable.columnMap();

    assertThat(courseKeyUniversitySeatMap).hasSize(3);
    assertThat(courseKeyUniversitySeatMap.get("IT")).hasSize(2);
    assertThat(courseKeyUniversitySeatMap.get("Electrical")).hasSize(1);
    assertThat(courseKeyUniversitySeatMap.get("Chemical")).hasSize(1);
}

4.6. Clé de colonne vers mappage de valeurs de cellule

Nous pouvons obtenir une représentationMap avec la clé comme colonne et la valeur commeCellValue en fournissant la clé de ligne:

@Test
public void givenTable_whenRow_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    Map courseSeatMap
      = universityCourseSeatTable.row("Mumbai");

    assertThat(courseSeatMap).hasSize(2);
    assertThat(courseSeatMap.get("IT")).isEqualTo(60);
    assertThat(courseSeatMap.get("Chemical")).isEqualTo(120);
}

4.7. Obtenir une clé de ligne distincte

Nous pouvons obtenir toutes les clés de ligne d'une table en utilisant la méthoderowKeySet:

@Test
public void givenTable_whenRowKeySet_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    Set universitySet = universityCourseSeatTable.rowKeySet();

    assertThat(universitySet).hasSize(2);
}

4.8. Obtenir une clé de colonne distincte

Nous pouvons obtenir toutes les clés de colonne d'une table en utilisant la méthodecolumnKeySet:

@Test
public void givenTable_whenColKeySet_returnsSuccessfully() {
    Table universityCourseSeatTable
      = HashBasedTable.create();
    universityCourseSeatTable.put("Mumbai", "Chemical", 120);
    universityCourseSeatTable.put("Mumbai", "IT", 60);
    universityCourseSeatTable.put("Harvard", "Electrical", 60);
    universityCourseSeatTable.put("Harvard", "IT", 120);

    Set courseSet = universityCourseSeatTable.columnKeySet();

    assertThat(courseSet).hasSize(3);
}

5. Conclusion

Dans ce tutoriel, nous avons illustré les méthodes de la classeTable de la bibliothèque Guava. La classeTable fournit une collection qui représente un tableau comme une structure contenant des lignes, des colonnes et des valeurs de cellule associées.

Le code appartenant aux exemples ci-dessus peut être trouvé dansthe GitHub project - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

TOC

Guide de la table de goyave