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

La classe ImmutableList

RAUZDUEL Rony

L'objectif de ce second article sur l’exploration de la bibliothèque Guava de Google est de vous présenter les méthodes statiques composant la classe utilitaire ImmutableList.

Cet article nous permettra d’apprécier toute la richesse de cette bibliothèque qui ne fait que s’améliorer au fur et à mesure des versions.

Lors de l’écriture de cet article, nous avons utilisé la version 30.1.1 de Google Guava.

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.

Vous pouvez également consulter mon précédent tutoriel pour découvrir la bibliothèque Guava.

La classe Lists

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum. Commentez

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

- Auteur : RAUZDUEL Rony

- Parution : 15 mars 2021

- Mise à jour : 3 novembre 2021

- Public visé :

- Licence : 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 et 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.

Sommaire

- I. Introduction

- II. Ajouter Google Guava à votre projet (Rappel)

- III. La classe utilitaire ImmutableList

- IV. Implémentation des méthodes de la classe ImmutableList

- IV-A. Les imports

- IV-A-1. Les attributs et blocs statiques

- IV-B. La méthode asList()

- IV-C. La méthode builder

- IV-C-1. builder()

- IV-C-2. builderWithExpectedSize(int expectedSize)

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

- IV-E. La méthode copyOf

- IV-E-1. copyOf(Collection<? extends E> elements)

- IV-E-2. copyOf(E[] elements)

- IV-E-3. copyOf(Iterable<? extends E> elements)

- IV-E-4. copyOf(Iterator<? extends E> elements)

- IV-F. La méthode equals(@Nullable Object obj)

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

- IV-H. La méthode hashCode()

- IV-I. La méthode indexOf(@Nullable Object object)

- IV-J. La méthode iterator()

- IV-K. La méthode lastIndexOf(@Nullable Object object)

- IV-L. La méthode listIterator

- IV-L-1. ListIterator()

- IV-L-2. listIterator(int index)

- IV-M. La méthode of

- IV-M-1. of()

- IV-M-2. of(E element)

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

- IV-N. La méthode reverse()

- IV-O. La méthode sortedCopyOf

- IV-O-1. sortedCopyOf(Comparator<? super E> comparator, Iterable<? extends E> elements)

- IV-O-2. sortedCopyOf(Iterable<? extends E> elements)

- IV-P. La méthode spliterator()

- IV-Q. La méthode subList(int fromIndex, int toIndex)

- IV-R. La méthode toImmutableList()

- V. Conclusion

- VI. Remerciements

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.

Installer Guava avec Maven

1. <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->

2. <dependency>

3. <groupId>com.google.guava</groupId>

4. <artifactId>guava</artifactId>

5. <version>30.1-jre</version>

6. </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

Les imports

1. import com.google.common.collect.ImmutableList;

2. import com.google.common.collect.Iterators;

3. import com.google.common.collect.Lists;

4. import com.google.common.collect.UnmodifiableIterator;

5. import com.google.common.collect.UnmodifiableListIterator;

6. import static java.lang.System.out;

7. import java.util.ArrayList;

8. import java.util.Collection;

9. import java.util.Comparator;

10. import java.util.Iterator;

11. import java.util.LinkedList;

12. import java.util.List;

13. import java.util.Spliterator;

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

Les attributs et blocs statiques

