Java OO

Par:
IALA Imad
Collections
 Classes d'usage courant

L'une des classes les plus utilisées en Java pour gérer un ensemble de données est :

Les Collections
 Les collections
Collections:
• Les collections sont des objets qui Ici, nous n'avons pas de
permettent de gérer des ensembles d'objets. limite n comme dans les
tableaux statiques.
• Les collections proposent une solution au
stockage de données et permettent une
manipulation de celles-ci:

 La possibilité de gérer des doublons, de

gérer un ordre de tri, etc. un protocole
particulier pour l’ajout, le retrait et la
recherche d’éléments.

 Chaque objet contenu dans une

collection est appelé un élément.
 Les collections (généralités)
Collections généralités:

• Dans la version 1 du J.D.K., il n'existe qu'un nombre restreint de classes pour gérer des
ensembles de données :
 Vector, Stack, Hashtable, Bitset.

• Pour combler le manque d'objets adaptés, la version 2 du J.D.K. apporte un framework

complet pour gérer les collections.

 Cette bibliothèque contient un ensemble de classes et interfaces.

 Elle fourni également un certain nombre de classes abstraites qui
implémentent partiellement certaines interfaces.
 Implémentation de méthodes (des algorithmes) liées aux collections
(recherche, tri, etc.).
 Classes d'usage courant

Les collections sont définies à partir de deux Interfaces Java :

Collection and Maps

 Les collections
aperçu
• Voyons la hiérarchie du
framework Collection.

• Le package [Link]
contient toutes les classes et
interfaces pour le framework
Collection.

• Ces classes représentent une

collection de données (une
collection de valeurs)
 Les collections : méthodes

[Link]
 Les collections (Interfaces)
• Les interfaces à utiliser par des objets qui gèrent
des collections sont :

 Collection :
Interface : qui est implémentée par la plupart
des objets qui gèrent des collections.

 Set :
Interface : pour des objets qui n'autorisent pas
la gestion des doublons dans l'ensemble.

 List :
Interface : pour des objets qui autorisent la
gestion des doublons et un accès direct à un
élément.

 SortedSet :
Interface : qui étend l'interface Set et permet
d'ordonner l'ensemble.
 Les collections (Classes - List)
• Les classes à utiliser pour créer des collections de type
List (gestion des doublons) sont :

 ArrayList (Non synchronisée):

Classe : Tableau dynamique qui implémente
l'interface List.

 LinkedList :
Classe : Liste doublement chaînée (parcours de la
liste dans les deux sens) qui implémente
l'interface List.

 Vector (Synchronisée) :
Classe : Implémentation qui nous permet de
créer des tableaux redimensionnables similaires à
la classe ArrayList.
Vector with Last
• Remarque : Il est recommandé d'utiliser ArrayList à la In First Out
place de Vector car les vecteurs sont moins efficaces.
 Les Lists - exemple
public static void main(String args[]){
ArrayList<String> al=new ArrayList<String>();
public static void main(String args[]) {
//Create an empty Vector
[Link]("Mango");
Vector<Integer> in = new Vector<>();
[Link]("Apple");
//Add elements in the vector
[Link]("Apple");
[Link](100);
[Link]("Apple");
[Link](200);
[Link]("Grapes");
[Link](300);
[Link](200);
//accessing the element
[Link]("Element: "+[Link](1));
//Display the vector elements
//changing the element
[Link]("Values in vector: " +in);
[Link](1,"Dates");
// Delete the first occurence of an element
//Removing element
[Link]((Integer)200);
[Link](2);
//Display the vector elements afre remove() method
//Traversing list
[Link]("Values in vector: " +in);
for (int i = 0; i < [Link](); i++) {
//Remove the element at index 4
[Link]([Link](i));
[Link]("Remove element: " +[Link](2));
}
[Link]("New Value in vector: " +in);
// Get element at position
for(String fruit:al)
[Link]("Element at index 1: "+[Link](1));
[Link](fruit);
}
}
}
 Les collections (Classes - Set)
