I. Introduction▲
Sans conteste la meilleure manière de découvrir une bibliothèque est de parcourir chacune de ses méthodes et de les implémenter les unes après les autres pour comprendre les subtilités de chacune.
Ce tutoriel sur l’exploration de la bibliothèque Guava de Google reprends l’ensemble des méthodes statiques composant la classe utilitaire ImmutableList.
II. Ajouter Google Guava à votre projet (Rappel)▲
La bibliothèque Google Guava peut être ajoutée de plusieurs façons dans un projet. La façon la plus triviale est de récupérer le .jar depuis le site de Google, puis de placer ce dernier directement dans la bibliothèque de votre projet.
Une autre façon plus élégante est d’utiliser un outil industrialisé de build comme Apache Maven ou Gradle en y ajoutant la dépendance requise de Google Guava.
2.
3.
4.
5.
6.
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version>
</dependency>
III. La classe utilitaire ImmutableList▲
Force est de constater que tout développeur familier avec le langage Java connaît l’utilité pratique des objets immuables, c’est-à-dire des objets dont l’état ne peut plus être modifié une fois ces derniers instanciés.
Google Guava permet de créer des structures de données de type List à l’instar du type analogue du JDK de Oracle… mais immuables celles-ci.
Les objets immuables possèdent de nombreux avantages par exemple le fait de pouvoir les utiliser comme constantes, voire comme clé des tables de hachage pour sécuriser l’accès aux valeurs ou lors d’accès concurrentiels aux données dans un environnement parallèle.
La classe com.google.common.collect.ImmutableLists contient des méthodes statiques utilitaires permettant de créer des instances immuables de l'interface List du JDK.
Mieux qu’un long discours dans le chapitre suivant, nous mettrons en œuvre la richesse de cette bibliothèque à travers un cas pratique de gestion d’un parc automobile.
IV. Implémentation des méthodes de la classe ImmutableList▲
IV-A. Les imports▲
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.google.common.collect.UnmodifiableIterator;
import com.google.common.collect.UnmodifiableListIterator;
import static java.lang.System.out;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Supplier;
IV-A-1. Les attributs et blocs statiques▲
Créons une classe Application qui contiendra les attributs, les blocs et les méthodes statiques pour la gestion de notre parc automobile.
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.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
public final class Application {
private final static int NB_VEHICULES = 3;
private final static int NB_MARQUES_VEHICULES = 5;
private final static String[] citroen;
private final static String[] opel;
private final static String[] peugeot;
private final static String[] renault;
private final static String[] toyota;
private final static List<Float> consommations;
private final static List<Double> jantes;
static { // les marques des véhicules
peugeot = new String[NB_VEHICULES];
peugeot[0] = "Peugeot Nouvelle SUV 3008";
peugeot[1] = "Peugeot Nouvelle SUV 5008";
peugeot[2] = "Peugeot Traveller/Expert Combi";
toyota = new String[NB_VEHICULES];
toyota[0] = "Toyota Auris";
toyota[1] = "Toyota Nouvelle Yaris";
toyota[2] = "Toyota Aygo X ";
opel = new String[NB_VEHICULES];
opel[0] = "Opel Calibra";
opel[1] = "Opel Ascona";
opel[2] = "Opel Corsa";
renault = new String[NB_VEHICULES];
renault[0] = "Renault Kangoo VP";
renault[1] = "Renault Nouveau Grand Scenic";
renault[2] = "Renault Alaskan";
citroen = new String[NB_VEHICULES];
citroen[0] = "Citroen Nouvelle C-Elysée";
citroen[1] = "Citroen Nemo Multispace";
citroen[2] = "Citroen C4 Aircross";
}
static { // la consommation du litre/100km, on voit qu'elle est très élevée.
consommations = new ArrayList<>();
consommations.add(4.3f);
consommations.add(5.8f);
consommations.add(6.9f);
consommations.add(7.4f);
consommations.add(8.5f);
consommations.add(9.2f);
}
static { // la taille des jantes des véhicules
jantes = new LinkedList<>();
jantes.add(7.5);
jantes.add(8.0);
jantes.add(8.5);
jantes.add(9.0);
jantes.add(9.5);
jantes.add(10.0);
jantes.add(10.5);
}
// une liste immuable contenant tous nos véhicules ...
final static ImmutableList<String> VEHICULES
= new ImmutableList.Builder<String>()
.add(citroen)
.add(opel)
.add(peugeot) // add(E... elements)
.add(renault)
.add(toyota)
.build();
// ... une autre contenant les carburants disponibles
final static ImmutableList<String> CARBURANTS
= new ImmutableList.Builder<String>()
.add("Essence") // add(E element)
.add("Diesel")
.add("GNV")
.add("Hybride")
.add("Biodiesel")
.add("Electric")
.add("Essence")
.add("Essence Sans Plomb 95")
.add("Essence Sans Plomb 98")
.build();
final static Collection<String> collectionVehicules = new ArrayList<>(NB_MARQUES_VEHICULES);
public static void main(String[] args) {
// commençons par afficher la liste des véhicules de la marque Peugeot
out.println(Arrays.asList(peugeot)); // [Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Peugeot Traveller/Expert Combi, Peugeot Boxer, Peugeot Tepee]
}
}
IV-B. La méthode asList()▲
Maintenant nous décidons de renvoyer une instance de notre liste immuable des carburants, puis l’une de tous nos véhicules du parc automobile.
2.
3.
4.
5.
6.
7.
8.
9.
10.
final ImmutableList<String> carburantsImmutableList = CARBURANTS.asList();
out.println(carburantsImmutableList);
// [Essence, Diesel, GNV, Hybride, Biodiesel, Electric, Essence, Essence Sans Plomb 95, Essence Sans Plomb 98]
final ImmutableList<String> carburantsImmutableList = CARBURANTS.asList();
out.println(carburantsImmutableList);
final ImmutableList<String> vehiculesImmutableList = VEHICULES.asList();
out.println(vehiculesImmutableList);
/*
[Citroen Nouvelle C-Elysée, Citroen Nemo Multispace, Citroen C4 Aircross, Opel Calibra, Opel Ascona, Opel Corsa, Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Peugeot Traveller/Expert Combi, Renault Kangoo VP, Renault Nouveau Grand Scenic, Renault Alaskan, Toyota Auris, Toyota Nouvelle Yaris, Toyota Aygo X ]
*/
IV-C. La méthode builder▲
IV-C-1. builder()▲
Cette méthode fonctionne comme celle du design pattern Builder, c’est-à-dire que l’on effectue un appel statique à la méthode builder, on ajoute un objet, puis on construit ce dernier en invoquant la méthode build(). En pratique nous obtenons le code suivant :
2.
3.
4.
final ImmutableList.Builder<String> citroenImmutableListBuilder = ImmutableList.builder();
citroenImmutableListBuilder.add(citroen); // on ajoute la marque citroen
out.println(citroenImmutableListBuilder.build()); // on invoque la méthode build() pour créer une nouvelle liste immuable
// [Citroen Nouvelle C-Elysée, Citroen Nemo Multispace, Citroen C4 Aircross]
IV-C-2. builderWithExpectedSize(int expectedSize)▲
Cette méthode prend un paramètre permettant de spécifier la taille allouée à la liste immuable, c’est-à-dire le nombre d’objets qu’elle contiendra. Sachant que la taille de la liste immuable sera dynamiquement redimensionnée en cas d’ajout d’autres objets.
2.
3.
4.
5.
6.
7.
8.
final ImmutableList.Builder<String> marquesImmutableBuilder = ImmutableList.builderWithExpectedSize(NB_MARQUES_VEHICULES); // 5
marquesImmutableBuilder.add(citroen);
marquesImmutableBuilder.add(opel);
marquesImmutableBuilder.add(peugeot);
marquesImmutableBuilder.add(renault);
marquesImmutableBuilder.add(toyota);
marquesImmutableBuilder.add(peugeot); // la taille de la liste est dynamiquement redimensionnée
out.println(marquesImmutableBuilder.build()); // [Citroen Nouvelle C-Elysée, Citroen Nemo Multispace, Citroen C4 Aircross, Opel Calibra, Opel Ascona, Opel Corsa, Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Peugeot Traveller/Expert Combi, Renault Kangoo VP, Renault Nouveau Grand Scenic, Renault Alaskan, Toyota Auris, Toyota Nouvelle Yaris, Toyota Aygo X , Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Peugeot Traveller/Expert Combi]
IV-D. La méthode contains(@Nullable Object object)▲
Nous désirons savoir si notre liste immuable contient un élément passé en paramètre.
2.
3.
final boolean containsBiodiesel = carburantsImmutableList.contains("Biodiesel");
out.println(containsBiodiesel); // true
out.println(carburantsImmutableList.contains("Biométhane")); // false
IV-E. La méthode copyOf▲
La méthode copyOf dispose de plusieurs signatures ayant chacune leurs spécificités bien que renvoyant toujours une liste immuable. Nous allons explorer chacune des versions de la méthode copyOf.
IV-E-1. copyOf(Collection<? extends E> elements)▲
Cette méthode nous permet de récolter dans une liste immuable un ensemble d’éléments issus d’une collection. Nous pouvons donc ajouter des véhicules (quelle que soit leur marque) à notre collection de véhicules en utilisant cette méthode.
2.
3.
4.
5.
6.
7.
collectionVehicules.add("Peugeot Tepee");
collectionVehicules.add("Toyota Prius+");
collectionVehicules.add("Opel Alambra");
collectionVehicules.add("Renault Safrane");
collectionVehicules.add("Citroen Space Tourer Business Lounge");
final ImmutableList<String> immutableCopyOfVehicules = ImmutableList.copyOf(collectionVehicules);
out.println(immutableCopyOfVehicules); // [Peugeot Tepee, Toyota Prius+, Opel Alambra, Renault Safrane, Citroen Space Tourer Business Lounge]
IV-E-2. copyOf(E[] elements)▲
Une autre variante de cette méthode prend en paramètre une liste d’éléments (un tableau donc mutable ou une liste immuable) et restitue les données dans une liste immuable.
2.
final ImmutableList<String> immutableCopyOfCarburants = ImmutableList.copyOf(CARBURANTS);
out.println(immutableCopyOfCarburants); // [Essence, Diesel, GNV, Hybride, Biodiesel, Electric, Essence, Essence Sans Plomb 95, Essence Sans Plomb 98]
IV-E-3. copyOf(Iterable<? extends E> elements)▲
Une autre variante de cette méthode prend en paramètre tout objet descendant de l’interface java.lang.Iterable du JDK d’Oracle donc en l’occurrence les éléments d’une liste de consommations de carburants au kilomètre.
2.
final ImmutableList<Float> immutableCopyOfConsommations = ImmutableList.copyOf(consommations);
out.println(immutableCopyOfConsommations); // [4.3, 5.8, 6.9, 7.4, 8.5, 9.2]
IV-E-4. copyOf(Iterator<? extends E> elements)▲
Idem pour cette variante, tout objet pouvant être parcouru à l’aide d’un itérateur comme nous avons coutume de le faire lors de l’utilisation des structures de données dynamiques en Java.
2.
final ImmutableList<Double> immutableCopyOfJantes = ImmutableList.copyOf(jantes);
out.println(immutableCopyOfJantes); // [7.5, 8.0, 8.5, 9.0, 9.5, 10.0, 10.5]
IV-F. La méthode equals(@Nullable Object obj)▲
Cette méthode à l’instar de celle du JDK d’Oracle permet de vérifier l’égalité « profonde » de deux objets.
2.
3.
4.
5.
// préférez le style Yoda lors d'évaluation avec la méthode equals(Object obj)
final boolean isDiesel = "Diesel".equals(CARBURANTS.get(1));
final boolean isElectric = "Electric".equals(CARBURANTS.get(1));
out.println(isDiesel); // true
out.println(isElectric); // false
IV-G. La méthode forEach(Consumer<? super E> consumer)▲
Parcourons notre collection de véhicules en utilisant cette fois-ci la méthode forEach.
2.
3.
4.
5.
6.
7.
8.
collectionVehicules.forEach(System.out::println);
/*
Peugeot Tepee
Toyota Prius+
Opel Alambra
Renault Safrane
Citroen Space Tourer Business Lounge
*/
IV-H. La méthode hashCode()▲
Derechef à l’instar du JDK d’Oracle, nous pouvons récupérer le hashCode d’un objet et ainsi vérifier par exemple si les deux objets sont identiques.
2.
out.println(VEHICULES.hashCode()); // 1001243442 sur ma machine !!!
out.println(CARBURANTS.hashCode()); // 1726599603 idem
IV-I. La méthode indexOf(@Nullable Object object)▲
Nous voulons récupérer l’indice (c’est-à-dire la valeur numérique du positionnement) d’un élément dans notre liste de carburants. Si l’élément n’est pas présent dans la liste immuable, la valeur -1 sera renvoyée.
2.
3.
4.
int indexOfBiodiesel = CARBURANTS.indexOf("Biodiesel");
int indexOfBiomethane = CARBURANTS.indexOf("Biométhane");
out.println(indexOfBiodiesel); // 4
out.println(indexOfBiomethane); // -1
IV-J. La méthode iterator()▲
À l’aide de la méthode iterator() nous pouvons définir un itérateur pour parcourir la liste de notre collection de véhicules.
2.
3.
4.
5.
6.
7.
final Iterator<String> it = collectionVehicules.iterator();
final UnmodifiableIterator<String> immutableListVoitures = Iterators.unmodifiableIterator(it);
while (immutableListVoitures.hasNext()) {
String vehicule = immutableListVoitures.next();
out.println(vehicule);
}
// [Peugeot Tepee, Toyota Prius+, Opel Alambra, Renault Safrane, Citroen Space Tourer Business Lounge]
IV-K. La méthode lastIndexOf(@Nullable Object object)▲
Nous pouvons récupérer précisément l’indice du dernier élément de la liste immuable. Idem que pour la méthode indexOf, si l’élément n’existe pas dans la liste immuable la valeur -1 sera renvoyée.
2.
3.
4.
final int lastIndexOfEssence = CARBURANTS.lastIndexOf("Essence");
final int lastIndexOfBiomethane = CARBURANTS.lastIndexOf("Biométhane");
out.println(lastIndexOfEssence); // 6
out.println(lastIndexOfBiomethane); // -1
IV-L. La méthode listIterator▲
La méthode listIterator renvoie un itérateur de liste sur les éléments de la liste immuable (dans l'ordre approprié).
IV-L-1. ListIterator()▲
Dans sa version simplifiée, nous pouvons l’utiliser directement sans aucun paramètre.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
final ImmutableList<Character> carburantHybride = Lists.charactersOf("Hybride");
final UnmodifiableListIterator<Character> immutableListCarburants = carburantHybride.listIterator();
while (immutableListCarburants.hasNext()) {
final Character carburant = immutableListCarburants.next();
out.print(carburant + " ");
}
out.println();
/*
Peugeot Tepee
Toyota Prius+
Opel Alambra
Renault Safrane
Citroen Space Tourer Business Lounge
*/
IV-L-2. listIterator(int index)▲
Sinon un indice peut être fourni en paramètre pour commencer l’itération à partir de ce dernier.
2.
3.
4.
5.
6.
7.
final ImmutableList<Character> carburantEssenceSansPlomb = Lists.charactersOf(CARBURANTS.get(7)); // Essence Sans Plomb 95
final UnmodifiableListIterator<Character> carburantSansPlomb = carburantEssenceSansPlomb.listIterator(8);
while (carburantSansPlomb.hasNext()) {
final Character carburant = carburantSansPlomb.next();
out.print(carburant); // Sans Plomb 95
}
out.println();
IV-M. La méthode of▲
La méthode of est surchargée un nombre important de fois. Cette méthode permet de renvoyer une liste immuable vide, contenant un unique élément ou une liste d’éléments dans leur ordre d’insertion.
IV-M-1. of()▲
2.
final ImmutableList<String> immutableListVide = ImmutableList.of(); // liste ne contenant aucun élément
out.println(immutableListVide); // []
IV-M-2. of(E element)▲
2.
final ImmutableList<String> immutableListUniqueElement = ImmutableList.of("Renault Talisman");
out.println(immutableListUniqueElement); // [Renault Talisman]
IV-M-3. of(E e1, E e2)▲
2.
final ImmutableList<String> immutableListCoupleElements = ImmutableList.of("Renault Talisman", "Renault Velsatis");
out.println(immutableListCoupleElements); // [Renault Talisman, Renault Velsatis]
IV-N. La méthode reverse()▲
Désormais nous voulons restituer notre liste de véhicules dans l’ordre inverse d’insertion.
2.
3.
out.println(carburantsImmutableList); // [Essence, Diesel, GNV, Hybride, Biodiesel, Electric, Essence, Essence Sans Plomb 95, Essence Sans Plomb 98]
final ImmutableList<String> immutableListReverseCarburants = CARBURANTS.reverse();
out.println(immutableListReverseCarburants); // [Essence Sans Plomb 98, Essence Sans Plomb 95, Essence, Electric, Biodiesel, Hybride, GNV, Diesel, Essence]
IV-O. La méthode sortedCopyOf▲
IV-O-1. sortedCopyOf(Comparator<? super E> comparator, Iterable<? extends E> elements)▲
Si nous voulons effectuer un tri en fonction de la longueur du nom du véhicule du plus long au plus court en utilisant un comparateur, la méthode sortedCopyOf nous permettra d’effectuer cette tâche.
2.
3.
4.
final Comparator<String> comparator = (String o1, String o2) -> (o2.length() - o1.length());
final ImmutableList<String> immutableListSortedCopyOfWithComparator = ImmutableList.sortedCopyOf(comparator, VEHICULES);
out.println(immutableListSortedCopyOfWithComparator);
// [Peugeot Traveller/Expert Combi, Renault Nouveau Grand Scenic, Citroen Nouvelle C-Elysée, Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Citroen Nemo Multispace, Toyota Nouvelle Yaris, Citroen C4 Aircross, Renault Kangoo VP, Renault Alaskan, Toyota Aygo X , Opel Calibra, Toyota Auris, Opel Ascona, Opel Corsa]
IV-O-2. sortedCopyOf(Iterable<? extends E> elements)▲
Nous pouvons effectuer un tri sans comparateur spécifique qui s’effectuera alors selon un ordre naturel alphabétique.
2.
3.
final ImmutableList<String> immutableListSortedCopyOfWithoutComparator = ImmutableList.sortedCopyOf(VEHICULES);
out.println(immutableListSortedCopyOfWithoutComparator);
// [Peugeot Traveller/Expert Combi, Renault Nouveau Grand Scenic, Citroen Nouvelle C-Elysée, Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Citroen Nemo Multispace, Toyota Nouvelle Yaris, Citroen C4 Aircross, Renault Kangoo VP, Renault Alaskan, Toyota Aygo X , Opel Calibra, Toyota Auris, Opel Ascona, Opel Corsa]
IV-P. La méthode spliterator()▲
La méthode spliterator fonctionne comme la méthode iterator vue plus haut dans ce tutoriel. Néanmoins elle dispose de deux méthodes particulièrement utiles, l’une permettant de connaître le nombre d’éléments restant à parcourir dans la liste, et l’autre permettant de boucler sur les éléments de la liste immuable directement sans devoir utiliser une boucle while classique pour parcourir un objet iterable.
2.
3.
4.
5.
6.
7.
8.
9.
10.
final Spliterator<String> spliterator = collectionVehicules.spliterator();
out.println(spliterator.estimateSize()); // 5
spliterator.forEachRemaining(System.out::println);
/*
Peugeot Tepee
Toyota Prius+
Opel Alambra
Renault Safrane
Citroen Space Tourer Business Lounge
*/
IV-Q. La méthode subList(int fromIndex, int toIndex)▲
Nous voulons désormais restituer uniquement une sous-liste immuable de notre liste de carburants. La méthode sublist permet d’effectuer cette tâche en lui passant l’indice de début et l’indice de fin.
2.
3.
4.
5.
6.
7.
final ImmutableList<String> immutableSubListCarburants = CARBURANTS.subList(1, 3);
out.println(immutableSubListCarburants); // [Diesel, GNV]
/* Attention : si votre collection est composée de plusieurs tableaux ajoutés,
| la sous-liste correspondra alors uniquement à une sous-liste des éléments du premier tableau
*/
final ImmutableList<String> immutableSubListVehicules = vehiculesImmutableList.subList(1, 3);
out.println(immutableSubListVehicules); // [Citroen Nemo Multispace, Citroen C4 Aircross]
IV-R. La méthode toImmutableList()▲
Nous souhaitons désormais récolter dans une liste immuable une liste des consommations en carburants d’une gamme de véhicules énergivores.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
final Supplier<List<Float>> getConsommations
= () -> ImmutableList.of(
8.3f, 8.5f, 8.9f,
9.1f, 9.2f, 9.7f,
10.4f, 10.8f, 10.9f,
11.1f, 11.4f, 11.8f,
// E... others
12.1f, 12.2f, 12.4f,
13.4f, 13.7f, 13.9f,
14.2f, 14.3f, 14.7f
);
final List<Float> indiceConsommation = getConsommations.get();
final List<Float> consommationMaserati = indiceConsommation.stream()
//.filter(c -> c <= 10.4) // si on veut uniquement les consommations inférieures à 10.4 litre/100km
.collect(ImmutableList.toImmutableList());
out.println(consommationMaserati);
// [8.3, 8.5, 8.9, 9.1, 9.2, 9.7, 10.4, 10.8, 10.9, 11.1, 11.4, 11.8, 12.1, 12.2, 12.4, 13.4, 13.7, 13.9, 14.2, 14.3, 14.7]
V. Conclusion▲
Nous avons fait le tour des méthodes utilitaires présentes dans la classe ImmutableList. Comme vous avez pu le constater ces méthodes sont à la fois très simples d’utilisation et particulièrement efficaces. Je vous invite fortement à les implémenter dans vos projets, car elles vous apporteront des avantages sans précédent en termes de productivité.
Par ailleurs, je vous invite comme d’habitude à créer un fil de discussion afin d’y laisser tous vos commentaires pour l’appréciation, voire pour l’amélioration des futurs tutoriels.
VI. Remerciements▲
Je tiens à remercier tout particulièrement claudeLELOUP pour la relecture orthographique de cet article.
Je tiens à remercier tout particulièrement la communauté developpez.com qui propose un forum d’entraide d’une richesse fortement appréciable. Je remercie également Mickael Baron qui donne de son temps pour s’occuper de la rubrique Java, RomeoBeni à qui je remercie d’avoir écrit un ouvrage d’une rare simplicité pour apprendre à programmer en Java, mais aussi à tous les membres répondant aux questions des débutants en programmation. Un grand merci à tous.