1. public final class Application {

3. private final static int NB_VEHICULES = 3;

4. private final static int NB_MARQUES_VEHICULES = 5;

5. private final static String[] citroen;

6. private final static String[] opel;

7. private final static String[] peugeot;

8. private final static String[] renault;

9. private final static String[] toyota;

10. private final static List<Float> consommations;

11. private final static List<Double> jantes;

13. static { // les marques des véhicules

14. peugeot = new String[NB_VEHICULES];

15. peugeot[0] = "Peugeot Nouvelle SUV 3008";

16. peugeot[1] = "Peugeot Nouvelle SUV 5008";

17. peugeot[2] = "Peugeot Traveller/Expert Combi";

19. toyota = new String[NB_VEHICULES];

20. toyota[0] = "Toyota Auris";

21. toyota[1] = "Toyota Nouvelle Yaris";

22. toyota[2] = "Toyota Aygo X ";

24. opel = new String[NB_VEHICULES];

25. opel[0] = "Opel Calibra";

26. opel[1] = "Opel Ascona";

27. opel[2] = "Opel Corsa";

29. renault = new String[NB_VEHICULES];

30. renault[0] = "Renault Kangoo VP";

31. renault[1] = "Renault Nouveau Grand Scenic";

32. renault[2] = "Renault Alaskan";

34. citroen = new String[NB_VEHICULES];

35. citroen[0] = "Citroen Nouvelle C-Elysée";

36. citroen[1] = "Citroen Nemo Multispace";

37. citroen[2] = "Citroen C4 Aircross";

38. }

40. static { // la consommation du litre/100km, on voit qu'elle est très élevée.

41. consommations = new ArrayList<>();

42. consommations.add(4.3f);

43. consommations.add(5.8f);

44. consommations.add(6.9f);

45. consommations.add(7.4f);

46. consommations.add(8.5f);

47. consommations.add(9.2f);

48. }

50. static { // la taille des jantes des véhicules

51. jantes = new LinkedList<>();

52. jantes.add(7.5);

53. jantes.add(8.0);

54. jantes.add(8.5);

55. jantes.add(9.0);

56. jantes.add(9.5);

57. jantes.add(10.0);

58. jantes.add(10.5);

59. }

61. // une liste immuable contenant tous nos véhicules ...

62. final static ImmutableList<String> VEHICULES

63. = new ImmutableList.Builder<String>()

64. .add(citroen)

65. .add(opel)

66. .add(peugeot) // add(E... elements)

67. .add(renault)

68. .add(toyota)

69. .build();

71. // ... une autre contenant les carburants disponibles

72. final static ImmutableList<String> CARBURANTS

73. = new ImmutableList.Builder<String>()

74. .add("Essence") // add(E element)

75. .add("Diesel")

76. .add("GNV")

77. .add("Hybride")

78. .add("Biodiesel")

79. .add("Electric")

80. .add("Essence")

81. .add("Essence Sans Plomb 95")

82. .add("Essence Sans Plomb 98")

83. .build();

85. final static Collection<String> collectionVehicules = new ArrayList<>(NB_MARQUES_VEHICULES);

87. public static void main(String[] args) {

88. // commençons par afficher la liste des véhicules de la marque Peugeot

89. out.println(Arrays.asList(peugeot)); // [Peugeot Nouvelle SUV 3008, Peugeot Nouvelle SUV 5008, Peugeot Traveller/Expert Combi, Peugeot Boxer, Peugeot Tepee]

90. }

91. }

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.

Méthode ImmutableList<E> asList()

1. final ImmutableList<String> carburantsImmutableList = CARBURANTS.asList();

2. out.println(carburantsImmutableList);

3. // [Essence, Diesel, GNV, Hybride, Biodiesel, Electric, Essence, Essence Sans Plomb 95, Essence Sans Plomb 98]

4. final ImmutableList<String> carburantsImmutableList = CARBURANTS.asList();

5. out.println(carburantsImmutableList);

6. final ImmutableList<String> vehiculesImmutableList = VEHICULES.asList();

7. out.println(vehiculesImmutableList);

8. /*

9. [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 ]

10. */

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 :

Méthode builder()

1. final ImmutableList.Builder<String> citroenImmutableListBuilder = ImmutableList.builder();

2. citroenImmutableListBuilder.add(citroen); // on ajoute la marque citroen

3. out.println(citroenImmutableListBuilder.build()); // on invoque la méthode build() pour créer une nouvelle liste immuable

4. // [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.

builderWithExpectedSize(int expectedSize)