• Parmi les classes à utiliser pour créer des
collections de type Set (gestion des doublons)
sont :

 HashSet :
Classe : Tableau qui n’autorise pas les
doublons.

 LinkedHashSet :
Classe : Liste doublement chaînée qui
n’autorise pas les doublons.

 TreeSet :
Classe : Arbre qui implémente l'interface
SortedSet.
 L’interface Iterator

 Une interface permettant d'énumérer les éléments contenus dans une collection.
 Toutes les collections proposent une méthode iterator renvoyant un
itérateur.
 Permet un parcours dans un sens uniquement.
 Les Sets - exemple

public static void main(String args[]){

//Creating HashSet and adding elements public static void main(String args[]){
HashSet<String> set=new HashSet(); LinkedHashSet<String> al=new LinkedHashSet<String>();

[Link]("One"); [Link]("Ravi");
[Link]("Two"); [Link]("Vijay");
[Link]("Three"); [Link]("Ravi");
[Link]("Four"); [Link]("Ajay");
[Link]("Four");
Iterator<String> itr=[Link]();
Iterator<String> i=[Link](); while([Link]()){
while([Link]()) [Link]([Link]());
{ }
[Link]([Link]()); }
}
}
 Les collections (List)
 ArrayList:
o Une classe qui utilise un tableau dynamique pour stocker les éléments. C'est comme un
tableau, mais il n'y a pas de limite de taille. Nous pouvons ajouter ou supprimer des
éléments à tout moment (tableau à taille variable).

 LinkedList:
o Une classe qui utilise une liste doublement chaînée pour stocker les éléments. Il fournit
une structure de données de liste chaînée (liste chaînée).

 ArrayList - Complexité :
o Les opérations add(E), size, isEmpty, get, set, iterator sont exécutées en temps constant.
o Les opérations d'ajout/suppression (add(index, E), remove, contains) sont exécutées en
temps linéaire O(n)(les ajouts/suppressions en fin de liste sont plus rapides).

 LinkedList - Complexité :
o Les opérations size, isEmpty, add, remove, set, get sont exécutées en temps constant.
o Toutes les méthodes qui font référence à un indice sont exécutées en temps O(n)
- Remove(i), get(i), add(i, E), ….. , contains.
 Les collections (Set)
 HashSet:
o Tableau qui n’autorise pas les doublons.

 TreeSet:
o Garantit que les éléments sont rangés dans leur ordre naturel (interface Comparable) ou
dans l'ordre d'un Comparator.

 HashSet - Complexité :
o Les opérations add, remove, contains et size sont exécutées en un temps constant.
 TreeSet - Complexité :
o Les opérations add, remove et contains sont exécutées en un temps log(n). La fonction
size est exécutée en un temps constant

• Remarque
- Si les données ne doivent pas avoir de doublon, on peut utiliser un HashSet.
- Si elles doivent en plus être triées, on utilise un TreeSet.
 Les collections- Map aperçu

• Voyons la hiérarchie du Map.

• Ces classes représentent une

collection de données sous
la forme clé/valeurs.
 Les collections - Map : méthodes

[Link]
 Map (Interfaces)

• Les interfaces à utiliser par des objets qui gèrent

des collections de type map sont :

 Map :
interface : qui définit des méthodes pour
des objets qui gèrent des collections sous la
forme clé/valeur.

 SortedMap :
interface : qui étend l'interface Map et
permet d'ordonner la Map.
 Map (Classes)

• Les Classes à utiliser par des objets qui gèrent

des collections de type map sont :

 HashMap :
Classe : Simple tableau de type clé / valeur.

 LinkedHashMap :
Classe : Liste doublement chaînée sous la
forme de type clé / valeur.

 TreeMap :
Classe : Arbre qui gère des données du type
clé / valeur.
 Les Maps - exemple
