CODER EN JAVA

CHAPITRE n° 1
Coder une application en JAVA

1. Introduction à JAVA
2. Introduction des notions de base en JAVA
3. Programmation OO en JAVA
4. Gestion des exceptions en JAVA
5. Gestion des entrées et sorties
6. Manipulation des collections
 01 – Coder une application en JAVA
Manipulation des collections

Définition

• Les collections sont des objets qui permettent de gérer des ensembles d'objets. Ces ensembles de données peuvent être définis avec plusieurs caractéristiques : la

possibilité de gérer des doublons, de gérer un ordre de tri, etc. ...

• Chaque objet contenu dans une collection est appelé un élément.

• L'API Collections propose un ensemble d'interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections,

chacune définie par une interface de base :

• List : collection d'éléments ordonnés qui accepte les doublons ;

• Set : collection d'éléments non ordonnés par défaut qui n'accepte pas les doublons ;

• Map : collection sous la forme d'une association de paires clé/valeur ;

PARTIE 1

• Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu'ils ne soient extraits pour traitement.

3
 01 – Coder une application en JAVA
Manipulation des collections

Les interfaces des collections

• Le Framework de java 2 définit 6 interfaces en relation directe avec

• L'API Collections possède deux grandes
les collections qui sont regroupées dans deux arborescences :
familles chacune définies par une interface :

• [Link] : pour gérer un groupe

d'objets.

• [Link] : pour gérer des éléments de

PARTIE 1

type paires de clé/valeur.

4
 01 – Coder une application en JAVA
Manipulation des collections

La hiérarchie des collections

PARTIE 1

5
 01 – Coder une application en JAVA
Manipulation des collections

Les interfaces des collections

Map
Set List
collection sous la forme
collection d'éléments uniques collection avec doublons
clé/valeur

Tableau redimensionnable ArrayList, Vector

Arbre TreeSet TreeMap

Liste chaînée LinkedList

PARTIE 1

Collection utilisant une table

HashSet LinkedHashSet HashMap, HashTable
de hachage

6
 01 – Coder une application en JAVA
Manipulation des collections

L'interface Collection
Cette interface définit plusieurs méthodes :

Méthode Rôle

boolean add(Object) ajoute l'élément fourni en paramètre à la collection. La valeur de retour indique si la collection a été mise à jour

boolean addAll(Collection) ajoute à la collection tous les éléments de la collection fournie en paramètre
void clear() supprime tous les éléments de la collection
boolean contains(Object) indique si la collection contient au moins un élément identique à celui fourni en paramètre

boolean containsAll(Collection) indique si tous les éléments de la collection fournie en paramètre sont contenus dans la collection

boolean isEmpty() indique si la collection est vide

Iterator iterator() renvoie un objet qui permet de parcourir l'ensemble des éléments de la collection
boolean remove(Object) supprime l'élément fourni en paramètre de la collection. La valeur de retour indique si la collection a été mise à jour
PARTIE 1

boolean removeAll(Collection) supprime tous les éléments de la collection qui sont contenus dans la collection fournie en paramètre

int size() renvoie le nombre d'éléments contenu dans la collection

Object[] toArray() renvoie d'un tableau d'objets qui contient tous les éléments de la collection

7
 01 – Coder une application en JAVA
Manipulation des collections

L'interface Iterator

Cette interface définit des méthodes pour des objets capables de parcourir les données d'une collection.

Méthode Rôle

boolean hasNext() indique s'il reste au moins un élément à parcourir dans la collection

Object next() renvoie le prochain élément dans la collection

void remove() supprime le dernier élément parcouru

PARTIE 1

8
 01 – Coder une application en JAVA
Manipulation des collections

Exemple

Iterator iterator = [Link]();

while ([Link]()) {
[Link]("objet = "+[Link]());
}

Remarque :
La méthode remove() permet de supprimer l'élément renvoyé par le dernier appel à la méthode next(). Il est ainsi impossible d'appeler la
méthode remove() sans un appel correspondant à next() : on ne peut pas appeler deux fois de suite la méthode remove().

Iterator iterator = [Link]();

PARTIE 1

if ([Link]()) {
[Link]();
ité[Link]();
}

9
 01 – Coder une application en JAVA
Manipulation des collections