1. final ImmutableList.Builder<String> marquesImmutableBuilder = ImmutableList.builderWithExpectedSize(NB_MARQUES_VEHICULES); // 5

2. marquesImmutableBuilder.add(citroen);

3. marquesImmutableBuilder.add(opel);

4. marquesImmutableBuilder.add(peugeot);

5. marquesImmutableBuilder.add(renault);

6. marquesImmutableBuilder.add(toyota);

7. marquesImmutableBuilder.add(peugeot); // la taille de la liste est dynamiquement redimensionnée

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

Méthode contains(@Nullable Object object)

1. final boolean containsBiodiesel = carburantsImmutableList.contains("Biodiesel");

2. out.println(containsBiodiesel); // true

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

Méthode copyOf(Collection<? extends E> elements)

1. collectionVehicules.add("Peugeot Tepee");

2. collectionVehicules.add("Toyota Prius+");

3. collectionVehicules.add("Opel Alambra");

4. collectionVehicules.add("Renault Safrane");

5. collectionVehicules.add("Citroen Space Tourer Business Lounge");

6. final ImmutableList<String> immutableCopyOfVehicules = ImmutableList.copyOf(collectionVehicules);

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

Méthode copyOf(E[] elements)

1. final ImmutableList<String> immutableCopyOfCarburants = ImmutableList.copyOf(CARBURANTS);

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

Méthode copyOf(Iterable<? extends E> elements)

1. final ImmutableList<Float> immutableCopyOfConsommations = ImmutableList.copyOf(consommations);

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

Méthode copyOf(Iterator<? extends E> elements)

1. final ImmutableList<Double> immutableCopyOfJantes = ImmutableList.copyOf(jantes);

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

Méthode equals(@Nullable Object obj)

1. // préférez le style Yoda lors d'évaluation avec la méthode equals(Object obj)

2. final boolean isDiesel = "Diesel".equals(CARBURANTS.get(1));

3. final boolean isElectric = "Electric".equals(CARBURANTS.get(1));

4. out.println(isDiesel); // true

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

Méthode forEach(Consumer<? super E> consumer)

1. collectionVehicules.forEach(System.out::println);

2. /*

3. Peugeot Tepee

4. Toyota Prius+

5. Opel Alambra

6. Renault Safrane

7. Citroen Space Tourer Business Lounge

8. */

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.

Méthode hashCode()

1. out.println(VEHICULES.hashCode()); // 1001243442 sur ma machine !!!

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

Méthode indexOf(@Nullable Object object)

1. int indexOfBiodiesel = CARBURANTS.indexOf("Biodiesel");

2. int indexOfBiomethane = CARBURANTS.indexOf("Biométhane");

3. out.println(indexOfBiodiesel); // 4

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.

Méthode iterator()

1. final Iterator<String> it = collectionVehicules.iterator();

2. final UnmodifiableIterator<String> immutableListVoitures = Iterators.unmodifiableIterator(it);

3. while (immutableListVoitures.hasNext()) {

4. String vehicule = immutableListVoitures.next();

5. out.println(vehicule);

6. }

7. // [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.

Méthode lastIndexOf(@Nullable Object object)

1. final int lastIndexOfEssence = CARBURANTS.lastIndexOf("Essence");

2. final int lastIndexOfBiomethane = CARBURANTS.lastIndexOf("Biométhane");

3. out.println(lastIndexOfEssence); // 6

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

Méthode listIterator()

1. final ImmutableList<Character> carburantHybride = Lists.charactersOf("Hybride");

2. final UnmodifiableListIterator<Character> immutableListCarburants = carburantHybride.listIterator();

3. while (immutableListCarburants.hasNext()) {

4. final Character carburant = immutableListCarburants.next();

5. out.print(carburant + " ");

6. }

7. out.println();

8. /*

9. Peugeot Tepee

10. Toyota Prius+

11. Opel Alambra

12. Renault Safrane

13. Citroen Space Tourer Business Lounge

14. */

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

