TOC

Goyave - Ensembles

Goyave - Ensembles

1. Vue d'ensemble

Dans ce didacticiel, nous allons illustrer les méthodes les plus utiles pour utiliserleverage Guava to work with Java Sets.

Commençons très simplement etcreate a HashSet sans le nouvel opérateur, en utilisant Guava: 

Set aNewSet = Sets.newHashSet();

2. Union d'ensembles

Tout d'abord, voyons comment nous pouvonsdo a union operation over Sets - en utilisant l'API simpleSets.union(): 

@Test
public void whenCalculatingUnionOfSets_thenCorrect() {
    Set first = ImmutableSet.of('a', 'b', 'c');
    Set second = ImmutableSet.of('b', 'c', 'd');

    Set union = Sets.union(first, second);
    assertThat(union, containsInAnyOrder('a', 'b', 'c', 'd'));
}

3. Produit cartésien d'ensembles

Nous pouvons également obtenirthe product of two sets en utilisantSets.cartesianProduct() comme dans l'exemple suivant: 

@Test
public void whenCalculatingCartesianProductOfSets_thenCorrect() {
    Set first = ImmutableSet.of('a', 'b');
    Set second = ImmutableSet.of('c', 'd');
    Set> result =
      Sets.cartesianProduct(ImmutableList.of(first, second));

    Function, String> func =
      new Function, String>() {
        public String apply(List input) {
            return Joiner.on(" ").join(input);
        }
    };
    Iterable joined = Iterables.transform(result, func);
    assertThat(joined, containsInAnyOrder("a c", "a d", "b c", "b d"));
}

Notez que - pour pouvoir tester le résultat facilement, nous utilisons unFunction et unJoiner pour convertir la structure complexeSet<List<Character>> en unIterable<String> plus gérable.

4. IntersectionSets

Ensuite, voyons comment obtenirthe intersection between two sets - en utilisant l'APISets.intersection(): 

@Test
public void whenCalculatingSetIntersection_thenCorrect() {
    Set first = ImmutableSet.of('a', 'b', 'c');
    Set second = ImmutableSet.of('b', 'c', 'd');

    Set intersection = Sets.intersection(first, second);
    assertThat(intersection, containsInAnyOrder('b', 'c'));
}

5. Différence symétrique d'ensembles

Voyons maintenant la différence symétrique de deux ensembles - tous les éléments contenus dans l'ensemble 1 ou 2, mais pas dans les deux: 

@Test
public void whenCalculatingSetSymmetricDifference_thenCorrect() {
    Set first = ImmutableSet.of('a', 'b', 'c');
    Set second = ImmutableSet.of('b', 'c', 'd');

    Set intersection = Sets.symmetricDifference(first, second);
    assertThat(intersection, containsInAnyOrder('a', 'd'));
}

6. Power Set

Voyons maintenant comment calculer lesthe power set – the set of all possible subsets de cet ensemble.

Dans l'exemple suivant, nous utilisonsSets.powerSet() pour calculer le jeu de puissance d'un jeu de caractères donné: 

@Test
public void whenCalculatingPowerSet_thenCorrect() {
    Set chars = ImmutableSet.of('a', 'b');

    Set> result = Sets.powerSet(chars);

    Set empty =  ImmutableSet. builder().build();
    Set a = ImmutableSet.of('a');
    Set b = ImmutableSet.of('b');
    Set aB = ImmutableSet.of('a', 'b');

    assertThat(result, contains(empty, a, b, aB));
}

7. ContiguousSet

Ensuite - Jetons un œil à un ensemble trié de valeurs contiguës - lesContiguousSet.

Dans l'exemple suivant - nous obtenons un ensemble d'entiers [10, 11,…, 30] dans unContiguousSet: 

@Test
public void whenCreatingRangeOfIntegersSet_thenCreated() {
    int start = 10;
    int end = 30;
    ContiguousSet set = ContiguousSet.create(
      Range.closed(start, end), DiscreteDomain.integers());

    assertEquals(21, set.size());
    assertEquals(10, set.first().intValue());
    assertEquals(30, set.last().intValue());
}

Ce type de structure de données est bien sûr quelque chose que vous pouvez faire en Java simple avec unTreeSet - mais avecthe semantics of this specialized type of set are just much more nicer pour travailler si vous avez besoin que vos données soient représentées de cette façon.

8. RangeSet

Maintenant, jetons un œil àRangeSet. Nous pouvons utiliserRangeSet pour contenir des plages déconnectées et non vides.

Dans l'exemple suivant, lorsque vous démarrez avec 2 plages déconnectées, nous les connectons ensuite à une seule et grande plage: 

@Test
public void whenUsingRangeSet_thenCorrect() {
    RangeSet rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(1, 10));
    rangeSet.add(Range.closed(12, 15));

    assertEquals(2, rangeSet.asRanges().size());

    rangeSet.add(Range.closed(10, 12));
    assertTrue(rangeSet.encloses(Range.closed(1, 15)));
    assertEquals(1, rangeSet.asRanges().size());
}

Passons en revue cet exemple en détail: **

  • Premièrement - nous insérons les 2 plages déconnectées:[1, 10] et[12, 15]

  • Ensuite - nous ajoutons une troisième plage pour connecter les 2:[10, 12] existants

  • Enfin - nous vérifions que leRangeSet était assez intelligent pour voir que les 3 plages sont maintenant une grande plage, et les fusionnons ensemble dans:[1, 15]

9. MultiSet

Ensuite, voyons comment utiliserMultiset. Contrairement aux ensembles normaux,a Multiset does support adding duplicate elements – which it counts as occurrences.

Dans l'exemple suivant, nous suivons une logique simple à plusieurs ensembles: 

@Test
public void whenInsertDuplicatesInMultiSet_thenInserted() {
    Multiset names = HashMultiset.create();
    names.add("John");
    names.add("Adam", 3);
    names.add("John");

    assertEquals(2, names.count("John"));
    names.remove("John");
    assertEquals(1, names.count("John"));

    assertEquals(3, names.count("Adam"));
    names.remove("Adam", 2);
    assertEquals(1, names.count("Adam"));
}

10. Obtenir les N principaux éléments dans unMultiSet

Voyons maintenant un exemple plus complexe et plus utile d’utilisation d’unMultiSet. Nous obtiendrons les N éléments les plus fréquents de l'ensemble - en gros, les plus courants.

Dans l'exemple suivant - nous trions les éléments dans lesMultiset en utilisantMultisets.copyHighCountFirst(): 

@Test
public void whenGetTopOcurringElementsWithMultiSet_thenCorrect() {
    Multiset names = HashMultiset.create();
    names.add("John");
    names.add("Adam", 5);
    names.add("Jane");
    names.add("Tom", 2);

    Set sorted = Multisets.copyHighestCountFirst(names).elementSet();
    List sortedAsList = Lists.newArrayList(sorted);
    assertEquals("Adam", sortedAsList.get(0));
    assertEquals("Tom", sortedAsList.get(1));
}

11. Conclusion

Dans ce rapide tutoriel, nous avons discuté des cas d'utilisation les plus courants et les plus utiles deworking with Sets using the Guava library.

L'implémentation de tous ces exemples et extraits de codecan be found in my Guava github project - il s'agit d'un projet basé sur Eclipse, il devrait donc être facile à importer et à exécuter tel quel.

Related