public static void main(String args[]){
HashMap<Integer,String> map=new HashMap<Integer,String>();
[Link](1,"Mango"); //Put elements in Map
[Link](2,"Apple");
[Link](3,"Banana");
[Link](4,"Grapes");

[Link]("Iterating Hashmap...");
for([Link] m : [Link]()){
[Link]([Link]()+" "+[Link]());
}
}

public static void main(String args[]){

TreeMap<Integer,String> map=new TreeMap<Integer,String>();
[Link](100,"Amit");
[Link](102,"Ravi");
[Link](101,"Vijay");
[Link](103,"Rahul");

for([Link] m : [Link]()){
[Link]([Link]()+" "+[Link]());
}
}
 Les Maps - exemple

class Personne { public static void main(String[] args) {

String CIN; // Création d'une carte de personne
Map<String,Personne> personneMap=new TreeMap<String,Personne>();
String nom; //Creating Books
String prenom; Personne p1=new Personne("HH11111","Hamid", "Hamid");
Personne p2=new Personne("HH22222","Karim", "Karim");
public Personne(String CIN, Personne p3=new Personne("HH33333","Idriss", "Idriss");
String nom, // Ajouter des personnes à la carte
String prenom) { [Link]([Link],p1);
[Link] = CIN; [Link]([Link],p2);
[Link] = nom; [Link]([Link],p3);
[Link] = prenom;
// Carte de cheminement
} for([Link]<String,Personne> entry:[Link]()){
} String key = [Link]();
Personne p = [Link]();
[Link]("CIN : "+key);
[Link](" Nom et prénom : "+[Link]+ " " +[Link]);
}
}
 Les Maps - exemple
class Book { public static void main(String[] args) {
int id; Map<Integer,Book> map=new TreeMap<Integer,Book>();
String name,author,publisher;
int quantity; Book b1=new Book(101,
"Let us C“,
public Book(int id, "Yashwant Kanetkar",
String name, "BPB",
8);
String author,
Book b2=new Book(102,
String publisher, "Data Communications & Networking",
int quantity) { "Forouzan",
"Mc Graw Hill",
[Link] = id; 4);
[Link] = name; Book b3=new Book(103,
[Link] = author; "Operating System“,
"Galvin",
[Link] = publisher; "Wiley",
[Link] = quantity; 6);
} //Adding Books to map
[Link](1,b1);
} [Link](2,b2);
[Link](3,b3);
//Traversing map
for([Link]<Integer, Book> entry:[Link]()){
int key=[Link]();
Book b=[Link]();
[Link](key+" Details:");
[Link]([Link]+" "+[Link]+" "+[Link]+" "+[Link]+" "+[Link]);
}
}
 Les collections (Map)

• Implémentation de l’interface Map :

 Des couples clé-valeur.
 Une clé identifie une valeur unique.
 Implémentations :

 HashMap - Complexité :
o Les fonctions: put, get, remove, containsKey et size sont exécutées en un temps
constant
o La fonction containsValue exécutée en un temps linéaire O(n).

 TreeMap - Complexité :
o La fonction size est exécutée en un temps constant
o Les fonctions put, get, remove (key), containsKey sont exécutées en O(log(n))
o La fonction containsValue est exécutée en O(n)
 Les collections

Synthèse, que choisir ?

 Les questions à se poser sont donc:

 Ai-je des doublons ?

 Dois-je privilégier le parcours ou l’insertion

et la suppression ?

 Mes données doivent elles être ordonnée ?

 Les collections et les types primitifs
• Les collections de [Link] ne peuvent pas contenir de valeurs de types primitifs.

• Il fallait donc utiliser explicitement les classes enveloppantes des types primitifs, Integer par
exemple.

• A partir du JDK 5, les conversions entre les types primitifs et les classes enveloppantes
peuvent être implicites avec le « boxing » / « unboxing ».

• Exemple
ArrayList <Integer>
c list = new ArrayList<>( );

[Link](10); // boxing: casting d’un entier en un objet Integer

[Link](-678);
[Link](87);
[Link](7);
int i = [Link](0); // unboxing: conversion d’un objet Integer en un entier.
 Les collections