List

Une liste est une collection ordonnée d'éléments qui autorise d'avoir des doublons. Etant ordonné, un élément d'une liste peut être accédé à

partir de son index.

• Les collections qui implémentent cette interface autorisent les doublons dans les éléments de la liste.

• Ils autorisent aussi l'insertion d'éléments null ;

• L'interface List propose plusieurs méthodes pour un accès à partir d'un index aux éléments de la liste.

• La gestion de cet index commence à zéro ;

• Pour les listes, une interface particulière est définie pour assurer le parcours dans les deux sens de la liste et assurer des mises à jour :
PARTIE 1

l'interface ListIterator.

10
 01 – Coder une application en JAVA
Manipulation des collections

Méthode
List Rôle
Iterator iterator() renvoie un objet capable de parcourir la liste
Object set (int, Object) remplace l'élément contenu à la position précisée par l'objet fourni en paramètre

void add(int, Object) ajouter l'élément fourni en paramètre à la position précisée

Object get(int) renvoie l'élément à la position précisée
int indexOf(Object) renvoie l'index du premier élément fourni en paramètre dans la liste ou -1 si l'élément n'est pas dans la liste

ListIterator listIterator() renvoie un objet pour parcourir la liste et la mettre à jour

List subList(int,int) renvoie un extrait de la liste contenant les éléments entre les deux index fournis (le premier index est inclus et le second est exclu). Les
éléments contenus dans la liste de retour sont des références sur la liste originale. Des mises à jour de ces éléments impactent la liste
originale.
PARTIE 1

int lastIndexOf(Object) renvoie l'index du dernier élément fourni en paramètre dans la liste ou -1 si l'élément n'est pas dans la liste

Object set(int, Object) remplace l'élément à la position indiquée avec l'objet fourni

11
 01 – Coder une application en JAVA
Manipulation des collections

List

Le Framework propose des classes qui implémentent l'interface List : LinkedList, Vector et ArrayList.
PARTIE 1

12
 01 – Coder une application en JAVA
Manipulation des collections

ArrayList
Cette classe représente un tableau d'objets dont la taille est dynamique.

Méthode Rôle
boolean add(Object) ajoute un élément à la fin du tableau
boolean addAll(Collection) ajoute tous les éléments de la collection fournie en paramètre à la fin du tableau
boolean addAll(int, Collection) ajoute tous les éléments de la collection fournie en paramètre dans la collection à partir de la position précisée
void clear() supprime tous les éléments du tableau
void ensureCapacity(int) permet d'augmenter la capacité du tableau pour s'assurer qu'il puisse contenir le nombre d'éléments passé en paramètre
Object get(index) renvoie l'élément du tableau dont la position est précisée
int indexOf(Object) renvoie la position de la première occurrence de l'élément fourni en paramètre
boolean isEmpty() indique si le tableau est vide
int lastIndexOf(Object) renvoie la position de la dernière occurrence de l'élément fourni en paramètre
Object remove(int) supprime dans le tableau l'élément fourni en paramètre
PARTIE 1

void removeRange(int,int) supprime tous les éléments du tableau de la première position fourni incluse jusqu'à la dernière position fournie exclue
Object set(int, Object) remplace l'élément à la position indiquée par celui fourni en paramètre
int size() renvoie le nombre d'élément du tableau
void trimToSize() ajuste la capacité du tableau sur sa taille actuelle

13
 01 – Coder une application en JAVA
Manipulation des collections

ArrayList
public static void main(String[] args) {

ArrayList liste = new ArrayList();

[Link]("sendes");
[Link]("rachid");
[Link](14);
[Link](14.02);
[Link](new Date());

Iterator it = [Link]();
PARTIE 1

while([Link]())
[Link]([Link]());
}

16
 01 – Coder une application en JAVA
Manipulation des collections

Liste de String

public static void main(String[] args) {

ArrayList<String> liste = new ArrayList<String>();
[Link]("Amal");
[Link]("Younes");
[Link]("Yassine");
[Link]("Taha");

Iterator<String> it = [Link]();
while ([Link]())
[Link]([Link]());

for (String s : liste)

[Link](s);
PARTIE 1

for (int i = 0; i < [Link](); i++)

[Link]([Link](i));
}