1. final ImmutableList<Character> carburantEssenceSansPlomb = Lists.charactersOf(CARBURANTS.get(7)); // Essence Sans Plomb 95

2. final UnmodifiableListIterator<Character> carburantSansPlomb = carburantEssenceSansPlomb.listIterator(8);

3. while (carburantSansPlomb.hasNext()) {

4. final Character carburant = carburantSansPlomb.next();

5. out.print(carburant); // Sans Plomb 95

6. }

7. 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()

Méthode of()

1. final ImmutableList<String> immutableListVide = ImmutableList.of(); // liste ne contenant aucun élément

2. out.println(immutableListVide); // []

IV-M-2 - of(E element)

Méthode of(E element)

1. final ImmutableList<String> immutableListUniqueElement = ImmutableList.of("Renault Talisman");

2. out.println(immutableListUniqueElement); // [Renault Talisman]

IV-M-3 - of(E e1, E e2)

Méthode of(E e1, E e2)

1. final ImmutableList<String> immutableListCoupleElements = ImmutableList.of("Renault Talisman", "Renault Velsatis");

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

reverse()

1. out.println(carburantsImmutableList); // [Essence, Diesel, GNV, Hybride, Biodiesel, Electric, Essence, Essence Sans Plomb 95, Essence Sans Plomb 98]

2. final ImmutableList<String> immutableListReverseCarburants = CARBURANTS.reverse();

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

Méthode sortedCopyOf(Comparator<? super E> comparator, Iterable<? extends E> elements)

1. final Comparator<String> comparator = (String o1, String o2) -> (o2.length() - o1.length());

2. final ImmutableList<String> immutableListSortedCopyOfWithComparator = ImmutableList.sortedCopyOf(comparator, VEHICULES);

3. out.println(immutableListSortedCopyOfWithComparator);

4. // [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.

Méthode sortedCopyOf(Iterable<? extends E> elements)

1. final ImmutableList<String> immutableListSortedCopyOfWithoutComparator = ImmutableList.sortedCopyOf(VEHICULES);

2. out.println(immutableListSortedCopyOfWithoutComparator);

3. // [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.

Méthode spliterator()

1. final Spliterator<String> spliterator = collectionVehicules.spliterator();

2. out.println(spliterator.estimateSize()); // 5

3. spliterator.forEachRemaining(System.out::println);

4. /*

5. Peugeot Tepee

6. Toyota Prius+

7. Opel Alambra

8. Renault Safrane

9. Citroen Space Tourer Business Lounge

10. */

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.

Méthode subList(int fromIndex, int toIndex)

1. final ImmutableList<String> immutableSubListCarburants = CARBURANTS.subList(1, 3);

2. out.println(immutableSubListCarburants); // [Diesel, GNV]

3. /* Attention : si votre collection est composée de plusieurs tableaux ajoutés,

4. |  la sous-liste correspondra alors uniquement à une sous-liste des éléments du premier tableau

5. */

6. final ImmutableList<String> immutableSubListVehicules = vehiculesImmutableList.subList(1, 3);

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

Méthode toImmutableList()

1. final Supplier<List<Float>> getConsommations

2. = () -> ImmutableList.of(

3. 8.3f, 8.5f, 8.9f,

4. 9.1f, 9.2f, 9.7f,

5. 10.4f, 10.8f, 10.9f,

6. 11.1f, 11.4f, 11.8f,

7. // E... others

8. 12.1f, 12.2f, 12.4f,

9. 13.4f, 13.7f, 13.9f,

10. 14.2f, 14.3f, 14.7f

11. );

12. final List<Float> indiceConsommation = getConsommations.get();

13. final List<Float> consommationMaserati = indiceConsommation.stream()

14. //.filter(c -> c <= 10.4) // si on veut uniquement les consommations inférieures à 10.4 litre/100km

15. .collect(ImmutableList.toImmutableList());

16. out.println(consommationMaserati);

17. // [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.