Guava

14
juin
2012

Un article de thierryler Comments

Commentaires fermés

Une des nouveautés les plus attendues de la version 12 de Guava est l’objet « FluentIterable » qui, comme son nom l’indique, offre les fonctionnalités de « Iterable » de manière fluide.

Prenons un exemple. Pour cela, je vais introduire l’objet « Dog », représentant un chien et ses attributs classiques : nom, date de naissance, poids, etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Dog {

private Integer id;
private String name;
private String fullName;
private Date birthday;
private String race;
private Boolean lof;
private Dog father;
private Dog mother;
private String color;
private Double weight;

public Dog(String name, String color, Double weight) {
this.name = name;
this.color = color;
this.weight = weight;
}
}

Classiquement, pour faire un « filtre » sur une liste de chiens, on doit écrire un code ressemblant au suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Test
public void testFiltreSimple() {

// Arrange
List<Dog> dogs = Lists.newArrayList(
new Dog("Milou", "Blanc", 10.5),
new Dog("Idefix", "Blanc", 5.4),
new Dog("Rintintin", "Noir et Blanc", 35.6),
new Dog("Lassie", "Noir et Marron", 32.4));

final int nombreChiensAvecBlanc = 3;

// Act
Predicate<Dog> whiteDogPredicate = new Predicate<Dog>() {
public boolean apply(Dog dog) {
return dog.getColor().contains("Blanc");
}
};

List<Dog> whiteDogs = Lists.newArrayList(Iterables.filter(dogs, whiteDogPredicate));

// Assert
Assert.assertEquals(nombreChiensAvecBlanc, whiteDogs.size());
}

Le soucis, c’est qu’on ne pouvait pas enchaîner les opérations avant cette nouvelle version. Très concrètement, voici ce qu’il fallait écrire pour avoir la liste des prénoms des chiens blancs :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

@Test
public void testFiltreTransform() {

// Arrange
List<Dog> dogs = Lists.newArrayList(
new Dog("Milou", "Blanc", 10.5),
new Dog("Idefix", "Blanc", 5.4),
new Dog("Rintintin", "Noir et Blanc", 35.6),
new Dog("Lassie", "Noir et Marron", 32.4));

final List<String> prenomsAttendus = Lists.newArrayList("Milou", "Idefix");

// Act
Predicate<Dog> whiteDogPredicate = new Predicate<Dog>() {
public boolean apply(Dog dog) {
return dog.getColor().contains("Blanc");
}
};

Function<Dog, String> dogToPrenomFunction = new Function<Dog, String>() {

public String apply(Dog dog) {
return dog.getName();
}
};

List<Dog> whiteDogs = Lists.newArrayList(Iterables.filter(dogs, whiteDogPredicate));
List<String> prenoms = Lists.newArrayList(Iterables.transform(whiteDogs, dogToPrenomFunction));

// Assert
Assert.assertTrue(prenoms.containsAll(prenomsAttendus));
}

A l’aide des FluentIterable, on peut enchaîner les opérations directement :

1
2
3
4
5
6
7
8
9
10
11
12

@Test
public void testFluent() {

...

List<String> prenoms = FluentIterable.from(dogs)
.filter(whiteDogPredicate)
.transform(dogToPrenomFunction)
.toImmutableList();

...
}

C’est franchement plus lisible.

Les commentaires sont fermés.

Connexion

Identifiez-vous

Créer un compte

Guava

Articles récents

Commentaires récents

Archives

Catégories

Méta

Identifiant
Mot de passe

Mot de passe oublié ?