IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Tutoriel pour découvrir l’API Collections de Google Guava

La classe ImmutableList

Le but de cet article est l'exploration de la classe ImmutableList de l'API Collections de la bibliothèque Guava de Google. À noter que j'ai déjà publié un premier tutoriel traitant de la classe Lists.

Comme exemple nous utiliserons un parc automobile, cela nous permettra de sonder de façon pratique et ludique les méthodes de cette classe.

En effet de par mon expérience, j'ai pu constater que certains développeurs (et parfois moi aussi) implémentaient des fonctionnalités alors que ces dernières étaient présentes dans des bibliothèques tierces.

Ainsi dans nos futurs projets respectons le vieil adage : "ne réinventez pas la roue".

Par ailleurs, je vous invite à 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. 2 commentaires Donner une note  l'article (5)

Article lu   fois.

L'auteur

Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

Dans ce second tutoriel sur l’exploration de la bibliothèque Guava de Google faisant suite au premier tutoriel, nous découvrirons l’ensemble des méthodes statiques composant la classe utilitaire ImmutableList.

Par ailleurs comme il s'agit d'une découverte, je parcours la bibliothèque des méthodes de la classe ImmutableList en y greffant des exemples simples. 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 est avant tout pratique, mon fil conducteur est la page suivante https://github.com/google/guava/wiki/ImmutableCollectionsExplainedained traitant des Collections de l'API Google Guava. Le lecteur devra donc s’attendre à voir la mise en œuvre des méthodes de la classe ImmutableList de façon pragmatique et ludique. Souhaitons au lecteur d’apprécier toute la richesse de cette bibliothèque qui ne fait que s’améliorer au fur et à mesure des versions. Bonne lecture à tous.

II. Qu’est-ce que l’API Google Guava et pourquoi l’utiliser ?

L’API Google Guava est une bibliothèque contenant un ensemble de classes utilitaires fort utiles dans n’importe quel projet Java. En effet, cette API contient des classes allant du traitement des collections permettant de gérer des objets immuables, à la manipulation des chaînes de caractères, en passant par la gestion des entrées-sorties conversationnelles, et bien d’autres fonctionnalités qui facilitent la vie du développeur.

Dans cette série de tutoriels, nous n’aborderons que les classes utilitaires de l’API Collections. Cette dernière regroupe un ensemble de classes analogues à celles présentes dans le JDK, mais à la différence que ces dernières ont été améliorées par rapport à celles du JDK d’ORACLE.

En effet les développeurs de Google ont souhaité étendre les fonctionnalités des structures de données natives que nous utilisons au quotidien afin d’accroître notre productivité.

Le projet Guava représente le cœur du développement de Google, il représente des années de développement et une boîte à outils utilisée au quotidien par les développeurs de Google. Cette API est arrivée à maturité puisqu’elle est à l’heure actuelle à sa version 30.1 et ne cesse d’être agrémentée de nouvelles fonctionnalités.

Pour conclure cette section, nous dirons que dans ce second volet nous découvrirons l’ensemble des méthodes utilitaires statiques composant la classe utilitaire ImmutableList.

III. Ajouter Google Guava à votre projet

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.

Installer Guava via Maven
Sélectionnez
1.
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>

IV. 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.

V. Implémentation des méthodes de la classe ImmutableList

V-A. Les imports

Les imports
Sélectionnez
1.
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;

V-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.

Les attributs et blocs statiques
Sélectionnez
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.
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]
    }    
}

V-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.

Méthode ImmutableList<E> asList()
Sélectionnez
1.
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 ]
*/

V-C. La méthode builder

V-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 :

Méthode builder()
Sélectionnez
1.
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]

V-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.

builderWithExpectedSize(int expectedSize)
Sélectionnez
1.
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]

V-D. La méthode contains(@Nullable Object object)

Nous désirons savoir si notre liste immuable contient un élément passé en paramètre.

Méthode contains(@Nullable Object object)
Sélectionnez
1.
2.
3.
final boolean containsBiodiesel = carburantsImmutableList.contains("Biodiesel");
out.println(containsBiodiesel); // true
out.println(carburantsImmutableList.contains("Biométhane")); // false