Collections:
• Les collection (classes et interfaces) sont définies dans le package [Link]

• Liste de toutes les classes qui implémente l’interface Collection:

AbstractCollection, AbstractList, AbstractQueue, AbstractSequentialList, AbstractSet, ArrayBlockingQueue,
ArrayDeque, ArrayList, AttributeList, BeanContextServicesSupport, BeanContextSupport,
ConcurrentLinkedQueue, ConcurrentSkipListSet, CopyOnWriteArrayList, CopyOnWriteArraySet, DelayQueue,
EnumSet, HashSet, JobStateReasons, LinkedBlockingDeque, LinkedBlockingQueue, LinkedHashSet,
LinkedList, PriorityBlockingQueue, PriorityQueue, RoleList, RoleUnresolvedList, Stack, SynchronousQueue,
TreeSet, Vector.

• Liste de toutes les classes qui implémente l’interface Map:

AbstractMap, Attributes, AuthProvider, ConcurrentHashMap, ConcurrentSkipListMap, EnumMap, HashMap,
Hashtable, IdentityHashMap, LinkedHashMap, PrinterStateReasons, Properties, Provider, RenderingHints,
SimpleBindings, TabularDataSupport, TreeMap, UIDefaults, WeakHashMap.
 Boucle de type for each
Une autre alternative pour l'itération sur des structures, on utilise la boucle de type for each.

Syntaxe : for (Type var : Objet)

Exemple : for(String str : myList),

avec myList est un conteneur contenant des références sur des objets de String

import [Link].*;
class ForEachExample2{
public static void main(String args[]){
//Creating a list of elements
ArrayList<String> list=new ArrayList<String>();
[Link]("vimal");
[Link]("sonoo");
[Link]("ratan");
//traversing the list of elements using for-each loop
for(String s:list){
[Link](s);
}
}
}
 Les collections
• Des algorithmes qui ne s'appliquent que sur des listes:

 Trier:
sort(List list) : trie une liste (dans l’ordre croissant).
sort(List list,Comparator comp) : trie une liste en utilisant un comparateur.

 Mélanger:
shuffle(List liste) : mélange les éléments de manière aléatoire.

 Manipuler:
reverse(List liste) : inverse les éléments de la liste.
fill (List liste, Object element) : initialise les éléments de la liste avec element.
copy(List dest, List src) : copy une liste src dans une liste dest.

 Rechercher:
contains(Object element) : renvoie true si la liste contient l'élément spécifié.
indexOf(Object element) : renvoie l'index de la première occurrence de l'élément spécifié
dans la liste donnée, ou -1 si la liste ne contient pas l'élément.
Les collections
 Java

Récapitulatif Questions
Anomalies en java
 Anomalies
int data=100/0;
[Link]("rest of the code...");

• L’exécution d’un programme // ArithmeticException

peut provoquer des
anomalies graves ou moins String[] cs=null;
graves. [Link]([Link]());// NullPointerException

String s="abc";
• Utilisation d’un objet null.
int i=[Link](s); // NumberFormatException
Impossibilité de lire, d’écrire
ou de traiter des données par int a[]=new int[5];
exemple. a[10]=50; // ArrayIndexOutOfBoundsException
 Anomalies
import [Link];

class TestScanner{
public static void main(String[] args) {
Scanner entree = new Scanner([Link]); // entréec clavier
[Link]("First number :");
double num1 = [Link]();
[Link]("second number :");
double num2 = [Link]();
[Link]("Sum = "+(num1+num2));

}
}

Dans ce cas, nous ne

pouvons pas contrôler
l'entrée
 Gestion des exceptions

• Java contient un mécanisme qui permet à un programme d’être

averti par la JVM lorsque des anomalies surviennent et de réagir :

 Affichage d’un message d’erreur.

 Arrêt de l’exécution.

 Remettre les choses en place puis restaurer l’exécution

(programmes robustes aux erreurs).
 Gestion des exceptions