17
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Que sera le résultat de ce programme ?

public static void main(String[] args) {

ArrayList<String> liste = new ArrayList<String>();
[Link]("Amal");
[Link]("Younes");
[Link]("Yassine");
[Link]("Taha");

[Link](1, "Halima");
[Link](1, "Safa");
PARTIE 1

for(String s : liste)
[Link](s);
}

18
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Expliquez la différence entre les deux déclarations :

List <String> liste = new ArrayList<String>();

ArrayList <String> liste = new ArrayList<String>();

PARTIE 1

19
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Expliquez la différence entre les deux déclarations :

List <String> liste = new ArrayList<String>();

ArrayList <String> liste = new ArrayList<String>();

Ici, List<String> est une déclaration de type d'interface et ArrayList<String>() est une implémentation concrète.
En utilisant le type d'interface (List<String>), vous suivez le principe de « programmation sur une interface, pas sur une
implémentation ». C'est une bonne pratique car elle permet plus de flexibilité dans votre code. Si vous décidez plus tard que
vous souhaitez modifier l'implémentation d'ArrayList en autre chose (par exemple, LinkedList), vous pouvez le faire sans
modifier le reste de votre code qui repose sur l'interface List.
PARTIE 1

On parle de polymorphisme d’interface.

20
 01 – Coder une application en JAVA
Manipulation des collections

Tri d’une liste

ArrayList<String> list = new ArrayList<String>();
[Link]("said");
[Link]("wafa");
[Link]("ali");
[Link]("amal");

[Link](1, "hind");
[Link](3, "karim");

[Link](list);
PARTIE 1

[Link](list);

21
 01 – Coder une application en JAVA
Manipulation des collections

Tri d’une liste des étudiants

public class Etudiant implements Comparable<Etudiant> {
• public static void main(String[] args) {
• List<Etudiant> e = new ArrayList<Etudiant>();
private String nom; • [Link](new Etudiant("Safi", "kamal"));
private String prenom; • [Link](new Etudiant("Alami", "said"));
• [Link](new Etudiant("Alaoui", "wafa"));
public Etudiant(String nom, String prenom) { • [Link](new Etudiant("Rami", "ali"));
super(); • [Link](new Etudiant("Safi", "Amal"));
[Link] = nom;
[Link] = prenom;
} • for(Etudiant ee : e)
public String toString() { • [Link](ee);
return [Link] + " " + [Link];
} • [Link](e);
public int compareTo(Etudiant e) {
if () • [Link]("Après le tri");
PARTIE 1

return [Link]([Link]);
• for(Etudiant ee : e)
else
return [Link]([Link]); • [Link](ee);
} • }
}

22
 01 – Coder une application en JAVA
Manipulation des collections

List : LinkedList
public class ListExample {
public static void main(String args[]) {
LinkedList<String> queue = new LinkedList<String>();
• [Clara, Elizabeth, Gene,
[Link]("Bernadine");
[Link]("Elizabeth");
[Link]("Gene");
Elizabeth, Bernadine]
[Link]("Elizabeth");
[Link]("Clara");
• [Clara, Elizabeth, Gene]
[Link](queue);

[Link]();
• [Elizabeth, Gene]
[Link]();
[Link]();
PARTIE 1

[Link](queue);
}
}

23
 01 – Coder une application en JAVA
Manipulation des collections

Set

C'est une interface identique à celle de Collection. Trois implémentations possibles :

• TreeSet: les éléments sont rangés de manière triée ;

• HashSet: les éléments sont rangés suivant une méthode de hachage ;

• LinkedHashSet: Comme HashSet mais les éléments sont accessibles en ordre d’insertion (L’ordre d’affiche est le même que

l’ordre d’insertion).
PARTIE 1

24
 01 – Coder une application en JAVA
Manipulation des collections

Fonction de hachage

• Une fonction de hachage permet de transformer une clé en une valeur de hachage (un index), donnant ainsi la position d'un

élément dans le tableau.

• Si la clé n'est pas un entier naturel, il faut trouver un moyen de la considérer comme tel. Par exemple, si la clé est de

type chaine de caractères, on peut calculer la somme des positions dans l'alphabet de chaque lettre pour obtenir un entier

naturel.
PARTIE 1