V-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.

V-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.

Méthode copyOf(Collection<? extends E> elements)
Sélectionnez
1.
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]

V-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.

Méthode copyOf(E[] elements)
Sélectionnez
1.
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]

V-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.

Méthode copyOf(Iterable<? extends E> elements)
Sélectionnez
1.
2.
final ImmutableList<Float> immutableCopyOfConsommations = ImmutableList.copyOf(consommations);
out.println(immutableCopyOfConsommations); // [4.3, 5.8, 6.9, 7.4, 8.5, 9.2]

V-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.

Méthode copyOf(Iterator<? extends E> elements)
Sélectionnez
1.
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]

V-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.

Méthode equals(@Nullable Object obj)
Sélectionnez
1.
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

V-G. La méthode forEach(Consumer<? super E> consumer)

Parcourons notre collection de véhicules en utilisant cette fois-ci la méthode forEach.

Méthode forEach(Consumer<? super E> consumer)
Sélectionnez
1.
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
*/

V-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.

Méthode hashCode()
Sélectionnez
1.
2.
out.println(VEHICULES.hashCode()); // 1001243442 sur ma machine !!!
out.println(CARBURANTS.hashCode()); // 1726599603 idem

V-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.

Méthode indexOf(@Nullable Object object)
Sélectionnez
1.
2.
3.
4.
int indexOfBiodiesel = CARBURANTS.indexOf("Biodiesel");
int indexOfBiomethane = CARBURANTS.indexOf("Biométhane");
out.println(indexOfBiodiesel); // 4
out.println(indexOfBiomethane); // -1

V-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.

Méthode iterator()
Sélectionnez
1.
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]

V-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.

Méthode lastIndexOf(@Nullable Object object)
Sélectionnez
1.
2.
3.
4.
final int lastIndexOfEssence = CARBURANTS.lastIndexOf("Essence");
final int lastIndexOfBiomethane = CARBURANTS.lastIndexOf("Biométhane");
out.println(lastIndexOfEssence); // 6
out.println(lastIndexOfBiomethane); // -1

V-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é).

V-L-1. ListIterator()

Dans sa version simplifiée, nous pouvons l’utiliser directement sans aucun paramètre.

Méthode listIterator()
Sélectionnez
1.
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
*/

V-L-2. listIterator(int index)

Sinon un indice peut être fourni en paramètre pour commencer l’itération à partir de ce dernier.

Méthode listIterator(int index)
Sélectionnez
1.
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();

V-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.

V-M-1. of()

Méthode of()
Sélectionnez
1.
2.
final ImmutableList<String> immutableListVide = ImmutableList.of(); // liste ne contenant aucun élément
out.println(immutableListVide); // []

V-M-2. of(E element)

Méthode of(E element)
Sélectionnez
1.
2.
final ImmutableList<String> immutableListUniqueElement = ImmutableList.of("Renault Talisman");
out.println(immutableListUniqueElement); // [Renault Talisman]

V-M-3. of(E e1, E e2)

Méthode of(E e1, E e2)
Sélectionnez
1.
2.
final ImmutableList<String> immutableListCoupleElements = ImmutableList.of("Renault Talisman", "Renault Velsatis");
out.println(immutableListCoupleElements); // [Renault Talisman, Renault Velsatis]

V-N. La méthode reverse()

Désormais nous voulons restituer notre liste de véhicules dans l’ordre inverse d’insertion.

reverse()
Sélectionnez
1.
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]

V-O. La méthode sortedCopyOf

V-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.

Méthode sortedCopyOf(Comparator<? super E> comparator, Iterable<? extends E> elements)
Sélectionnez
1.
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]

V-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.

Méthode sortedCopyOf(Iterable<? extends E> elements)
Sélectionnez
1.
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]

V-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.

Méthode spliterator()
Sélectionnez
1.
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
*/

V-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.

Méthode subList(int fromIndex, int toIndex)
Sélectionnez
1.
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]

V-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.

Méthode toImmutableList()
Sélectionnez
1.
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]

VI. 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.

VII. 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.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2021 RAUZDUEL Rony. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.