• Avantage :

 Maintenir le flux normal de l'application.

 Assurer une application robuste, disponible et l’ensemble des exigences

non fonctionnelle voulus.

 Assurez-vous que l'application ne plantera à aucun moment de

l'exécution.

 Sécuriser l'application.
 Gestion des exceptions
Anomalies

Exceptions
Erreurs

Exécution Compilation

Exceptions non contrôlées Exceptions contrôlées

- erreur interne de la JVM - erreur arithmétique - méthode non trouvée

- pas assez de mémoire - downcast interdit - erreur d’entrée/sortie
- pile d’exécution saturée - référence nulle - fichier non trouvé
- classe non trouvée - indice erroné - erreur d’accès à une base
- erreurs dans AWT - thread endormi interrompu
 Gestion des exceptions

• Exceptions contrôlées : Les exceptions vérifiées

sont vérifiées au moment de la compilation.

• Exceptions non contrôlées : Les exceptions non

vérifiées ne sont pas vérifiées au moment de la
compilation, mais elles sont vérifiées au moment
de l'exécution.

• Error : L'erreur est irrécupérable. Quelques

exemples d'erreurs sont OutOfMemoryError,
VirtualMachineError, AssertionError, [Link]
 Gestion des exceptions
Error class

Checked
Exception
(*)
Unchecked
Exception
 Gestion des exceptions

• La classe Error :

 Représente les erreurs système, de compilation, de matérielles ou des erreurs

internes à la JVM, dont on a pas à nous soucier.

o Les erreurs de type Error sont irrécupérables pour l’application.

• La classe RuntimeException:

 Elles sont imprévisibles, surviennent très fréquemment et peuvent être générées

n’importe où.

o Les erreurs de type RuntimeException sont gérées automatiquement par la

JVM.
 Les exceptions fréquentes
• NumberFormatException :
Conversion d’un texte en valeur numérique.

• ArrayIndexOutOfBoundsException :
Appel de champ de tableau qui n’existe pas.

• NullPointerException :
Un programme essaye d’appliquer la valeur null alors qu’un objet, non nul, est attendu.

• ArithmeticException :
Elle est déclenchée si une condition mathématiques erronée est exécutée.

• ClassCastException :
Elle est déclenchée lors d’une tentative d’utiliser le casting pour affecter une valeur à un objet, alors que ce casting
n’est pas valide.

• VirtualMachineError :
L’erreur se produit lorsque la machine virtuelle Java a été interrompue ou n’est pas en mesure de continuer à
fonctionner.
Rattraper et traiter une exception
Rattraper et traiter une exception
try {
// Code qui peut généré une exception

} catch(ExceptionType1 id1) {
// traitement de l’exception de Type1

} catch(ExceptionType2 id2) {
// traitement de l’ exception of Type2

} finally{
// passage obligatoire dans cette partie.

}
 Rattraper et traiter une exception

public class JavaExceptionExample{

public static void main(String args[]){
try{
//code that may raise exception
int data=100/0;
}catch(ArithmeticException e){

[Link](e);
}
//rest code of the program
[Link](“Exception Handling...");
}
}

Exemple 1
 Rattraper et traiter une exception
public double moyenne (double[] t){ // Tableau de deux cases
double moy = 0;
try{
for (int i = 0; i < 5; i++){

moy += t[i];
}
moy = moy / 2;
}catch (NullPointerException e){ // t est nulle
[Link](" le tableau manque. ");

}catch (ArrayIndexOutOfBoundsException e){

// Tableau ayant plus de 2 cases.
[Link]("Il faut 2 nombres, le tab doit être de longueur 2") ;
}catch (Exception e){
// erreur inattendue mais bloc non obligatoire.
[Link] ( ); // afficher la pile d’appel
}finally {
[Link]("On passe tjrs ici, aucune dérogation!. ");
return moy; // retourner la moyenne calculée ou 0 ;
}
}
 Rattraper et traiter une exception

• Si une méthode génère une exception, elle doit être levée et interceptée.

• On place les instructions susceptibles de générer des exceptions (région surveillée) dans un
bloc try, qui est suivie par
 le code qui traite ces exceptions dans un ou plusieurs gestionnaires d’exceptions.

• Les gestionnaires d’exceptions sont placés juste derrière le bloc try.