25
 01 – Coder une application en JAVA
Manipulation des collections

Fonction de hachage : Exemple

Exemple simple de fonction de hachage sur des chaînes de longueur l à valeurs dans l'intervalle [0, N - 1] :

public static final int B=256;

public static final int N=311;

public static int hash(String ch){

int v = 0;

int i;

for (i=0; i<[Link](); i++) {

v = (v*B + [Link](i)) % N;
PARTIE 1

return v;

26
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Que sera le résultat du programme suivant :

public static void main(String[] args) {

Set <String> set = new TreeSet<String>();

[Link]("said");
[Link]("alae");
[Link]("reda");
[Link]("ilham");
[Link]("said");
[Link]("amal");
PARTIE 1

[Link]("zineb");
for(String s : set)
[Link](s);
}

27
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Que sera le résultat du programme suivant :

public static void main(String[] args) {

Set set = new TreeSet();

[Link]("zineb");

[Link]("salma");

[Link](14);

[Link]("amine");

for(Object o : set)
PARTIE 1

[Link](o);

28
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Que sera le résultat du programme suivant :

import [Link].*;
public class SetExample {
public static void main(String args[]) {
Set<String> set = new HashSet<String>(); // Une table de Hachage
[Link]("Bernadine");
[Link]("Elizabeth");
[Link]("Gene");
[Link]("Elizabeth");
[Link]("Clara");
[Link](set);
PARTIE 1

Set<String> setTrie = new TreeSet<String>(set); // Un Set trié

[Link](setTrie);
}
}

29
 01 – Coder une application en JAVA
Manipulation des collections

Exercice
Que sera le résultat du programme suivant :

public static void main(String[] args) {

Set <String> set = new LinkedHashSet<String>();

[Link]("said");
[Link]("sendes");
[Link]("reda");
[Link]("ilham");
[Link]("said");
[Link]("amal");
[Link]("zineb");
PARTIE 1

for(String s : set)
[Link](s);
}

30
 PARTIE 1

Here

31
 01 – Coder une application en JAVA
Manipulation des collections

Map

• Un groupe de paires contenant une clé et une valeur associée à cette clé. Cette interface n'hérite ni de Set ni de Collection. La

raison est que Collection traite des données simples alors que Map des données composées (clé,valeur).

• SortedMap est un Map trié.

PARTIE 1

32
 01 – Coder une application en JAVA
Manipulation des collections

HashTable
Un HashTable est une implémentation de Map qui associe une clé à une valeur. N'importe quel objet, mis à part null peut y être ajouté.

Map monHashtable = new Hashtable() ;

[Link](new Integer(1),"Janvier");
[Link](new Integer(2),"Fevrier");
[Link](new Integer(3),"Mars");
[Link](new Integer(4),"Avril");
[Link](new Integer(5),"Mai");
[Link](new Integer(6),"Juin");
[Link](new Integer(7),"Juillet");
[Link](new Integer(8),"Aout");
[Link](new Integer(9),"Septembre");
[Link](new Integer(10),"Octobre");
[Link](new Integer(11),"Novembre");
PARTIE 1

[Link](new Integer(12),"Décembre");
[Link](monHashtable);

{12=Décembre, 11=Novembre, 10=Octobre, 9=Septembre, 8=Aout, 7=Juillet, 6=Juin, 5=Mai, 4=Avril, 3=Mars, 2=Fevrier, 1=Janvier}

33
 01 – Coder une application en JAVA
Manipulation des collections

TreeMap

TreeMap<Integer, String> map = new TreeMap<Integer, String>();

[Link](new Integer(2), "Donnée 2");

[Link](new Integer(1), "Donnée 1");

[Link](new Integer(3), "Donnée 3");

[Link]([Link](2));

Set <Integer> set = [Link]();

for(Integer c : set){

[Link]([Link](c));
PARTIE 1

34
 PARTIE 1

HERE

35
 01 – Coder une application en JAVA
La Manipulation des collections

Définition

• La généricité équivalant au template en C++ est probablement la fonctionnalité la plus demandée dans Java depuis son origine. Intégrée à Java 5.0, la généricité est

utilisée par les classes de collection pour laisser le choix au programmeur de spécifier une classe différente de « Object » comme classe des éléments stockés. La classe

des éléments est spécifiée entre les symboles < et > qui suivent la classe de collection.

• Par exemple, ArrayList <Integer> représente une collection de classe dans laquelle seuls des objets de classe Integer pourront être ajoutés. La généricité simplifie alors

la consultation des éléments d’une collection en évitant de faire appel à l’opérateur de cast.
PARTIE 1

36
 01 – Coder une application en JAVA
Manipulation des collections

Supposons qu’on souhaite développer un type pour gérer une valeur qui change de type (int, float, String, etc.), ainsi, il faut créer autant de classe que de types visés.

Généricité - problématique

StringValue IntegerValue FloatValue BooleanValue DoubleValue

value : String value : Inetger value : float value : boolean value : double

Value <T>

value : T
PARTIE 1

Les types génériques apportent une solution simple et efficace

à une telle problématique, en développant une seule classe générique.

37
 01 – Coder une application en JAVA
Manipulation des collections

public class Triple<T> {

Exemple 1 : Classe générique
private T premier;
private T second;
private T troisieme;

Triple<T> public Triple(T premier, T second, T troisieme) {

- Premier :T [Link] = premier;
- Second :T [Link] = second;

- Troisième :T [Link] = troisieme;

}
public void affiche(){
[Link]([Link]+" "+
PARTIE 1

[Link]+" "+[Link] );
}
}

38
 01 – Coder une application en JAVA
Manipulation des collections

Exemple 1 : Classe générique

public class Test {

public static void main(String[] args) {
Triple <Integer> c1 = new Triple <Integer>(12, 23, 23);
[Link]();
Triple <String> c2 = new Triple <String>("Karim", "Mohamed", "Amine");
[Link]();
}
}
PARTIE 1

39
 01 – Coder une application en JAVA
Manipulation des collections

Exemple 2 : Classe générique

public class Triple <T1, T2, T3> { Triple <String, String, String> t1 =
private T1 a; new Triple<String, String, String>(
private T2 b; "kamal", "iamne","safa");
private T3 c;
[Link]();
Triple <Integer, String, Double> t2 =
public Triple(T1 a, T2 b, T3 c) { new Triple<Integer, String, Double>
this.a = a; (12,"imane", 12.99);
this.b = b; [Link]();
this.c = c;
}
public void affiche(){
PARTIE 1

[Link](this.a +" "+this.b+" "+this.c);

}
}

40
 01 – Coder une application en JAVA
Manipulation des collections

Généricité et collection

• Vous pouvez aussi utiliser la généricité sur les objets servant à gérer des collections ;

• C'est même l'un des points les plus utiles de la généricité ;

• En effet, lorsque vous listiez le contenu d'un ArrayList par exemple, vous n'étiez JAMAIS sûrs à 100 % de savoir sur quel type de référence vous alliez tomber.
PARTIE 1

41
 01 – Coder une application en JAVA
Manipulation des collections

Généricité et collection
import [Link];

[Link]("\nListe de float");
public class Test {
[Link]("------------------------");
public static void main(String[] args) {
ArrayList<Float> listeFloat = new ArrayList<Float>();
[Link]("Liste de String");
[Link]("------------------------------"); [Link](12.25f);
ArrayList<String> listeString= new ArrayList<String>(); [Link](15.25f);
[Link]("Une chaîne");
[Link](2.25f);
[Link]("Une Autre");
[Link]("Encore une autre"); [Link](128764.25f);

[Link]("Allez, une dernière"); for(float f : listeFloat)

for(String str : listeString)
[Link](f);
PARTIE 1

[Link](str);
}

42
 01 – Coder une application en JAVA
Manipulation des collections

Héritage et généricité

//Un ArrayList n'acceptant que des instances de Voiture ou de ses sous-classes

ArrayList<? extends Voiture> listVoitureSP = new ArrayList<VoitureSansPermis>();

PARTIE 1

43
 01 – Coder une application en JAVA
Manipulation des collections

Héritage et généricité
Exercice : Créer une méthode qui autorise un objet de type List de n'importe quel super classe de la classe Voiture, Voiture y compris.

• static void affiche(List<? super Voiture> list) {

• for(Object v : list)
• [Link]([Link]());
}
PARTIE 1

44
 PARTIE 1

45