PROGRAMMATION JAVA

Deuxième année Informatique (ENICARTHAGE)

1
LES COLLECTIONS ET
LES STREAMS
2
 GÉNÉRICITÉ
 En POO, la généricité est un concept permettant de définir des
algorithmes (types de données et méthodes) identiques qui peuvent
être utilisés sur de multiples types de données. Cela permet donc de
réduire
// exemple 1:les quantités de codes à produire.
ArrayList
import [Link];
import [Link]; Essai
public class Genericite { Cours Java
public static void main(String[] args) { Tutoriel Java
// création d'un tableau dynamique des instances de Object Thu Oct 06 [Link]
ArrayList collection = new ArrayList(); GMT+01:00 2022
// On y stocke nos chaînes de caractères (possible par polymorphisme)
[Link]( "Essai" ); [Link]( "Cours Java" );
[Link]( "Tutoriel Java" );
// Mais rien nous interdit d'y mettre autre chose (polymorphisme)
[Link]( new Date() );
// Maintenant on parcourt la collection
3
for ( Object value : collection ) {
 // Si nous utilisons la généricité, nous pouvons indiquer que la collection ne peut contenir que
des chaînes de caractères
ArrayList<String> collection = new ArrayList<String>();

// On y stocke nos chaînes de caractères

[Link]( "Essai" ); [Link]( "Cours Java" ); [Link]( "Tutoriel
Java" );

// Cette ligne ne compile plus

[Link]( new Date() );
public class GenericBox<T>{ public class ClassesGeneriques { enicar
// exemple 2: création d’une classe générique
private T element; 123
public GenericBox( T element ) { public static void main(String[] args) {
[Link] = element; }
public T getElement() { GenericBox<String> box = new GenericBox<>(
return element; } "enicar" );
public void setElement( T element ) { [Link]( [Link]() );
[Link] = element; } } GenericBox<Integer> box1 = new
GenericBox<>(123 );
 classe générique avec plusieurs types de généricité:
[Link]( public class
[Link]() ); }}
………<T1,T2>
 Restriction de typage sur une classe générique; par exemple:
public class GenericBox<T extends Personne> 4
 LES COLLECTIONS
 Une collection est une structure de données en mémoire, qui contient
toutes les valeurs que la structure de données possède actuellement.
Des opérations telles que la recherche, le tri, l'insertion, la manipulation
et la suppression peuvent être effectuées sur une collection.
 Le Java SE propose un très grand nombre de classes génériques dans
sa librairie et notamment les classes de collections. Elles implémentent
des interfaces communes qui sont elles-mêmes génériques:
public interface Collection<E> extends Iterable<E>
public interface List<E> extends Collection<E>
public interface Set<E> extends Collection<E>
public interface Map<Key, Value>

5
 Tableau Liste Table avec Arbre
de taille chainée hashage
variable
Interfaces Classes implémentant ces interfaces
List ArrayList LinkedList
<T> <T>
Set HashSet<T> TreeSet<T>

Map HashMap<T1,T TreeMap<T1,T2>

 Quelques méthodes de Collection: 2>
 int size();  boolean containsAll(Collection c);
 boolean isEmpty();  boolean addAll(Collection c);
 boolean contains(Object element); 
boolean removeAll(Collection c);
 boolean add(Object element);
 void clear();
 boolean remove(Object element);
 Object[] toArray();
 int hashCode();
 boolean equals(Object element);
6
 Quelques méthodes de List:  Quelques méthodes de Map:
 Object get(int index);  int size();
 Object set(int index, Object Object put(Object key, Object value);
element);  Object get(Object key);
 void add(int index, Object Object remove(Object key);
element);
 boolean containsKey(Object key);
 Object remove(int index);
 boolean containsValue(Object value);
 boolean addAll(int index, Collection
c);  boolean isEmpty();

 int indexOf(Object o);  void putAll(Map t);

 int lastIndexOf(Object o);  void clear();


 List subList(int fromIndex, int public Set keySet();
toIndex); public Collection values();

7
// exemple:
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public enum Category { Ouvrier, Ingenieur, Directeur}
public class Employe {
private int id; private String name; private int age; private double salary; private Category
cat;
public Employe(int id, String name, int age, double salary, Category cat) {
[Link] = id; [Link] = name; [Link] = age; [Link] = salary; [Link] =
cat; }
public int getId() { return id; }
public String getName() { return name; }
public int getAge() { return age; }
public double getSalary() { return salary; }
public Category getCategory(){ return cat; }
public void setId(int id) { [Link] = id; }
public void setName(String name) { [Link]= name; }
public void setAge(int age) { [Link] = age; }
public void setSalary(double salary ) { [Link]=salary; } 8
@Override
public String toString() {
return "[id=" + [Link] + ", name=" + [Link] + ", age=" + [Link] + ", salary=" + [Link] + "
Category: "+[Link]+ "]"; }}
public class LesCollections {
public static void main(String[] args) {
// tableaux statiques
[Link]("---------------- Array -------------------");
Employe[] employes1 = {new Employe(0,"Ferid", 25, 2000.0, [Link]), new
Employe(1,"Samia", 30, 3000.1, [Link])};
Employe[] employes2 =new Employe[2];
employes2[0] = new Employe(0,"Ferid", 25, 2000.0, [Link]);
employes2[1] = new Employe(1,"Samia", 30, 3000.1, [Link]);
[Link]("affichage du contenu tableau statique");
for (Employe emp:employes2){
[Link](emp); }
// tableaux dynamiques
[Link]("---------------- ArrayList-------------------");
List<Employe> employeList = new ArrayList<Employe>();
[Link](new Employe(0,"Ferid", 25, 2000.0, [Link]));
[Link](0, new Employe(1,"Samia", 30, 3000.1, [Link]));
[Link]("affichage du contenu ArrayList");
for (Employe emp:employeList){
[Link](emp); } 9
// listes chainées
[Link]("---------------- LinkedList -------------------");
List<Employe> employeList1 = new LinkedList<Employe>();
[Link](new Employe(0,"Ferid", 25, 2000.0, [Link]));
[Link](0, new Employe(1,"Samia", 30, 3000.1, [Link]));
[Link]("affichage du contenu LinkedList");
for (Employe emp:employeList1){ [Link](emp); }
// Emsembles
[Link]("---------------- Set -------------------");
Set<String> se = new HashSet<String>() ;
[Link]("un"); [Link]("deux") ; [Link]("un") ;
[Link]("Taille du set : " + [Link]()) ;
[Link]("affichage du contenu Set");
for (String emp:se){ [Link](emp); }
// tables associatives
[Link]("---------------- Map-------------------");
Map <String,Employe> m = new HashMap(); int i=0;
[Link]("c", new Employe(i,"Salah", 30, 600.25, [Link]));
[Link]("f", new Employe(i++,"Said", 27, 600.25, [Link]));
[Link]("k", new Employe(i++,"Fethi", 32, 600.25, [Link]));
[Link]("P", new Employe(i++,"Nabiha",29 , 1500.0, [Link]));
[Link]("valeur associée à f est: "+[Link]("f"));
[Link]("liste des valeurs "+ [Link]());
[Link]("liste des clés: "+[Link]());}} 10
---------------- Array -------------------
affichage du contenu tableau statique
[id=0, name=Ferid, age=25, salary=2000.0 Category: Ingenieur]
[id=1, name=Samia, age=30, salary=3000.1 Category: Directeur]
---------------- ArrayList-------------------
affichage du contenu ArrayList
[id=1, name=Samia, age=30, salary=3000.1 Category: Directeur]
[id=0, name=Ferid, age=25, salary=2000.0 Category: Ingenieur]
---------------- LinkedList -------------------
affichage du contenu LinkedList
[id=1, name=Samia, age=30, salary=3000.1 Category: Directeur]
---------------- Set -------------------
Taille du set : 2
affichage du contenu Set
un
deux
---------------- Map-------------------
valeur associée à f est: [id=0, name=Said, age=27, salary=600.25 Category: Ouvrier]
liste des valeurs [[id=2, name=Nabiha, age=29, salary=1500.0 Category: Ingenieur], [id=0,
name=Salah, age=30, salary=600.25 Category: Ouvrier], [id=0, name=Said, age=27,
salary=600.25 Category: Ouvrier], [id=1, name=Fethi, age=32, salary=600.25 Category:
Ouvrier]]
liste des clés: [P, c, f, k] 11
Il existe une autre façon pour créer des listes en utilisant la méthode
statique asList() de la classe Arrays. Rappelons que cette classe
comporte un ensemble de méthodes statiques qui s’appliquent sur des
tableaux.
// continuons avec le même exemple:
// autre façon de créer des listes avec méthodes statique de Arrays
[Link]("---------------- liste avec Arrays -------------------");
List<Employe> employes3 = [Link](new Employe(i,"Salah", 30, 600.25,
[Link]),new Employe(i++,"Said", 27, 600.25, [Link]));
for (Employe emp:employes3){
[Link](emp); }

---------------- liste avec Arrays -------------------

[id=3, name=Salah, age=30, salary=600.25 Category: Ouvrier]
[id=3, name=Said, age=27, salary=600.25 Category: Ouvrier]

12
 CLASSE COLLECTIONS
Classe identique à la classe Arrays avec des méthodes statiques qui s’applique
sur des collections:
 Tri: sort(List list) ; sort(List list,Comparator comp)
 Mélange aléatoire: shuffle(List liste) ;
 Manipulations: reverse(List liste) ; fill (List liste, Object element) ; copy(List
dest, List src) ;
 Recherche binaire: binarySearch(List list, Object element) ;
// continuons avec le même exemple:
// test des méthodes statiques de Collections
[Link]("---------------- classe Collections -------------------");
List<Integer> entiers = [Link](12,45,10,-5,56);
[Link](entiers); 13
for (Integer emp:entiers){
[Link](emp+" "); }
[Link]();
[Link]([Link](entiers, 45));
[Link]([Link](entiers, 6));
List<String> chaines = [Link]("Ali","Enicar","Car","Bac");
[Link](chaines);
for (String emp:chaines){
---------------- classe Collections -------------------
[Link](emp+" "); }
-5 10 12 45 56
[Link]();
3
[Link]([Link](chaines));
-2
}
Ali Bac Car Enicar
Enicar

// Comment faire le tri/chercher les bornes (…) d’une collection des

employés?

14
 LES INTERFACES DE
COMPARAISON
 Java propose l’interface générique Comparable <T> qui doit être
implémentée par une classe si nous voulons utiliser les méthodes de tri
d’Arrays ou Collections. Elle possède une seule méthode int compareTo(T
obj)
 retourne un entier négatif si l’objet qui fait l’appel est plus petit que obj
 nul (égal) si ils sont identiques,
 ou a positif (supérieur) si il est plus grand
 L’interface générique Comparator <T> propose une méthode int
compare(Object o1, Object o2). Celle-ci retourne un entier négatif, nul ou
positif si le premier objet est respectivement inférieur, égal ou supérieur au
deuxième

15
// Modifions le même exemple:
public class Employe implements Comparable<Employe> { // mêmes
attributs et méthodes
@Override
public int compareTo(Employe o) {
return ([Link]); } }
// dans la classe principale
List<Employe> employes4 = [Link](new Employe(0,"Salah", 30,
600.25, [Link]),new Employe(1,"Said", 27, 600.25,
[Link]));
[Link]("-----------tri avec Comparable -------");
-----------tri avec Comparable -------
[Link]("liste avant le tri"); liste avant le tri
for (Employe emp:employes4){ [id=0, name=Salah, age=30, salary=600.25
[Link](emp); } Category: Ouvrier]
[Link](employes4); [id=1, name=Said, age=27, salary=600.25 Category:
[Link]("liste après le tri"); Ouvrier]
for (Employe emp:employes4){ liste après le tri
[Link](emp); } [id=1, name=Said, age=27, salary=600.25 Category:
Ouvrier]
[id=0, name=Salah, age=30, salary=600.25
Category: Ouvrier]
16
// Modifions le même exemple: avec l’interface fonctionnelle Comparator
// dans la classe principale
List<Employe> employes5 = [Link](new Employe(0,"Salah", 30, 600.25,
[Link]),new Employe(1,"Said", 27, 1000.25, [Link]));
[Link]("-----------tri avec Comparator -------");
[Link]("liste avant le tri");
for (Employe emp:employes5){
[Link](emp); }
[Link](employes5, (o1,o2)->[Link]()-[Link]());
[Link]("liste après le tri d'age");
for (Employe emp:employes5){
[Link](emp); }
[Link](employes5, (o1,o2)->(int)([Link]()-[Link]()));
[Link]("liste après le tri de salaire");
for (Employe emp:employes5){ -----------tri avec Comparator -------
[Link](emp); } liste avant le tri
[id=0, name=Salah, age=30, salary=600.25 Category:
Ouvrier]
[id=1, name=Said, age=27, salary=1000.25 Category:
Ouvrier]
liste après le tri d'age
[id=1, name=Said, age=27, salary=1000.25 Category:
Ouvrier]
[id=0, name=Salah, age=30, salary=600.25 Category:
17
Ouvrier]
 AUTRES INTERFACES
FONCTIONNELLES
GÉNÉRIQUES
 public interface UTILES
Consumer <T> { void accept(T); }
 Parmi les méthodes des collections d’un type T: forEach
(Consumer<? Super T>)
// exemple d’utilisation
List <Employe> employes5 = [Link](new Employe(0,"Salah", 30, 600.25,
[Link]),new Employe(1,"Said", 27, 1000.25, [Link]));
// au lien de: for (Employe emp:employes5) { [Link](emp); }
// en utilisant les expressions Lambda
[Link]((Employe e) -> [Link](e));
// en utilisant reference au méthode:
[Link]([Link]::println);
18
 public interface Supplier <T> { T get(); }
 public interface Predicate <T> { boolean test(T); }
 public interface Function <T1, T2> { T2 apply(T1); }
// exemple d’utilisation
import [Link];
import [Link];
import [Link];
public class InterfacesUtiles { 120.0
Suceess
public static void main(String[] args) {
true
Function <Integer,Double> fun = i->i*10.0; [Link]([Link](12));
Supplier <String> supp = ()-> "Suceess"; [Link]([Link]());
Predicate <Double> pre = n-> n<20; [Link]([Link](15.0));}}
 public interface UnaryOperator <T> { T apply(T); }
 public interface BiFunction <T1,T2,T3> { T3 apply(T1,T2); }
 public interface BinaryOperator <T> { T apply(T,T); } 19
 LES STREAMS?
 Dans l’objectif des traitements des données (et pas l’enregistrement) Java a
introduit les flux ou streams
 Un stream se construit à partir d’une source de données (une collection, un
tableau ou des sources I/O par exemple), et possède un certain nombre de
propriétés spécifiques:
 Un stream ne stocke pas de données, contrairement à une collection
 Un stream ne modifie pas les données de la source sur laquelle il est construit.
 Un stream peut ne pas être borné, contrairement aux collections. Il faudra
cependant veiller à ce que nos opérations se terminent en un temps fini
 Un stream n’est pas réutilisable. Une fois qu’il a été parcouru, si l’on veut
réutiliser les données de la source sur laquelle il avait été construit, nous serons
obligés de reconstruire un nouveau stream sur cette même source.
20
Avant Java8: effectuer des traitements sur des Collections ou des
tableaux en Java passait essentiellement par l’utilisation du pattern
Iterator.
Java 8: propose l’API Stream pour simplifier ces traitements en
introduisant un nouvel objet, Stream.

21
 MÉTHODES DES STREAMS
Méthodes de création à partir des collections:
stream() et/ou parallel()

22
Méthodes intermédiaires

23
// exemple :
List<Integer> liste = new ArrayList<>();
[Link](12);[Link](45);[Link](-5);[Link](56); 12
Stream <Integer> str = [Link](); 45
Stream <Integer> str1 = [Link](e->e>0); 56
[Link]([Link]::println); cachalo
// ou en une seule ligne t
[Link]().filter(e->e>0).forEach([Link]::println); chamea
u
List<String> strings = [Link]("girafe", "chameau", "chat", "poisson", Chat
"cachalot"); 3.0
[Link]().filter(x -> 9.0
[Link]("cha")).sorted().forEach([Link]::println);
LinkedList <Point> points = new LinkedList();
[Link](new Point(-2,5));
[Link](new Point(7,2));
[Link]().map(p-> [Link]()+[Link]()).forEach([Link]::println);

maptoDouble
Autres formes de
map maptoInt
maptoLong
24
 [Link]("tri selon ordonnée croissante"); tri selon ordonnée
[Link]().sorted((p1,p2)->(int)([Link]()- croissante
[Link]())).forEach([Link]::println); Point: (7.0,2.0 )
Méthodes terminales: Point: (-2.0,5.0 )
 collect(méthode statique de public record Commande(String nom, double prix,
Collectors): Client client) { }
public class TerminalesStreams {
La collecte permet de créer un public static void main(String[] args) {
nouvelle collection à partir d’un List<Commande> mesCommandes =
stream [Link](new Commande("Stylos",5.0,new
// exemple: Client(78945689,"Ali")),new
public class Client { Commande("Cartbale",20.5,new
private int rip; private String nom; Client(78941789,"Samia")), new
public Client(int rip, String nom){ Commande("feuilles",7.2,new
[Link] = rip; [Link] = nom; } Client(78945689,"Ali")));
public int getRip(){return rip;} List<Client> mesClients =
public String getNom(){return nom;} [Link]().map( c ->
public void setRip(int rip){[Link] = rip;} [Link]()).collect( [Link]() );
public void setNom(String nom){[Link] = [Link]([Link]::println);
nom;} Nom du client = Ali de rip: 78945689
double
Nom duchiffreAffaire = de rip: 78941789
client = Samia
@Override [Link]().collect( [Link]
public String toString(){ Nom du client = Ali de rip: 78945689
gDouble(
32.7 Commande::prix ) );
return "Nom du client = "+nom+" de rip: [Link](chiffreAffaire); }} 25
"+rip;}
 Quelques méthodes statiques de Collectors: toList(), toSet(),
summingDouble(), summingInt(), joining(), groupingBy()…

// continuons l’exemple:
String joined =
[Link]().map(Commande::toString).collect([Link](",")
);
[Link](joined);
Commande[nom=Stylos, prix=5.0, client=Nom du client = Ali de rip:
78945689],Commande[nom=Cartbale, prix=20.5, client=Nom du client = Samia de rip:
78941789],Commande[nom=feuilles, prix=7.2, client=Nom du client = Ali de rip: 78945689]

Map<String, List<Commande>> map =

[Link]().collect([Link](Commande::nom));
[Link]().forEach([Link]::println);
[Link]().forEach([Link]::println);
Stylos
Cartbale
feuilles
[Commande[nom=Stylos, prix=5.0, client=Nom du client = Ali de rip: 78945689]]
[Commande[nom=Cartbale, prix=20.5, client=Nom du client = Samia de rip: 78941789]]
[Commande[nom=feuilles, prix=7.2, client=Nom du client = Ali de rip: 78945689]] 26
  La réduction
La réduction consiste à obtenir un résultat unique à partir d’un stream. Les
réductions simples sont celles auxquelles on pourrait penser en premier lieu :
La somme d’éléments ([Link]), le maximum ([Link]), ou le nombre
d’éléments
// continuons([Link])
l’exemple: sont des réductions simples
OptionalDouble moy = [Link]().mapToDouble(c-
>[Link]()).average(); OptionalDouble[10.9]
[Link](moy); OptionalDouble[20.5]
OptionalDouble maximum = [Link]().mapToDouble(c- OptionalDouble[5.0]
>[Link]()).max(); 3
[Link](maximum);
OptionalDouble minimum = [Link]().mapToDouble(c-
>[Link]()).min();
[Link](minimum);
L’API
Long nbr =streams introduit la notion de Optional. Certaines opérations de
[Link]().mapToDouble(c->[Link]()).count();
[Link](nbr);
réduction peuvent ne pas être possibles. Par exemple, le calcul de la
moyenne n’est pas possible si le stream ne contient aucun élément. La
méthode average qui permet de calculer la moyenne d’un stream
numérique retourne donc un OptionalDouble qui permet de représenter
soit le résultat, soit le fait qu’il n’y a pas de résultat. On peut appeler la
méthode [Link]() pour s’assurer qu’il existe 27
un
 AUTRES MÉTHODES DE
CRÉATION DES STREAMS
Stream <Integer> str = [Link] (3,9,7,5,1);

of Point [] tabp = {new Point(2,1), new Point(7,0)};

Stream <Point> strp = [Link](tabp);

IntStream str = [Link] (3,9,7,5,1);

iterate
iterate(T seed, UnaryOperator<T>)

[Link](5,i->i*10)

generate
generate(Supplier<? extends T>)

[Link](()-> "bonjour "); // Stream infini de String

(bonjour)
[Link](Math::random); // Stream infini 28
// spécifique IntStream
[Link](20,23); // suite : 20,21,22
[Link](20,23); //suite : 20,21,22,23

// Pour exécuter l’exemple traité sur les streams vous avez besoin
des ces importations:
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

29