 Ils sont reconnaissables par le mot clé catch.
 Ils définissent la zone de traitement des exceptions, présentée dans le bloc catch

• Un gestionnaire d’exceptions pour chaque type d’exception.

Remarque:
Dans le bloc try, différentes méthodes peuvent générer la même exception.
 Rattraper et traiter une exception

• Le bloc finally { } est exécuté systématiquement qu’une exception

soit générée ou pas,

 ce bloc est facultatif, et vient après les blocs catch.

• Question: Quand avons nous besoin de la clause finally en Java ?

 Le bloc finally est nécessaire quand :
 Rattraper et traiter une exception

Remarque:
Il faut faire attention à bien traiter les exceptions « les plus précises » (les sous classes) avant les exceptions générales.
 Rattraper et traiter une exception
• Si nécessaire, nous pouvons nous-mêmes lever l'exception afin d'être catch avec la fermeture
"catch".
public class ExceptionMethods {
public static void main(String[] args) {
try {
throw new Exception("C’est mon Exception");
} catch(Exception e) {
[Link]("Caught Exception");
[Link]( "[Link](): " + [Link]());
[Link]("[Link](): " + [Link]());
[Link]("[Link](): " + e);
[Link]("[Link]():");
[Link]( );
}
}
}
 Propager une exception vers la fonction appelante

• Une fonction peut ne pas capturer les exceptions qu’elle reçoit mais se contente de les propager vers la
fonction qui l’a appelée.

public class Main {

public void checkAge(int age) throws ArithmeticException {

if (age < 18) {
throw new ArithmeticException("Access denied - You must be at least 18 years old.");
}
else {
[Link]("Access granted - You are old enough!");
}
}

public static void main(String[] args) {

checkAge(15); // Set age to 15 (which is below 18...) Must handle exception here
}
}
 Propager une exception vers la fonction appelante

• Une fonction peut ne pas capturer les exceptions qu’elle reçoit mais se contente de les
propager vers la fonction qui l’a appelée.

• Pour lever une exception au sein d’une méthode, on utilise la directive throw.
L’exécution de la méthode est arrêtée dès l’invocation de l’instruction throw qui transmet
à la fonction appelante l’exception crée.

• Les méthodes contenant la directive throw, sans capture de l’exception, doivent contenir
dans leur déclaration throws.

• Toutes les méthodes, appelant une méthode qui lève une exception, doivent
obligatoirement capturer cette exception ou la propager.
 Exceptions personnalisées

• On peut définir nos propres exceptions, qui devrons dériver de la classe Exception. Au point de vue
de la conception.

public class WrongFileNameException extends Exception {

public WrongFileNameException(String errorMessage) {

super(errorMessage);
}
}

• Nous utilisons une exception personnalisée pour :

 Pour intercepter et fournir un traitement spécifique à un sous-ensemble d'exceptions Java
existantes.

 Exceptions de logique métier : il s'agit des exceptions liées à la logique métier et au workflow.
 Exceptions personnalisées

Exception personnalisée
class InvalidAgeException extends Exception
{
public InvalidAgeException (String str)
{
Main
// calling the constructor of parent Exception
super(str); // main method
} public static void main(String args[])
} {
try
// class that uses custom exception InvalidAgeException {
public class TestCustomException1 // calling the method
{ validate(13);
}
// method to check the age catch (InvalidAgeException ex)
static void validate (int age) throws InvalidAgeException{ {
if(age < 18){ [Link]("Caught the exception");

// throw an object of user defined exception // printing the message from InvalidAgeException object
throw new InvalidAgeException("age is not valid to vote"); [Link]("Exception occured: " + ex);
} }
else {
[Link]("welcome to vote"); [Link]("rest of the code...");
} }
} }