Exposé Java Groupe 3

République du Cameroun Republic of Cameroon
Paix-Travail-Patrie Peace-Work-Fatherland
---------------------- ----------------------
Université de Yaoundé I University of Yaounde I
Sapentia-Collativia-Cognito Sapentia–Collativia–Cognito
---------------------- ----------------------
École Nationale Supérieure National Advanced
Polytechnique de Yaoundé School of Engineering
---------------------- ----------------------
Département du Génie Civil Department of Civil Engineering
3GC
INFORMATIQUE ET PROGRAMMATION GCU 332
Par les membres du groupe 3:
 BATCHANOU YANSE KIZIA (SOUS CHEF) 21P148

 DIKANDA HENRI 20P384
 FOWE SOH HURLIN 21P143
 MECHEDJEU DARELLE 21P216
 NGAI NWATSOK JOHANN 21P327
 NGUINI MBE DIEUDONNÉ VALENTIN 23P773
 TONTSA YMELE LEONNE NADIA 21P071
 WAFFO FOKOUA JULIUS CHANTIAL (CHEF) 21P044
Sous la supervision de l’Ingénieur de Conception de Génie Civil et Chercheur à

l’école doctorale de l’UY1 :
M. ENYEGUE GERMAIN
DEDICACES
Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 2
Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

Structures De Données En Java
Remerciements
REMERCIEMENTS
Au terme de ce travail, nous tenons à exprimer notre profonde gratitude envers tous
ceux qui ont participé au bon déroulement de cet exposé. Nos remerciements vont
particulièrement :
 Au directeur de l‟École Nationale Supérieure Polytechnique de Yaoundé Pr.

AYISSI
RAOUL ;
 Au chef de département de la filière Génie civil de l‟École Nationale Supérieure
Polytechnique de Yaoundé Pr. MANDJIA MARCELLINE ;
 À notre enseignant Monsieur ENYEGUE GERMAIN, à qui nous exprimons

toute notre reconnaissance ; d‟avoir encadré et encouragé la réalisation de cet
exposé.
Pour conclure, nous souhaitons adresser nos remerciements à nos parents, amis, et
camarades de la filière Génie civil et urbanisme et aussi tous ceux qui de près ou de
loin, ont contribué à la réalisation de ce travail.

Résumé
RESUMÉ
Les structures de données sont un concept de programmation très important. Elles

nous fournissent un moyen de stocker, d'organiser et de récupérer des données de manière
efficace. Les structures de données sont utilisées pour faciliter le travail avec nos données.
Le parcours de tout débutant en programmation commence par la résolution des
questions relatives aux tableaux qui sont utilisée dans toutes les situations possibles où on doit
rassembler les objets en un seul endroit. Qu'il s'agisse d'un logiciel simple ou complexe ou
d'une application Web, le tableau est principalement utilisé pour stocker et afficher les
données de manière dynamique sur les pages Web.
Les structures de données sont indispensables pour gérer efficacement de grandes
quantités de données, comme les informations stockées dans une base de données ou des
services d‟indexation. La bonne gestion d‟un système de données exige la capacité
d‟identifier la mémoire allouée, les relations entre les données et les processus de données.
Or, les structures de données facilitent ces opérations.
Par ailleurs, non seulement il est important d‟utiliser des structures de données, mais il
est également indispensable de choisir la structure adaptée à chaque tâche. Choisir une
structure de données universelle pourrait entraîner un ralentissement des temps de traitement
ou une absence de réponse du code. Plusieurs facteurs sont à prendre en compte lors du choix
d‟une structure de données : le type d‟information qui sera stocké, l‟emplacement de stockage
des données existantes, le mode de stockage des données, et la quantité de mémoire à réserver
aux données.
En résumé, on peut donc dire que ; En organisant d'une certaine manière les données,
on permet un traitement automatique de ces dernières plus efficace et rapide. Le fait d'utiliser
une structure de données appropriée à un traitement informatique peut également faire baisser
de manière significative la complexité d'une application informatique et ainsi contribuer à
diminuer le taux d'erreurs. D'où l'importance des structures de données en Java.

Abstract
ABSTRACT
Data structures are a very important programming concept. They provide us with a
way to store, organize and retrieve data efficiently. Data structures are used to make working
with our data easier.
The journey of any beginner in programming starts with solving questions relating to
arrays which are used in all possible situations where one needs to collect objects in one
place. Whether it is simple or complex software or a web application, table is mainly used to
store and display data dynamically on web pages.
Data structures are essential for efficiently managing large amounts of data, such as
information stored in a database or indexing services. Proper management of a data system
requires the ability to identify allocated memory, data relationships, and data processes.
However, data structures facilitate these operations.
Furthermore, not only is it important to use data structures, but it is also essential to
choose the right structure for each task. Choosing a universal data structure could result in
slower processing times or unresponsive code. Several factors must be taken into account
when choosing a data structure: the type of information that will be stored, the storage
location of existing data, the method of storing the data, and the amount of memory to reserve
for data.
In a nut shell, we can therefore say that; by organizing the data in a certain way, we
enable automatic processing of the data more efficiently and quickly. Using a data structure
appropriate for computer processing can also significantly reduce the complexity of a
computer application and thus help to reduce the error rate. Hence the importance of data
structures in Java.
5
Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par :
Liste Des Figures
LISTE DES FIGURES
Figure 1: Interfaces En Java......................................................................................................... 41

Figure 2 : Interface Closeable ...................................................................................................... 75

Liste Des Images
LISTE DES IMAGES
Image 1 : Exemples D’utilisations Des Opérateurs De Transtypage ............................................. 26

Image 2 : Les Différentes Bases Numériques .............................................................................. 27
Image 3 : Utilisation Du Groupage De Chiffres........................................................................... 27
Image 4 : Résultat De L’utilisation Du Groupage De Chiffre....................................................... 28
Image 5 : Formatage D’un Entier À L’affichage ........................................................................ 28
Image 6 : Exemple D’utilisation Des Opérateurs Arithmétiques .................................................. 29
Image 7 : Forcer La Priorité....................................................................................................... 29
Image 8 : Exemple D’une Division Entière ................................................................................. 29
Image 9 : Autre Exemple D'une Division Entière ........................................................................ 30
Image 10 : Utilisation Des Operateur De Comparaison ............................................................... 30
Image 11 : Utilisation Des Opérateurs Sur Les Réels ................................................................... 32
Image 12: Utilisation Des Opérateurs De Comparaisons Avec Les Réels ...................................... 32
Image 13: Extrait Du Standard Unicode ..................................................................................... 33
Image 14: Test Sur Les Caractères ............................................................................................. 34
Image 15 : Déclaration De Booléens ........................................................................................... 35
Image 16: Operations Sur Les Booléens ..................................................................................... 36
Image 17: Utilisation Des Comparaisons Dans Les Conditions .................................................... 37
Image 18: Méthodes Retournant Des Valeurs Booléennes ........................................................... 38
Image 19: Code De Création D’une Liste Avec Récupération D’élément ........................................ 47
Image 20: Résultat De La Création D'une Avec Récupération D'éléments ..................................... 48
Image 21 : Code De L’exemple Piles En Java ................................................................................ 56
Image 22 : Résultat Du Code ....................................................................................................... 56

Liste Des Tableaux
LISTE DES TABLEAUX
Tableau 1: Valeurs Limitées Des Types Byte, Short, Int, Et Long ............................................. 25
Tableau 2 : Valeurs Limites Des Types Float Et Double............................................................ 31
Tableau 3 : Utilisation Des Caractères En Java ......................................................................... 34
Tableau 4: Classes D'implémentations ........................................................................................ 42

Table Des Matières
TABLES DES MATIERES

DEDICACES ................................................................................................................................... 2
REMERCIEMENTS ......................................................................................................................... 3
RESUMÉ ....................................................................................................................................... 4
ABSTRACT .................................................................................................................................... 5
LISTE DES FIGURES ........................................................................................................................ 6
LISTE DES IMAGES ........................................................................................................................ 7
LISTE DES TABLEAUX..................................................................................................................... 8
TABLES DES MATIERES .................................................................................................................. 9
INTRODUCTION .......................................................................................................................... 11
I- PRESENTATION DES STRUCTURES DE DONNEES ................................................................... 12
1. Définitions ...................................................................................................................... 12
2. Rôles des structures de données ...................................................................................... 16
II- LES STRUCTURES DE DONNEES EN JAVA............................................................................... 25
A. Les Structures De Données Primitives .............................................................................. 25
1. Les types entiers .......................................................................................................... 25
2. Les types flottants ....................................................................................................... 30
3. Les caractères .............................................................................................................. 32
4. Le type booléen ........................................................................................................... 34
B. Les Tableaux ................................................................................................................... 38
1. Les tableaux à une dimension .......................................................................................... 38
2. Les tableaux multidimensionnels ..................................................................................... 40
C. Les Collections................................................................................................................. 41
D. Les Structures De Données Linéaires ................................................................................ 52
1. Les Piles ...................................................................................................................... 52
2. Les Files ....................................................................................................................... 57
E. Les Structures De Données Non Linéaires ......................................................................... 58
F. Les Structures De Données De Hachage............................................................................ 60
G. Les Classes Et Objets ........................................................................................................ 61
a. Les classes ................................................................................................................... 61
b. Les objets .................................................................................................................... 67
H. Les Flux Et Les Fichiers ..................................................................................................... 74
I. Les Enregistrements ........................................................................................................ 85

Table Des Matières
III- CHOIX APPROPRIE DES STRUCTURES DE DONNEES ........................................................... 92

A. Analyse Des Besoins Et Des Contraintes Des Besoins ........................................................ 92
B. Sélection De La Structure De Données A Adapter Aux Besoins. ......................................... 94
C. Optimisation Des Performances En Utilisant Les Bonnes Structures De Données. .............. 95
IV- CAS PRATIQUES : Utilisation Des Piles .............................................................................. 97
CONCLUSION.............................................................................................................................. 98
LEXIQUE ..................................................................................................................................... 99
REFERENCES BIBLIOGRAPHIQUES...............................................................................................100

Introduction
INTRODUCTION
Une structure de données est un format spécial destiné à organiser, traiter, extraire et
stocker des données. S'il existe plusieurs types de structures plus ou moins complexes, tous
visent à organiser les données pour répondre à un besoin précis, afin de pouvoir y accéder et
les traiter de façon appropriée. Alors, la compréhension et le choix approprié des structures de
données sont essentiels pour garantir l'efficacité et la performance du système. En fonction
des besoins spécifiques du projet, il est important de choisir la structure de données la plus
adaptée pour optimiser les opérations de stockage et de manipulation des données. Une bonne
conception des structures de données peut contribuer à améliorer la qualité du code, à réduire
la complexité algorithmique et à augmenter l'efficacité globale du système. L'essence des
structures de données réside dans leur capacité à organiser et à manipuler efficacement des
données pour répondre aux besoins spécifiques d'une application ou d'un système
informatique. Les structures de données permettent de stocker des informations de manière
structurée, facilitant ainsi l'accès, la recherche, la modification et la suppression des données.
Les structures de données jouent un rôle crucial dans la résolution de problèmes informatiques
complexes en fournissant des moyens efficaces pour représenter et traiter les données. Elles
permettent aux programmeurs de choisir la structure la plus adaptée en fonction des
opérations à effectuer sur les données, de l'espace mémoire disponible et des contraintes de
performance. De ce fait, dans cet exposé, nous avons présenté dans l'ordre chronologique. La
présentation des différentes structures de donnés en Java, le choix approprié de la structure de
données selon les besoins spécifiques pour l'obtention d'une solution optimale des problèmes
rencontrés. Tout en nous apesantissant sur de nombreux cas pratiques.

Présentation Des Structures De Données
I- PRESENTATION DES STRUCTURES DE DONNEES

1. Définitions
En informatique, une structure de données est un moyen de stocker, organiser et manipuler
des données de manière efficace. Elle permet de représenter des informations de manière
structurée afin de faciliter leur accès, leur modification et leur traitement. Le fait d'utiliser une
structure de données peut également baisser de manière significative d'un programme
informatique et ainsi à diminuer le taux d'erreurs. (Wikipédia).
 Les structures de données primitives ( miahs www.u-ga.fr )
En informatique une structure de données primitive fait référence à un type de données de de

base qui est directement pris pas le langage de programmation lui-même. Les structures de
données primitives sont généralement simples, efficaces et directement manipulables par le
programmeur sans avoir besoin de classe supplémentaires. Ce sont des types de données qu'on
retrouve dans de nombreux langages de programmation :
_ Booléen : C'est l'ensemble des valeurs true or false
_ Caractère : Ensemble des valeurs Unicode (valeurs de '\u0000' à '\uffff avec 4 chiffres
obligatoires après '\u' ) les 128 premiers caractères sont des codes ASCII et se notent entre
apostrophe: 'a', 'l', '\', '\n'.
_ Les types entiers : Les différents types entiers se distingue par la taille de leur
représentation.
Byte : (1 octet) entiers compris entre -128 et +127.
Short : (2 octet) entiers compris entre -32768 et +32767
Int : (4 octet) entiers compris entre -2147483648 et +2147483647
Long : (8 octet) entiers compris entre -9223372036854775808 et

+9223372036854775807
_ Les types flottants :
_ Les conversions :
 Les tableaux (codegym.cc)
Un tableau est une structure de données qui stocke des éléments du même type. On peut le
considérer comme un ensemble de cellules numérotées dans lequel on peut mettre des

données dans chaque cellule (un élément de données par cellule). Le numéro d'un élément
dans le tableau est également appelé Index. En Java, un tableau est homogène c'est-à-dire que
toutes les cellules contiennent des éléments de même type. Ainsi un tableau d'entier ne
contient que des entiers (Int). Un tableau d'instances de chaine uniquement des chaines, un
tableau d'instances d'une classe dog que nous avons créée ne contiendra que des objets dog.
En d'autres termes, Java ne nous laissera pas mettre un entier dans la première cellule du
tableau et une chaine dans la seconde cellule.
Les tableaux en Java offrent plusieurs méthodes pour accéder et manipuler les éléments du
tableau, telles que l‟accès direct à un élément en utilisant son index, la boucle for pour
parcourir tous les éléments du tableau, et les méthodes de la classe Arrays pour effectuer des
opérations sur les tableaux.
Il est important de noter que les tableaux ont une taille fixe lors de leur création et ne peuvent
pas être redimensionnés. Si vous avez besoin d'une structure de données dynamique en Java,
vous pouvez utiliser des collections comme ArrayList.
 Les collections (jmdoudoux.fr)
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...
Une collection est un regroupement d'objets qui sont désignés sous le nom d'éléments.
L'API Collections propose un ensemble d'interfaces et de classe 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 : collections d'éléments ordonnés qui accepte les doublons. Les implémentations les
plus courantes sont ArrayList et LinkedList
_ Set : collection d'éléments non ordonnés par défaut qui n'accepte pas les doublons. Les
implémentations les plus courantes sont HashSet, TreeSet et LinkedHashSet.
_Map : collection sous la forme d'une association de pair clé/valeur. Les implémentations les
plus courantes sont HashMap, TreeMap et LinkedHashMap.
_Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu'ils ²
 Les structures de données non linéaires (docplayer.fr)
En Java les structures de données non linéaires sont des collections d'objets qui ne sont pas
organisées de manière linéaire c'est-à-dire qu'elles ne suivent pas un ordre séquentiel comme
les tableaux e les lists mais plutôt un ordre trié. Pour cela, les éléments peuvent être attachés à

plus d'un élément présentant une relation hiérarchique. Dans une structure de données non
linéaire, le parcours de données et l'insertion ou la suppression ne sont pas effectuées de
manière séquentielle. Les structures de données les plus courantes en Java incluent :
_Graphes : Les graphes en Java sont des structures de données composées de sommets (ou
nœuds) reliés par des arêtes. Les graphes peuvent être dirigés (avec des arêtes orientées) ou
non dirigés (sans orientation).
Un graphe orienté
Un graphe non orienté
_Arbres : Les arbres en Java sont des structures de données hiérarchiques composées de
nœuds connectés les uns aux autres par des arêtes. Chaque nœud peut avoir un ou plusieurs
enfants, formant ainsi une structure arborescente.
 Structure de données en hachage
Une Hashtable est une structure de données où les données sont stockées sous forme
de tableau. Chaque valeur de données à une valeur de clé unique. Si la clé est connue, tu peux
accéder aux données souhaitées très rapidement. Ainsi, les opérations d'insertion et de
recherche sont rapides et indépendantes de la taille des données.
Une table de hachage se compose d'un tableau pour conserver des données et d'une
fonction de hachage pour générer l'index où un élément doit être stocké.
En Java, il s'agit d'une règle qui mappe un objet sur un jeu de caractères (un code de
hachage). Habituellement, ce genre de fonction convertit un gros morceau de données en une
petite valeur entière. Les fonctions de hachage peuvent être variées, mais elles respectent
toutes certaines propriétés :
 Un objet particulier a un code de hachage particulier.

 Deux objets égaux ont les mêmes codes de hachage. L'inverse n'est pas vrai.
 Si deux codes de hachage sont différents, alors nous avons la certitude que les objets
ne sont pas égaux.
 Différents objets peuvent avoir le même code de hachage. Cet événement très rare est
appelé une collision. Une bonne fonction de hachage minimise la probabilité de
collisions.
Le résultat de l'application de la fonction de hachage à un objet est appelé hashCode.

 Classes et Objets
Les classes et les objets sont les composants fondamentaux de la Programmation

Orienté Objet. Il y a souvent une confusion entre les classes et les objets. Le concept
d‟utilisation de classes et d‟objets consiste à encapsuler l‟état et le comportement dans une
seule unité de programmation. Les objets Java sont similaires aux objets du monde réel. Par
exemple, nous pouvons créer un objet voiture en Java, qui aura des propriétés telles que la
vitesse et la couleur actuelles ; et un comportement comme : accélérer et freiner.
Une classe est un plan ou un prototype défini par l‟utilisateur à partir duquel des
objets sont créés. Il représente l‟ensemble des propriétés ou méthodes communes à tous les
objets d‟un type.
Un Objet est une unité de base de la programmation orientée objet et représente les
entités de la vie réelle. Un programme Java typique crée de nombreux objets qui, comme vous
le savez, interagissent en appelant des méthodes. Un objet est composé de :
 Etat : Il est représenté par les attributs d‟un objet.

 Comportement : Il est représenté par les méthodes d‟un objet.
 Identité : attribue un nom unique à un objet et permet à un objet d‟interagir avec
d‟autres objets.
 Les flux et les fichiers
Un flux est une séquence de données qui peut être lue ou écrite de manière
séquentielle. Les flux traitent toujours les données de façon séquentielle.
En Java, les flux peuvent être divisés en plusieurs catégories :
 Les flux d'entrée (input stream) et les flux de sortie (output stream)
 Les flux de traitement de caractères et les flux de traitement d'octets
Java définit des flux pour lire ou écrire des données mais aussi des classes qui permettent
de faire des traitements sur les données du flux. Ces classes doivent être associées à un flux de
lecture ou d'écriture et sont considérées comme des filtres. Par exemple, il existe des filtres
qui permettent de mettre les données traitées dans un tampon (buffer) pour les traiter par lots.
Les fichiers (Files) :

En Java, un fichier est une unité de stockage persistante qui peut contenir des données
sous forme de bytes ou de caractères. Les fichiers peuvent être utilisés pour stocker des
informations de manière permanente sur le disque dur.
Pour travailler avec des fichiers en Java, on utilise les classes du package java.io telles
que File, FileReader, FileWriter, etc.
- Les opérations courantes sur les fichiers en Java incluent la création, la lecture, l'écriture,
la suppression, le déplacement et la modification des fichiers.
 Les enregistrements en Java
Un type enregistrement est un type de données complexe (ou composé) représente une
donnée, elle-même composée d‟un ensemble de données. Chaque élément de cet ensemble
possède un nom et un type de données spécifique, et il ne doit pas y avoir de doublons dans
les noms des éléments.
Les éléments d‟un enregistrement sont appelés champs (fields), attributs (attributes) ou
encore propriétés (properties). Contrairement, aux valeurs individuelles d‟un tableau, les
valeurs des champs d‟un enregistrement ne sont pas indépendantes les unes des autres.
Ensemble, ces valeurs sont une description d‟un objet concret ou abstrait du monde réel.
Par exemple, un compte d‟utilisateur peut être décrit par :
 Un identifiant numérique (uid) de type entier

 Un nom d‟utilisateur (userName) de type texte,
 Un nom complet (displayName) de type texte.
Un type enregistrement est défini à l‟aide d‟une classe, dans laquelle les variables
membres représentent les champs de l‟enregistrement. Les variables membres sont déclarées
au début de la classe juste après l‟accolade ouvrante. La déclaration d‟une variable membre
est similaire à celle d‟une variable locale, mais elle est précédée du modificateur public.
2. Rôles des structures de données

Les structures de données jouent un rôle essentiel en Java et dans tout langage de
programmation. Elles permettent de stocker, organiser et manipuler des données de manière

efficace, en offrant différentes façons d'accéder et de gérer ces données. En Java, les
structures de données peuvent être utilisées pour résoudre une grande variété de problèmes,
que ce soit pour stocker des collections d'objets, gérer des informations complexes, ou
optimiser les performances des algorithmes.
 Les structures de données primitives
En Java, les structures de données primitives jouent un rôle essentiel dans la

manipulation et le stockage des données de base. Voici quelques-uns des rôles importants des
structures de données primitives en Java :
 Stockage efficace : Elles occupent moins d'espace mémoire que les objets. En
conséquence, l'utilisation de structures de données primitives permet d'économiser de
la mémoire et d'améliorer les performances en réduisant la surcharge liée à la gestion
des objets.
 Performances optimisées : Elles offrent des performances optimisées par rapport aux
objets. Étant donné que les structures de données primitives sont stockées sur la pile
(stack) plutôt que dans le tas (heap), leur accès et leur manipulation sont plus rapides.
De plus, les opérations arithmétiques sur les types primitifs sont généralement plus
rapides que sur les objets correspondants.
 Facilité de manipulation : Elles sont simples à manipuler car elles représentent des
valeurs de base. Les opérations sur les structures de données primitives sont directes et
ne nécessitent pas de méthodes spéciales comme pour les objets. Cela facilite la
manipulation des données et rend le code plus concis.
 Compatibilité avec les types primitifs : Elles sont compatibles avec les types
primitifs du langage, ce qui facilite l'interopérabilité avec d'autres bibliothèques et API
Java. Les structures de données primitives peuvent être utilisées dans des tableaux, des
collections et d'autres structures de données standard sans nécessiter de conversion
vers des objets.
 Utilisation dans les algorithmes et les opérations mathématiques : Elles sont
largement utilisées dans les algorithmes et les opérations mathématiques pour stocker
des valeurs numériques, des caractères, des booléens, etc. Leur utilisation permet
d'optimiser les performances des algorithmes en évitant les coûts supplémentaires liés
à la gestion des objets.


 Les tableaux
En Java, les tableaux sont des structures de données utilisées pour stocker une
collection d'éléments de même type. Voici quelques-uns des rôles des tableaux en Java :
 Stockage de données : Les tableaux permettent de stocker un ensemble d'éléments

de même type dans une seule structure de données.
 Accès aux éléments : Les éléments d'un tableau peuvent être accédés en utilisant
leur indice. Cela permet un accès rapide et efficace aux données.
 Manipulation des données : Les tableaux offrent des méthodes pour manipuler
les données, telles que l'ajout, la suppression, la modification et le tri des éléments.
 Itération : Les tableaux peuvent être parcourus à l'aide de boucles, ce qui facilite
le traitement séquentiel des éléments.
 Passage d'arguments : Les tableaux peuvent être passés en tant qu'arguments à
des méthodes, ce qui permet de transmettre des collections de données à une
fonction.
 Retour de valeurs : Les méthodes peuvent retourner des tableaux en tant que
résultats, ce qui permet de renvoyer des collections de données à partir d'une
fonction.
 Les collections
En Java, les collections sont des structures de données plus flexibles et dynamiques
que les tableaux, offrant une variété de fonctionnalités pour stocker et manipuler des
éléments. Voici quelques-uns des rôles des collections en Java :
 Stockage dynamique : Contrairement aux tableaux dont la taille est fixe, les
collections en Java peuvent grandir et rétrécir dynamiquement en fonction des besoins.
 Gestion de la mémoire : Les collections en Java gèrent automatiquement la mémoire,
ce qui simplifie la gestion des ressources et évite les problèmes de dépassement de
capacité.
 Types de données variés : Les collections en Java offrent une gamme de types de
données prédéfinis tels que les listes, les ensembles, les cartes, etc., permettant de
stocker différents types d'éléments.

 Fonctionnalités avancées : Les collections en Java offrent des fonctionnalités

avancées telles que le tri, le filtrage, la recherche, l'itération, etc., facilitant la
manipulation des données.
 Interfaces standard : Les collections en Java sont basées sur des interfaces standard
telles que List, Set, Map, etc., ce qui permet une utilisation cohérente et compatible
des différentes structures de données.
 Sécurité et robustesse : Les collections en Java sont conçues pour être sécurisées et
robustes, offrant des mécanismes pour éviter les erreurs telles que les doublons, les
accès concurrents, etc.
 Les structures de données linéaires
En Java, les structures de données linéaires telles que les piles (Stack) et les files (Queue)
jouent un rôle important dans le stockage et la manipulation des éléments de manière
séquentielle. Voici quelques-uns des rôles des piles et des files en Java :
1. Piles (Stack)
LIFO (Last In First Out) : Les piles suivent le principe du dernier élément ajouté est le
premier à être retiré, ce qui les rend utiles pour des opérations telles que l'annulation (undo)
ou le suivi d'un historique.
Gestion de la pile d'appels : Les piles sont utilisées pour gérer les appels de fonctions
récursives ou les appels de méthodes dans la programmation orientée objet.
Évaluation d'expressions : Les piles sont utilisées pour évaluer des expressions
arithmétiques ou logiques en utilisant des algorithmes tels que l'algorithme de conversion en
notation polonaise inversée (RPN).
2. Files (Queue) :
FIFO (First In First Out) : Les files suivent le principe du premier élément ajouté est le
premier à être retiré, ce qui les rend utiles pour des opérations telles que la gestion des tâches
en attente ou la gestion des requêtes réseau.

Gestion des processus : Les files sont utilisées pour gérer les processus en attente
d'exécution, tels que l'ordonnancement des tâches dans un système d'exploitation.
Communications asynchrones : Les files sont utilisées pour faciliter la communication

asynchrone entre différents composants d'un système.
 Les structures de données non linéaires
En Java, les structures de données non linéaires telles que les arbres et les graphes jouent
un rôle crucial dans de nombreuses applications informatiques. Voici quelques-uns des rôles
des structures de données non linéaires en Java :
1. Arbres
- Représentation hiérarchique : Les arbres sont utilisés pour représenter des structures
hiérarchiques telles que les arbres généalogiques, les structures de dossiers et fichiers, les
arbres de décision, etc.
- Arbres binaires de recherche : Les arbres binaires de recherche sont utilisés pour stocker et
rechercher des données de manière efficace, en garantissant un temps de recherche
logarithmique.
- Arbres d'expressions : Les arbres d'expressions sont utilisés pour représenter des
expressions arithmétiques ou logiques de manière structurée, ce qui facilite leur évaluation et
leur manipulation.
2. Graphes
Modélisation des relations : Les graphes sont utilisés pour modéliser des relations
complexes entre des entités, telles que les réseaux sociaux, les réseaux de transport, les
réseaux informatiques, etc.
Algorithmes de parcours : Les graphes sont utilisés pour implémenter des algorithmes de
parcours tels que la recherche en profondeur (Depth First Search) et la recherche en largeur
(Breadth First Search), qui sont essentiels pour résoudre de nombreux problèmes liés aux
graphes.

Algorithmes de plus court chemin : Les graphes sont utilisés pour résoudre des problèmes
de recherche du plus court chemin, tels que l'algorithme de Dijkstra ou l'algorithme de
Bellman-Ford, qui sont largement utilisés dans la planification des itinéraires, la logistique,
etc.
 Structures de données de Hachage
En Java, les structures de données de hachage jouent un rôle essentiel dans de nombreuses
applications informatiques en raison de leur efficacité en termes de recherche, d'insertion et de
suppression d'éléments. Voici quelques-uns des rôles des structures de données de hachage en
Java :
 Recherche efficace : Les tables de hachage permettent une recherche efficace en

temps constant (O(1)) pour trouver des éléments en fonction de leur clé. Cela les rend
idéales pour les applications nécessitant des recherches rapides, telles que les bases de
données, les caches mémoire, etc.
 Stockage et récupération rapide : Les structures de données de hachage permettent
de stocker des éléments de manière efficace en utilisant une fonction de hachage pour
mapper chaque clé à une position dans la table. Cela facilite la récupération rapide des
éléments sans avoir besoin de parcourir toute la structure.
 Élimination des doublons : Les tables de hachage sont souvent utilisées pour
éliminer les doublons dans un ensemble d'éléments, car elles garantissent l'unicité des
clés. Cela est utile pour la déduplication des données et la gestion des ensembles
distincts.
 Implémentation de structures de données associatives : Les tables de hachage
peuvent être utilisées pour implémenter des structures de données associatives telles
que les dictionnaires, les ensembles et les listes associatives. Elles permettent
d'associer des valeurs à des clés de manière efficace et rapide.
 Optimisation des performances : Les structures de données de hachage sont souvent
utilisées pour optimiser les performances des algorithmes en réduisant le temps de
recherche et en améliorant l'efficacité de la manipulation des données. Elles sont
largement utilisées dans les applications nécessitant un accès rapide aux données,
telles que les bases de données, les systèmes de cache, etc.

 Les classes et les objets
En Java, les classes et les objets jouent un rôle fondamental dans la programmation
orientée objet. Voici quelques-uns des rôles importants des classes et des objets en Java :
 Encapsulation : Les classes en Java permettent d'encapsuler des données (attributs) et

des comportements (méthodes) connexes en un seul objet. Cela permet de regrouper
des fonctionnalités liées ensemble et de les manipuler de manière cohérente.
 Réutilisabilité : Les classes en Java favorisent la réutilisabilité du code en permettant
de définir des modèles de données et de comportements qui peuvent être instanciés
pour créer de multiples objets. Cela permet d'éviter la duplication du code et de
faciliter la maintenance.
 Héritage : Les classes en Java peuvent hériter des caractéristiques d'autres classes, ce
qui permet de créer une hiérarchie de classes et de partager des fonctionnalités
communes entre elles. L'héritage permet d'étendre et de spécialiser le comportement
des classes existantes.
 Polymorphisme : Les objets en Java peuvent être utilisés de manière polymorphe,
c'est-à-dire qu'un objet d'une classe peut être traité comme un objet d'une classe
parente. Cela permet de simplifier le code en utilisant des interfaces communes pour
manipuler différents types d'objets.
 Abstraction : Les classes en Java permettent de définir des abstractions pour
représenter des concepts du monde réel de manière simplifiée. Cela facilite la
modélisation des problèmes complexes en se concentrant sur les aspects essentiels et
en masquant les détails d'implémentation.
 Modularité : Les classes en Java favorisent la modularité du code en permettant de
diviser un programme en unités logiques indépendantes (classes) qui peuvent être
développées, testées et maintenues séparément. Cela facilite la gestion de projets
complexes et la collaboration entre développeurs.
 Les flux et fichiers
En Java, les flux et les fichiers jouent un rôle essentiel dans la manipulation des données
entrantes et sortantes, ainsi que dans le stockage et la lecture de données sur des supports de
stockage persistants tels que des fichiers. Voici quelques-uns des rôles importants des flux et
des fichiers en Java :

 Lecture et écriture de données : Les flux en Java permettent de lire des données à
partir de sources telles que des fichiers, des entrées utilisateur, des connexions réseau,
etc., et d'écrire des données vers des destinations telles que des fichiers, des sorties
système, des connexions réseau, etc. Les flux offrent une interface unifiée pour la
lecture et l'écriture de données de manière séquentielle.
 Manipulation de fichiers : Les classes de gestion de fichiers en Java (comme File,
FileInputStream, FileOutputStream, FileReader, FileWriter, etc.) permettent de créer,
supprimer, renommer, copier, déplacer et inspecter des fichiers et des répertoires sur le
système de fichiers local. Elles offrent des fonctionnalités pour interagir avec les
fichiers et les répertoires de manière programmatique.
 Persistance des données : Les fichiers en Java sont couramment utilisés pour stocker
des données de manière persistante sur le disque dur ou tout autre support de stockage.
Les applications Java peuvent lire et écrire des données dans des fichiers pour
sauvegarder des informations entre les exécutions du programme, partager des
données entre différentes parties de l'application ou échanger des données avec
d'autres applications.
 Traitement de flux : Les flux en Java offrent une manière flexible et efficace de
traiter les données en transit. Les développeurs peuvent chaîner plusieurs flux
ensemble pour effectuer des opérations de transformation, de filtrage, de compression
ou de cryptage sur les données en transit. Cela permet de manipuler efficacement les
données sans avoir à les stocker entièrement en mémoire.
 Communication réseau : Les flux en Java sont largement utilisés pour la
communication réseau via les sockets. Les développeurs peuvent créer des flux
d'entrée et de sortie pour envoyer et recevoir des données sur un réseau, ce qui facilite
le développement d'applications client-serveur, d'applications Web et d'autres
systèmes distribués.
 Les enregistrements
En Java, les enregistrements sont une fonctionnalité introduite dans la version 16 de Java,
qui permet de définir des classes légères et immuables pour représenter des données de
manière concise et efficace. Voici quelques-uns des rôles importants des enregistrements en
Java :

 Simplification de la définition de classes de données : Les enregistrements en Java

permettent de définir des classes de données avec un minimum de code. En utilisant le
mot-clé record, il est possible de déclarer une classe avec des champs de données
immuables et des méthodes utilitaires générées automatiquement, tels que les
méthodes equals(), hashCode () et toString(). Cela simplifie la création de classes de
données simples et réduit la quantité de code boilerplate à écrire.
 Immuabilité : Les enregistrements en Java sont par défaut immuables, ce qui signifie
que les instances d'enregistrements ne peuvent pas être modifiées une fois qu'elles ont
été créées. Cela garantit l'intégrité des données et évite les effets de bord indésirables
liés à la mutation des objets. Les enregistrements favorisent la programmation
fonctionnelle en encourageant l'utilisation de données immuables.
 Facilité d'utilisation avec les API modernes : Les enregistrements en Java sont
conçus pour s'intégrer facilement avec les API modernes telles que les streams, les
lambdas et les expressions switch. Grâce à leur syntaxe concise et à leur immuabilité,
les enregistrements peuvent être utilisés de manière transparente avec ces
fonctionnalités avancées de Java pour simplifier le traitement des données.
 Support pour la déconstruction : Les enregistrements en Java offrent un support
intégré pour la déconstruction, ce qui permet d'accéder facilement aux champs d'un
enregistrement sans avoir à écrire du code supplémentaire. La déconstruction facilite
l'extraction et la manipulation des données contenues dans un enregistrement de
manière concise et expressive.
 Amélioration de la lisibilité du code : En utilisant des enregistrements pour
représenter des données simples et immuables, le code devient plus lisible et expressif.
Les enregistrements permettent de clarifier l'intention du code en mettant l'accent sur
les données elles-mêmes plutôt que sur les détails de mise en œuvre, ce qui facilite la
compréhension du code par les développeurs.

Les Structures De Données En Java
II- LES STRUCTURES DE DONNEES EN JAVA

A. Les Structures De Données Primitives
Un type primitif est un type de donnée déjà implanté dans le langage de

programmation. En dehors du C et du C++, son espace en mémoire est fixé par la
spécification du langage et non par la machine cible.
1. Les types entiers

Les types entiers servent à représenter des entiers relatifs : il s'agit des types byte,
short, int, et long, dont voici un tableau récapitulant leurs tailles, leurs maximums et
minimums :
Type Taille (en Valeur minimal Valeur maximale

octet)
Byte 1 -128 127
Short 2 -32 768 32 767
Int 4 -2 147 483 648 2 147 483 647
long 8 -9 223 372 036 854 775 808 9 223 372 036 854 775 807
Tableau 1: Valeurs limitées des types byte, short, int, et long
 Passage d’un type a un autre
Pour transférer la valeur d'une variable entière dans une autre variable entière, il y a deux
possibilités :
 Soit la taille de la variable dans laquelle on affecte est plus grande (ou égale) à la taille
de la variable initiale, et dans ce cas, le changement de type est implicitement autorisé.
 Soit la taille de la variable dans laquelle on affecte est plus petite à la taille de la
variable initiale, et dans ce cas il peut y avoir une perte de précisions lors de
l'affectation. Du coup le changement de type devra être explicitement acté via un

opérateur de transtypage (on utilise aussi souvent la terminologie anglo-saxonne en

parlant d'opérateur de cast).
Un opérateur de transtypage s'introduit en mettant le type de destination entre parenthèses,

comme le montre l'exemple suivant.
Image 1 : Exemples d’utilisations des opérateurs de transtypage
 Les différentes bases numériques
Java permet d'utiliser plusieurs bases numériques pour exprimer vos valeurs entières. Il y
en a trois qui sont reprises du langage C : base octale, base décimale et base hexadécimale.
Depuis Java SE 7.0, une quatrième base, la base binaire, a été rajoutée au langage.
 La base binaire : elle ne supporte que deux chiffres, le 0 et le 1. Pour exprimer une
valeur en base binaire, il est nécessaire de préfixer votre valeur par 0b.
 La base octale : comme son nom l'indique, cette base numérique contient 8 chiffres
(de 0 à 7). Les chiffres 8 et 9 sont donc non autorisés : si vous les utilisez, une erreur
de compilation sera produite. Pour exprimer une valeur en base octale, il est nécessaire
de préfixer votre valeur par 0.
 La base décimale : bien entendu dix chiffres de 0 à 9. Que dire de plus ....
 La base hexadécimale : 16 chiffres de 0 à 9 puis de A à F. Cette base numérique est
très intéressante dans certains cas : communication avec un matériel électronique,
codification de couleurs ARGB, ...

Image 2 : Les différentes bases numériques
 Groupage de chiffres
Depuis Java SE 7.0, il est possible d'utiliser le caractère _ pour grouper les digits (les
chiffres) d'une valeur numérique. On peut aussi grouper les chiffres par blocs de taille
quelconque. On n'est même pas obligé de définir de groupes de tailles identiques : cela peut,
par exemple, s'avérer très pratique avec l'utilisation du binaire dans le cadre de la
communication avec un matériel électronique.
Il est possible d'utiliser le groupage de chiffres, quelle que soit la base numérique
utilisées. Voici quelques exemples d'utilisations.
Image 3 : Utilisation du groupage de chiffres
Le groupage n'intervient uniquement que pour la spécification de la valeur. A

l'affichage, aucun groupage n'est réalisé par défaut. Voici le résultat produit par l'exemple

précédent. La valeur négative vient du faire que le type int est signé (le bit 32 étant fixé à 1, la
valeur est affichée négativement).
Image 4 : Résultat de l’utilisation du groupage de chiffre
Pour réaliser un groupage à l'affichage, il est nécessaire d'utiliser un formateur, comme

le montre l'exemple suivant. La ligne commençant par import correspond à une importation
de la librairie java.text.NumberFormat.
Image 5 : Formatage d’un entier à l’affichage
Si vous utilisez une version de Java inférieur à Java 7.0, le groupage ne sera pas
supporté. Une erreur de compilation sera produite.
 Operateurs arithmétiques sur entiers
 Les opérateurs arithmétiques
Les opérateurs arithmétiques dont nous disposons en Java sont : +, -, *, / et % pour

respectivement, l'addition, la soustraction, la multiplication, la division et le calcul du reste de
la division entière. Voici un petit exemple.

Image 6 : Exemple d’utilisation des opérateurs arithmétiques
Si vous avez le moindre doute sur la priorité d'évaluation de vos opérateurs, utilisez
les parenthèses pour forcer les priorités. Voici un exemple, mais j'insiste bien sur le fait qu'ici
ce n'est pas nécessaire.
Image 7 : Forcer la priorité
 Dépassement d’étendue
L'ajout de deux variables de type byte produit un entier typé int. La raison est qu'on
peut très facilement dépasser de l'étendue du type byte étant donné le peu de place occupé. Il
est donc nécessaire de transtyper le résultat en byte si c'est ce que vous souhaitez récupérer. Il
en va de même pour les autres opérateurs arithmétiques (soustraction, ...). Dans le même ordre
d'idée, l'addition de deux short produit aussi un résultat typé int. L'exemple ci-dessous vous
montre comment réaliser les transtypages (conversions vers le type souhaité).
 Cas de la division entière
Le langage Java défini, comme en C, deux sortes d'opérateurs de division : vous avez
la possibilité de faire des divisions entières ou des divisions flottantes. Dans l'exemple ci-
dessous, il n'y a aucun doute à avoir, on divise deux entiers et on demande à récupérer un
entier : la division sera donc entière.
Image 8 : Exemple d’une division entière

Image 9 : autre exemple d'une division entière
 Operateurs de comparaison
Vous pouvez aussi comparer vos entiers. Pour ce faire, six opérateurs-vous sont
proposés : l'égalité (opérateur ==), la différence (opérateur !=), l'infériorité (opérateur <=),
l'infériorité stricte (opérateur <), la supériorité (opérateur >=), la supériorité stricte (opérateur
>). Voici un exemple d'utilisation.
Image 10 : utilisation des operateur de comparaison
2. Les types flottants

Les types flottants en Java, sont utilisés pour stocker des nombres réels selon le format
IEEE 754. Contrairement aux types entiers qui ne peuvent représenter que des nombres
entiers, les types flottants peuvent contenir des valeurs fractionnaires. Ils sont souvent utilisés
pour représenter des quantités réelles telles que des valeurs monétaires, des coordonnées
géographiques, etc. Ces types sont essentiels car ils permettent aux programmes de traiter des
données réelles de manière précise.

Les types flottants en Java ont une précision limitée en raison de la façon dont les
nombres réels sont représentés en mémoire. Cela peut entraîner des approximations et des
erreurs de calcul, en particulier lors de l‟utilisation de valeurs très grandes ou très petites. Il
est important pour les programmeurs de comprendre ces limitations et de prendre des
précautions lors de l‟utilisation de types flottants pour des calculs critiques.
Ce format stocke le signe sur un bit puis le nombre sous une forme entière (la
mantisse) et l‟exposant en base 2 pour positionner la virgule. Il existe en Java deux types
primitifs permettant de représenter des nombres flottants, à savoir float et double, dont voici
les valeurs limites :
type Taille (en octets) Valeur minimale Valeur maximale
float 4 -1.40239846E-45 3.40282347E38
double 8 4.9406564584124654E- 1.797693134862316E308

324
Tableau 2 : Valeurs limites des types float et double
Float est dit en simple précision et tandis que double est dit en double précision.
En règle générale, il est recommandé d‟utiliser le type double pour les calculs impliquant
des valeurs flottantes, car il offre une meilleure précision que le type float. Le type float peut
être utilisé dans des cas où l‟espace mémoire est limité ou lorsque la précision accrue du type
double n‟est pas nécessaire.
 Opérateurs arithmétiques sur les types flottants
Bien entendu, vous avez le droit d'utiliser des opérateurs pour réaliser les opérations
arithmétiques classiques : l'addition (opérateur +), la soustraction (opérateur -), la
multiplication (opérateur *) et la division flottante (opérateur /). Voici un petit exemple
d'utilisation de certains de ces opérateurs.

Image 11 : utilisation des opérateurs sur les réels
 Operations comparaisons
Vous pouvez aussi comparer vos flottants. Pour ce faire, six opérateurs-vous sont proposés :
l'égalité (opérateur ==), la différence (opérateur !=), l'infériorité (opérateur <=), l'infériorité
stricte (opérateur <), la supériorité (opérateur >=), la supériorité stricte (opérateur >). Voici
un exemple d'utilisation.
Image 12: Utilisation des opérateurs de comparaisons avec les réels
3. Les caractères
 Unicode
Unicode est une spécification qui vise à lister tous les caractères utilisés par les
langues humaines et à donner à chaque caractère son propre code unique. Les spécifications

Unicode sont continuellement révisées et mises à jour pour ajouter de nouvelles langues et de
nouveaux symboles.
Un caractère est le plus petit composant possible d'un texte. « A », « B », « C », etc.

sont tous des caractères différents. Il en va de même pour « È » et « Í ». Les caractères varient
selon la langue ou le contexte dont vous parlez. Par exemple, il y a un caractère pour « Chiffre
Romain Un » (Roman Numeral One), « Ⅰ », qui est séparé de la lettre majuscule « I ». Ils se
ressemblent généralement, mais ce sont deux caractères différents qui ont des significations
différentes.
Le standard Unicode décrit comment les caractères sont représentés par les points de
code. Une valeur de point de code est un nombre entier compris entre 0 et 0x10FFFF (environ
1,1 million de valeurs possibles, le nombre de valeurs réellement assignées est inférieur à ce
nombre). Dans le standard, un point de code est écrit en utilisant la notation U+265E pour
désigner le caractère avec la valeur 0x265e (9 822 en décimal).
La standard Unicode contient de nombreux tableaux contenant la liste des caractères et

des points de code correspondants :
Image 13: Extrait du standard Unicode
 Les caractères en java
En Java, les caractères sont représentés par le type primitif char, qui peut stocker un
seul caractère Unicode. Ce type de données est codé sur 16 bits et peut donc représenter des
caractères Unicode allant de U+0000 à U+FFFF. Il existe également d‟autres types de

données pour représenter des chaînes de caractères, telles que String, qui est une séquence de
caractères.
Utilisation des caractères en Java
Tableau 3 : utilisation des caractères en java
Test des caractères
La classe java.lang.Character propose un certain nombre de méthodes statiques vous

permettant de tester vos caractères et ce quel que soit l'alphabet utilisé.
Image 14: Test sur les caractères
4. Le type booléen
Le type booléen est fondamental en programmation car il permet de représenter l‟état de
vérité dans les décisions et les conditions. Il ne peut prendre que deux valeurs : true ou false.
Les opérations logiques, les expressions conditionnelles et les structures de contrôle de flux
dépendent largement de ce type de données.

En Java, true et false sont des mots-clés réservés qui représentent les deux seules valeurs
possibles du type booléen : true est utilisé pour exprimer une condition vraie, tandis que false
est utilisé pour exprimer une condition fausse.
 Représentation des valeurs booléennes dans la mémoire
En interne, les valeurs booléennes sont stockées sous forme de bits dans la mémoire de
l‟ordinateur. Cependant, chaque valeur booléenne ne nécessite qu‟un seul bit pour être
stockée, où true peut être représenté par le bit 1 et false par le bit 0.
true peut être représenté par le bit 1 et false par le bit 0.
 Déclaration de Variables booléennes
En Java, les variables booléennes sont déclarées en spécifiant le type booléen, suivi du
nom de la variable et éventuellement de sa valeur initiale. Voici la syntaxe générale pour
déclarer une variable booléenne : true peut être représenté par le bit 1 et false par le bit 0.
Image 15 : Déclaration de booléens
 Opérations Logiques
En Java, les opérateurs logiques sont utilisés pour combiner ou modifier des valeurs
booléennes. Les opérateurs logiques les plus couramment utilisés sont l‟opérateur AND (&&),
l‟opérateur OR (||) et l‟opérateur NOT (!). Voici une brève explication de chaque opérateur :
 Opérateur AND (&&) : Renvoie true si et seulement si les deux opérandes sont true,
sinon renvoie false.
 Opérateur OR (||) : Renvoie true si au moins l‟un des opérandes est true, sinon renvoie
false.
 Opérateur NOT (!) : Inverse la valeur de l‟opérande ; si l‟opérande est true, renvoie false,
et vice versa.

Image 16: Operations sur les booléens
 Expressions booléennes
En Java, une expression booléenne est une expression qui évalue à une valeur booléenne,
c‟est-à-dire soit true soit false. Ces expressions sont souvent utilisées dans des conditions, des
boucles et d‟autres situations où une évaluation logique est nécessaire.
Une expression booléenne peut être aussi simple qu‟une seule variable booléenne, ou aussi
complexe qu‟une combinaison d‟opérateurs logiques et de valeurs booléennes.
Exemple d’expression booléenne :
 Comparaisons et Conditions
En Java, les valeurs booléennes sont souvent utilisées dans les comparaisons et les
conditions pour prendre des décisions en fonction de certaines conditions. Les opérateurs de
comparaison tels que ==,=, <, <=, >, >= permettent de comparer des valeurs et de produire des
résultats booléens.
Exemple d’utilisation des comparaisons dans des conditions :

Image 17: utilisation des comparaisons dans les conditions
Dans cet exemple, nous comparons les valeurs de x et y à l‟aide de l‟opérateur == et de

l‟opérateur >. Les résultats des comparaisons sont ensuite utilisés dans une structure
conditionnelle (if, else if, else) pour afficher un message en fonction des résultats.
Utilisation des valeurs booléennes dans les instructions conditionnelles :
Utilisation des valeurs booléennes dans les boucles :
 Méthodes et Retours booléens

En Java, les méthodes peuvent également retourner des valeurs booléennes. Cela signifie
qu‟une méthode peut effectuer une opération et renvoyer un résultat booléen, qui peut ensuite
être utilisé dans d‟autres parties du programme.
Définition de méthodes retournant des valeurs booléennes :
Image 18: méthodes retournant des valeurs booléennes
B. Les Tableaux
1. Les tableaux à une dimension
 Déclaration et initialisation des tableaux
En Java, la déclaration d‟un tableau consiste à indiquer le type de données des
éléments qu‟il contiendra, suivi de son nom et des crochets [] pour indiquer qu‟il s‟agit d‟un
tableau. Voici un exemple simple de déclaration de tableau en Java :
Une fois déclaré, le tableau doit être initialisé avant de pouvoir y stocker des éléments. Il
existe plusieurs façons d‟initialiser un tableau en Java :
 Initialisation statique : Les éléments du tableau sont définis directement lors de la

déclaration.
 Manipulation des tableaux

La manipulation de tableaux en Java englobe un large éventail d‟opérations, notamment

l‟ajout et la suppression d‟éléments, le tri des éléments, la recherche d‟éléments spécifiques,
ainsi que la copie de tableaux. Voici des exemples pour illustrer chacune de ces opérations :
 Ajout et Suppression d’Éléments : En Java, les tableaux ont une taille fixe une fois
qu‟ils sont créés. Cela signifie que vous ne pouvez pas ajouter ou supprimer
d‟éléments directement à partir d‟un tableau existant. Cependant, vous pouvez simuler
l‟ajout et la suppression en créant un nouveau tableau avec une taille différente et en
copiant les éléments de l‟ancien tableau. Voici un exemple :
 Tri des Éléments : Le tri des éléments d‟un tableau est souvent nécessaire pour
organiser les données dans un ordre spécifique. En Java, vous pouvez trier les
éléments d‟un tableau en utilisant la méthode Arrays.sort(). Cette méthode trie les
éléments du tableau dans l‟ordre naturel de leurs valeurs. Voici un exemple :
 Recherche d’Éléments : Vous pouvez rechercher un élément spécifique dans un

tableau en parcourant le tableau et en comparant chaque élément avec la valeur
recherchée. Si l‟élément est trouvé, vous pouvez alors prendre l‟action appropriée.
Voici un exemple :
 Copie de Tableaux : Pour copier un tableau en Java, vous pouvez utiliser la méthode
Arrays.copyOf(). Cette méthode crée une nouvelle copie du tableau avec une taille
spécifiée. Voici un exemple :

2. Les tableaux multidimensionnels

En Java, les tableaux multidimensionnels permettent de stocker des données dans une
structure en plusieurs dimensions. Contrairement aux tableaux unidimensionnels qui ne
comportent qu‟une seule rangée de données, les tableaux multidimensionnels peuvent avoir
plusieurs rangées et colonnes, formant ainsi une grille ou une matrice.
La déclaration d‟un tableau multidimensionnel en Java se fait en ajoutant des paires de

crochets supplémentaires pour chaque dimension.
 Cas des tableaux bidimensionnels

Le plus simple du tableau multidimensionnel est un tableau bidimensionnel. Une
définition simple des tableaux 2D est: Un tableau 2D est un tableau de tableaux à une
dimension.
En Java, un tableau à deux dimensions est stocké sous forme de lignes et de colonnes et
est représenté sous la forme d'une matrice.
 Déclaration des tableaux bidimensionnels : la déclaration des tableaux peut se faire comme
suit :
On peut aussi déclarer un tableau comme suit :
 Initialisation : la déclaration des tableaux bidimensionnels en Java se fait comme suit :
Il faut toujours spécifier les tailles différentes dimensions.
On peut également initialiser un tableau multidimensionnel avec des valeurs dès sa

déclaration, comme ceci :

 Accès aux éléments du tableau : Pour accéder aux éléments d‟un tableau
multidimensionnel, on doit spécifier les indices de chaque dimension. Par exemple,
pour accéder à l‟élément à la première ligne et à la deuxième colonne d‟un tableau
bidimensionnel, vous pouvez utiliser :
C. Les Collections
Une collection : gère un groupe d'un ensemble d'objets d'un type donné ; ou bien c'est
un objet qui sert à stocker d'autres objets. Dans les premières versions de Java, les collections
étaient représentées par les "Array","Vector","Stack" etc. Puis avec Java 1.2 (Java 2), est
apparu le framWork de collections qui tout en gardant les principes de bases, il a apporté des
modifications dans la manière avec laquelle ces collections ont été réalisées et hiérarchisées.
Tout en collaborant entre elles, ces collections permettent de réaliser dans des catégories de
logiciels des conceptions réutilisables.
 Collections Framework de Java
Réparties en deux groupes :
 Interfaces
Les interfaces sont organisées en deux catégories : Collection & Map.

• Collection : est un groupe d'objets où la duplication peut être autorisée.
Figure 1: interfaces en java

• Set : est ensemble ne contenant que des valeurs et ces valeurs ne sont pas dupliquées. Par
exemple l'ensemble A = {1,2,4,8}. Set hérite donc de Collection, mais n'autorise pas la
duplication. SortedSet est un Set trié.
• List : hérite aussi de collection, mais autorise la duplication. Dans cette interface, un
système d'indexation a été introduit pour permettre l'accès (rapide) aux éléments de la liste.
• Map : est 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 a des données composées (clé, valeur). SortedMap est un Map trié.
 Implémentations
Le Framework fournit les implémentations suivantes des différentes interfaces :
Classes d'implémentations
Table de Tableau de Arbre balancé Liste chaînée

Hachage taille variable
Interfaces Set HashSet TreeSet
List ArrayList LinkedList
Map HashMap TreeMap

Tableau 4: classes d'implémentations
Par contre, il n'y a pas d'implémentation de l'interface Collection. Pour Set et Map
l'implémentation est soit sous la forme d'une table de hachage (HashSet/HashMap) ou bien
sous la forme d'un arbre (TreeSet/TreeMap). Pour la liste : soit sous la forme de tableau
(ArrayList) ou une liste chaînée (LinkedList).
 Description des interfaces
 Collection
Exemple de code pour une collection

public interface Collection {

// Basic Operations int size();

boolean isEmpty(); boolean contains(Object
element); boolean add(Object element); //
Optional boolean remove(Object element); //
Optional
Iterator iterator();
int hashCode(); boolean
equals(Object element);
// Bulk Operations boolean

containsAll(Collection c); boolean
addAll(Collection c); // Optional boolean
removeAll(Collection c); // Optional boolean
retainAll(Collection c); // Optional void
clear(); // Optional
// Array Operations
Object[] toArray();
Object[] toArray(Object a[]);
}
Les interfaces contiennent des méthodes optionnelles. Cette approche permet de traiter
les collections particulières sans que nous soyons dans l'obligation de définir les méthodes
optionnelles. Ces méthodes optionnelles sont définies qu'en cas de besoin. Un Set non
modifiable n'a pas besoin de redéfinir la méthode add, puisque nous ne pouvons pas le
modifier !
Il y a des opérations réalisées sur un seul objet ou bien sur une collection (un ensemble
d'objets). Nous avons :
 add (remove) : permet d'ajouter (resp. de retirer) un élément.

 addAll (removeAll) permet d'ajouter (resp. de retirer même si les éléments sont
dupliqués dans la collection originale) une collection.
 contains (containsAll) : permet de vérifier si un objet (resp. les éléments d'une
collection) est présent dans la collection.
 size, isEmpty et clear : permettent respectivement de donner la taille de la collection, de
vérifier si la collection est vide et finalement d'effacer le contenu de la collection.
retainsAll se comporte comme le résultat de l'intersection de deux ensembles. Si A=
{1,2,5,8} et B= {3,8} alors A = {8}.
 equals : permet de tester si deux objets sont égaux.

 hashCode : retourne le code de hachage calculé pour la collection.

 toArray : retourne les éléments de la collection sous le format d'un tableau.
 toArray (Object a[]) : permet de préciser le type du tableau à retourner. Si le tableau est
grand les éléments sont rangés dans ce tableau, sinon un nouveau tableau est créé pour
recevoir les éléments de la collection.
L'interface collection est dotée d'une instance d'une classe qui implante l'interface
Iterator. C'est l'outil utilisé pour parcourir une collection. L'interface Iterator contient ce qui
suit :
public interface Iterator {

boolean hasNext (); Object
next(); void remove(); //
Optional }
 hasNext : permet de vérifier s'il y a un élément qui

suit.
 next : permet de pointer l'élément suivant.
 remove permet de retirer l'élément courant.
Exemple de code :
Collection collection = ... ;
Iterator iterator = collection.iterator(); while
(iterator.hasNext()) {
Object element = iterator.next();
if (removalCheck(element)) {
iterator.remove();
}
}
Les collections vues comme des ensembles réalisent les 3 opérations mathématiques
sur des ensembles :
Union : add et addAll
Intersection : retainAll
Différence : remove et removeAll
 Set

Le set : est une interface identique à celle de Collection. Deux implémentations possibles :
 TreeSet : les éléments sont rangés de manière ascendante.

 HashSet : les éléments sont rangés suivant une méthode de hachage.
- Exemple de code
import java.util.*;
public class SetExample {
public static void main(String args[]) {
Set set = new HashSet(); // Une table de Hachage
set.add("Bernadine");
set.add("Elizabeth"); set.add("Gene");
set.add("Elizabeth"); set.add("Clara");
System.out.println(set);
Set SetTrie = new TreeSet(set); // Un Set trié
System.out.println(sortedSet);
}
}
Résultat du code
[Gene, Clara, Bernadine, Elizabeth]

[Bernadine, Clara, Elizabeth, Gene]
 List
Liste est une collection ordonnée. Elle permet la duplication des éléments. L'interface
est renforcée par des méthodes permettant d'ajouter ou de retirer des éléments se trouvant à
une position donnée. Elle permet aussi de travailler sur des sous listes. On utilise le plus
souvent des ArrayList sauf s'il y a insertion d'élément(s) au milieu de la liste. Dans ce cas il
est préférable d'utiliser une LinkedList pour éviter ainsi les décalages.
- Exemple de code pour une List

public interface List extends Collection {
// Positional Access
Object get(int index);
Object set(int index, Object element); // Optional
void add(int index, Object element); // Optional Object
remove(int index); // Optional boolean addAll(int
index, Collection c); // Optional

// Search int
indexOf(Object o); int
lastIndexOf(Object o);
// Iteration
ListIterator listIterator();
ListIterator listIterator(int index);
// Range-view
List subList(int fromIndex, int toIndex);
}
Les méthodes de l'interface List permettent d'agir sur un élément se trouvant à un index
donné ou bien un ensemble d'éléments à partir d'un index donné dans la liste.
 get (remove) retourne (resp. retirer) : l'élément se trouvant à la position index.

 set (add & addAll) modifie (resp. ajouter) l'élément (resp. un seul ou une collection)
se trouvant à la position index.
 indexOf (lastIndexOf) : recherche si un objet se trouve dans la liste et retourner son
(resp. son dernier) index.
 subList : permet de créer un sous liste d'une liste.
Pour parcourir une liste, il a été défini un itérateur spécialement pour la liste.
- Code java
public interface ListIterator extends Iterator {
boolean hasNext();
Object next();
boolean hasPrevious();
Object previous();
int nextIndex();
int previousIndex();
void remove(); // Optional
void set(Object o); // Optional
void add(Object o); // Optional
}

Ceci permet donc de parcourir la liste dans les deux directions et de modifier un élément
(set) ou d'ajouter un nouvel élément.
- Code java
List list = ... ;
ListIterator iterator = list.listIterator(list.size()); while
(iterator.hasPrevious()) {
Object element = iterator.previous();
// traitement d'un élément
}
hasNext : permet de vérifier s'il y a un élément qui suit.

next : permet de pointer l'élément courant.
nextIndex : retourne l'index de l'élément courant.
Pour les sous listes, elles sont extraites des listes de fromIndex (inclus) à toIndex (non
inclus). Tout changement sur les sous listes affecte la liste de base, et l'inverse provoque un
état indéfini s'il y a accès à là sous liste.
Voici un exemple de code complet pour la création des listes et la récupération des éléments
dans celle-ci.
Image 19: code de création d’une liste avec récupération d’élément

Image 20: résultat de la création d'une avec récupération d'éléments
 Map
Le Map : est un ensemble de paires, contenant une clé et une valeur (en réalité, nous
pouvons associer plusieurs valeurs. Dans ce cas-là, nous sommes en présence d'une
multimap).
Deux clés ne peuvent être égales au sens de equals.
L'interface interne Entry permet de manipuler les éléments d'une paire comme suit :
public interface Entry {

Object getKey();
Object getValue();
Object setValue(Object value);
}
 getKey & getValue : retournent respectivement la clé et la valeur associée à cette clé.
 setValue : permet de modifier une valeur d'une paire. Remarque : faire attention de ne
pas modifier directement la valeur associée à une clé. Pour le faire, retirer l'ancienne
clé (et donc sa valeur aussi) et ajouter une nouvelle clé (avec cette nouvelle valeur).
- Exemple de code
public interface Map {
// Basic Operations
Object put(Object key, Object value);
Object get(Object key); Object
remove(Object key); boolean
containsKey(Object key); boolean

containsValue(Object value); int

size(); boolean isEmpty();
// Bulk Operations
void putAll(Map t); void
clear();
// Collection Views public

Set keySet(); public
Collection values(); public
Set entrySet();
// Interface for entrySet elements

public interface Entry { Object
getKey();
Object getValue();
Object setValue(Object value);
}
}
 Values : retourne les valeurs sous la forme d‟une Collection.

 keySet et entrySet : retournent, respectivement, un ensemble (Set) de clés et un
ensemble (set) d'Entry.
Ceci permet donc d'itérer sur les Map comme suit :
Si m est un HashMap alors :
// sur les clés

for (Iterator i = m.keySet().iterator();i.hasNext();)
System.out.println(i.next());
// sur les valeurs

for (Iterator i = m.values().iterator();i.hasNext();)
System.out.println(i.next());
// sur la paire clé/valeur

for (Iterator i = m.keySet().iterator();i.hasNext();){
Map.Entry e = (Map.Entry) i.next();
System.out.println(e.getKey() + " ; " + e.getValue()); }

import java.util.*;
public class MapExample {
public static void main(String args[]) {
Map map = new HashMap();
Integer ONE = new Integer(1); for
(int i=0, n=args.length; i<n; i++) {
String key = args[i];
Integer frequency = (Integer)map.get(key);
if (frequency == null) {
frequency = ONE;
} else {
int value = frequency.intValue();
frequency = new Integer(value + 1);
}
map.put(key, frequency);
}
System.out.println(map);
Map sortedMap = new TreeMap(map);
System.out.println(sortedMap);
}
}
 Description des algorithmes
L'ensemble des algorithmes manipulant les collections se trouve dans la classe Collections
(à ne pas confondre avec l'interface Collection). Ces méthodes ont été définies statiques.
Des algorithmes qui ne s'appliquent que sur des listes :
Trier :
 sort(List list) ; trie une liste.

 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 :
binarySearch(List list, Object element) ; une recherche binaire d'un élément.
binarySearch(List list, Object element, Comparator comp) ; une recherche binaire

d'un élément en utilisant un comparateur.
Des algorithmes qui s'appliquent sur toutes les collections :
Effectuer des recherches extrêmes : min,

max etc.
 min (Collection)
 max (Collection)
 Interface Comparable
Un algorithme extrêmement rapide et stable (les éléments équivalents ne sont pas

réordonnés) est utilisé pour trier la liste en utilisant l'ordre naturel du type. Le tri ne peut avoir
lieu que si les classes implantent la méthode Comparable, ce qui n'est toujours pas le cas 1.
Cette classe contient une seule méthode compareTo:
interface Comparable {
int compareTo(Object obj);
}
Cette méthode retourne :
- Entier positif si l'objet qui fait l'appel est plus grand que obj,
- Zéro s'ils sont identiques,
- Négatif si l'objet qui fait l'appel est plus petit que obj.
Dans le cas d'une classe qui n'implante pas la classe Comparable, ou bien vous voulez
spécifier un autre ordre, vous devez implanter l'interface Comparator. Cette dernière permet

de comparer deux éléments de la collection. Pour trier, nous passons une instance de cette
classe à la méthode Sort ().
interface Comparator { int compare(Object

o1, Object o2); boolean equals(Object
object);
}
class CaseInsensitiveComparator implements Comparator {

public int compare(Object element1,Object element2) {
String lowerE1 = (
(String)element1).toLowerCase();
String lowerE2 = (
(String)element2).toLowerCase();
return lowerE1.compareTo(lowerE2);
}
}
 Les librairies de collections
 Pour le langage C++ il existe une bibliothèque appelée la STL (Standard Templates Library),
l'équivalent pour le langage java est la JGL (Generic Collections Library for Java) développée par
ObjectSpace. Vous pouvez la trouver à cette adresse :
http://www.objectspace.com/products/voyager/downloads.asp
 L'utilisation de la JGL n'est pas conseillée vu sa complexité. Il est conseillé d'installer la
documentation associée. Il est à signaler que la JGL n'a pas été mise à jour depuis la version beta
de java 1.2 ; de ce fait, la version 1.2 de java n'est pas supportée.
D. Les Structures De Données Linéaires
1. Les Piles
Une pile est une structure de données linéaire basée sur le principe du dernier entré,
premier sorti (LIFO = Last In First Out). Imaginez un jeu de cartes ou une pile de livres dans
une boîte. Le livre que vous placez en premier dans la pile est en bas, et le premier que nous
sortirons de la boîte est le livre qui était en haut, c'est à-dire celui qui est entré en dernier dans

la boîte. La structure de données de la pile en Java ou ailleurs dans la programmation

comporte les deux opérations les plus importantes, push et pop. L'opération push insère un
élément dans la pile et l'opération pop supprime un élément du haut de la pile.
 Importance de la pile dans un programme :

L'une des utilisations les plus importantes de la pile est d'organiser les appels de sous-
programmes. Le point d'appel sur la pile stocke l'adresse de retour du sous-programme après
sa fin (et éventuellement les paramètres passés). A chaque appel imbriqué (y compris récursif)
de sous-programmes, de nouvelles adresses de retour sont ajoutées à la pile. A chaque
opération de retour du sous-programme (retour), l'adresse de retour est retirée de la pile et le
contrôle lui est transféré.
Cette application est si importante pour la programmation que dans la plupart des processeurs,
la pile de retour est implémentée dans le matériel du jeu d'instructions.
 Méthodes de pile Java

Cette classe n'a qu'un seul constructeur par défaut et toutes les méthodes de la classe. De plus,
a ses propres 5 méthodes :
• boolean empty() : la méthode vérifie si la pile est vide ou non. Renvoie vrai si la pile est
vide, faux sinon.
• Objet peek () : la méthode renvoie l'élément qui se trouve en haut de la pile.
• Objet pop () : la méthode renvoie l'élément qui se trouve en haut de la pile et le supprime.
• Object push (objet element) : la méthode ajoute l'élément spécifié en haut de la pile.
• int search (Object element) : la méthode recherche dans la pile l'élément spécifié. Si
l'élément recherché est trouvé, sa « distance » par rapport au sommet (numéro de série) est
renvoyée. Si l'élément n'est pas trouvé, -1 est retourné.
 Interface d’une pile en java

Figure : interface d’une pile en java
 Exemple de code de pile

Créons un exemple de programme de pile. Nous allons mettre trois "boules", orange,
violette et verte, sur la pile. Vérifions que la pile n'est pas vide. Ensuite, nous allons extraire
des boules de la pile jusqu'à ce que la pile soit vide.
Figure : Code du programme

Figure : Résultat du code
Etant donné que Stack est hérité de vector Class et implémente l‟interface List, Stack, en
plus des opérations push et pop classiques pour cette structure de données pour l‟ajout de
l‟extraction d‟éléments, a également une norme pour les opérations add() et remove() de la
structure de liste.
Dans notre exemple, l‟ajout d‟éléments peut être implémenté de la même

manière en utilisant les méthodes add(). Cependant, vous pouvez extraire en utilisant
remove() uniquement avec un element spécifié, ce qui n‟a aucun sens pour la structure de
données de la pile
- Code du programme

Image 21 : code de l’exemple piles en java
Image 22 : résultat du code
L'implémentation basée sur la baie est plus simple, plus efficace et plus économe en
mémoire, mais elle nécessite une connaissance préalable de la taille limite de la pile et peut
entraîner des bogues difficiles à trouver. L'implémentation basée sur des listes est plus robuste
mais moins efficace. Faisons une implémentation simple basée sur un tableau de la pile. Il
comprendra des fonctions.
• push : une méthode qui assurera l'ajout d'un élément (en position haute)
• pop : une méthode qui fournira la suppression d'un élément (de la position supérieure)
• readTop : une méthode qui renverra la valeur de l'élément qui est en position supérieure

• sEmpty : une méthode qui vérifiera si la pile est vide
• isFull : une méthode qui vérifiera si notre tableau dans lequel nous stockons la pile n'est pas
plein.
2. Les Files
Une file : est une autre structure de données courante. En plus des piles, de nombreux
langages de programmation, dont Java, implémentent également la structure de données de
file. Quelle est la différence entre une file et une pile ? Une file n'est pas basée sur le principe
LIFO, mais plutôt sur le principe FIFO ("premier entré, premier sorti"). Ce principe est facile
à comprendre en considérant, par exemple, une ligne ordinaire, ou file d'attente, dans la vraie
vie ! Par exemple, une ligne à l'épicerie. Le fonctionnement d'une file est très intuitif, car on
retrouve souvent des files d'attente dans la vraie vie. Il convient de noter séparément qu'en
Java, une file n'est pas représentée par « une classe, mais par une interface » : Queue. De
plus, il existe de nombreuses implémentations de cette interface de file d'attente en Java. Si
nous regardons la documentation d'Oracle, nous verrons que 4 interfaces différentes, ainsi
qu'une liste de classes extrêmement impressionnante, héritent de l'interface Queue. Les files
d'attente doubles sont largement utilisées dans le développement de logiciels.
 Importance de la File java

La file est plus informatique par nature. La file modélise aussi tout système ou l‟entrée
et la sortie se font par le même passage obligatoire : wagons sur une voie de garage, cabine de
téléphérique, etc.
 Méthode de File en java

Comme vous pouvez le voir, implémente l‟interface (encore une fois, cela signifie une
file d'attente à double extrémité). Pourquoi est-ce nécessaire ? Cela nous permet d'obtenir des
éléments du début et de la fin d'un fichier. Cela nous permet également d'ajouter des éléments
au début et à la fin. Voici les méthodes qui proviennent de l‟interface :
• peekFirst() : renvoie le premier élément (mais ne le supprime pas de la file d'attente).
• peekLast() : renvoie le dernier élément (mais ne le supprime pas de la file d'attente).
• pollFirst() : renvoie le premier élément de la file d'attente et le supprime.
• pollLast() : renvoie le dernier élément de la file d'attente et le supprime.
• addFirst() : ajoute un nouvel élément au début de la file d'attente.

• addLast() : ajoute un élément à la fin de la file d'attente.
 Exemple de code de file dans une liste
E. Les Structures De Données Non Linéaires

Les arbres
Une structure de données arborescente est définie comme un ensemble d'objets ou d'entités
appelés nœuds qui sont liés entre eux pour représenter ou simuler une hiérarchie.
Une structure de données arborescente est une structure de données non linéaire car elle n'est
pas stockée de manière séquentielle. Il s'agit d'une structure hiérarchique car les éléments d'un
arbre sont disposés sur plusieurs niveaux.
Dans la structure de données Arbre, le nœud le plus élevé est appelé nœud racine. Chaque
nœud contient des données et les données peuvent être de n'importe quel type. Dans
l'arborescence ci-dessus, le nœud contient le nom de l'employé, le type de données serait donc
une chaîne.
Chaque nœud contient des données et le lien ou la référence d'autres nœuds qui peuvent être
appelés enfants.
Types de structure de données non linéaires ( arbres)
Voici les types de structure de données arborescente :
*Arbre général : l'arborescence générale est l'un des types de structure de données
arborescente. Dans l‟arborescence générale, un nœud peut avoir un nombre maximum de
nœuds de 0 ou n. Il n'y a aucune restriction imposée sur le degré du nœud (le nombre de
nœuds qu'un nœud peut contenir). Le nœud le plus élevé d‟une arborescence générale est
appelé nœud racine. Les enfants du nœud parent sont appelés sous-arbres.

Il peut y avoir n nombre de sous-arbres dans une arborescence générale. Dans l'arborescence
générale, les sous-arbres ne sont pas ordonnés car les nœuds du sous-arbre ne peuvent pas être
ordonnés.
Chaque arbre non vide possède un bord descendant, et ces bords sont connectés aux nœuds
appelés nœuds enfants. Le nœud racine porte le niveau 0. Les nœuds qui ont le même parent
sont appelés frères et sœurs.
*Arbre binaire : ici, le nom binaire lui-même suggère deux nombres, c'est-à-dire 0 et 1. Dans
un arbre binaire, chaque nœud d'un arbre peut avoir au maximum deux nœuds enfants. Ici,
maximum signifie si le nœud a 0 nœud, 1 nœud ou 2 nœuds.
*Arbre de recherche binaire : l'arbre de recherche binaire est une structure de données non
linéaire dans laquelle un nœud est connecté à n n nœuds. Il s'agit d'une structure de données
basée sur des nœuds. Un nœud peut être représenté dans un arbre de recherche binaire avec
trois champs, c'est-à-dire la partie données, l'enfant gauche et l'enfant droit. Un nœud peut être
connecté aux deux nœuds enfants les plus élevés dans un arbre de recherche binaire, de sorte
que le nœud contient deux pointeurs (enfant gauche et pointeur enfant droit).
Chaque nœud du sous-arbre de gauche doit contenir une valeur inférieure à la valeur du nœud
racine, et la valeur de chaque nœud du sous-arbre de droite doit être supérieure à la valeur du
nœud racine.
*Arbre AVL:
C'est l'un des types de l'arbre binaire, ou on peut dire que c'est une variante de l'arbre de
recherche binaire. L'arbre AVL satisfait à la propriété de l'arbre binaire ainsi qu'à celle de
l'arbre de recherche binaire. Il s'agit d'un arbre de recherche binaire auto-équilibré inventé
par Adelson Velsky Lindas. Ici, l‟auto-équilibrage signifie équilibrer les hauteurs du sous-
arbre gauche et du sous-arbre droit. Cet équilibrage est mesuré en termes de facteur
d'équilibrage.
On peut considérer un arbre comme un arbre AVL si l'arbre obéit à l'arbre de recherche
binaire ainsi qu'à un facteur d'équilibrage. Le facteur d'équilibrage peut être défini comme la
différence entre la hauteur du sous-arbre de gauche et la hauteur du sous-arbre de droite. La
valeur du facteur d'équilibrage doit être 0, -1 ou 1 ; par conséquent, chaque nœud de
l'arborescence AVL doit avoir la valeur du facteur d'équilibrage soit 0, -1 ou 1.
Les graphes
Les types de graphiques
Graphique pondéré : dans un graphique pondéré, chaque bord contient des données (poids)
telles que la distance, le poids, la taille, etc. Il est noté w(e). Il est utilisé pour calculer le coût
de déplacement d‟un sommet à un autre.
Graphique non pondéré : un graphique dans lequel les arêtes ne sont associées à aucune
valeur est appelé graphique non pondéré.

Graphique orienté : un graphique dans lequel les arêtes représentent la direction est appelé
un graphique orienté. Dans un graphique orienté, nous utilisons des flèches au lieu de lignes
(bords). La direction indique la manière d'atteindre d'un nœud à un autre nœud. Notez que
dans un graphe orienté, nous pouvons nous déplacer soit dans un sens, soit dans les deux sens.
La figure suivante représente un graphe orienté.
Graphique non orienté : un graphique dans lequel les arêtes sont bidirectionnelles est appelé
un graphique non orienté. Dans un graphe non orienté, nous pouvons parcourir dans n‟importe
quelle direction. Notez que nous pouvons utiliser le même chemin de retour par lequel nous
avons parcouru. Dans le graphe orienté, nous ne pouvons pas revenir du même chemin.
Graphique connecté : un graphe est dit connecté s'il existe au moins un chemin entre chaque
paire de sommets. Notez qu‟un graphe avec seulement un sommet est un graphe connexe.
--> Pour l'implémentation de graphiques en Java, nous utiliserons la classe générique. Pour
créer un objet de classe Java Generic, nous utilisons la syntaxe suivante):
BaseType <ParameterType> obj = new BaseType <ParameterType>();
F. Les Structures De Données De Hachage

Hash Table
Derrière ce nom un peu barbare se cache un mécanisme très simple : les paires « clé-valeur »
sont placées dans un tableau de manière efficace. En fait, au lieu de les ajouter l'une après
l'autre (comme on aurait normalement tendance à faire dans un tableau), on va les éparpiller le
plus uniformément possible.
Déclaration :
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable,
Serializable
Bien évidemment, on ne va pas les mettre n'importe comment, sinon on ne saura plus les
retrouver. Les indices de chaque paire sont déterminés par le hash code de la clé, qui est
donné par une fonction de hachage.
Le tableau porte généralement le nom de bucket array tandis que les cases, vides ou occupées,
sont les buckets (ou alvéoles).
Hash map
Déclaration :

La classe HashMap<K,V> est une implantation particulière de table (K est le type des clés, et
V le type des valeurs). La fonction de recherche de clé est réalisée en un temps presque
constant, grâce à l'utilisation d'une fonction dite de hachage, qui transforme la clé en un entier.
G. Les Classes Et Objets

a. Les classes
Une classe est le plan d‟un objet. Une classe nous permet de créer les types complexes en
regroupant ses attributs, en définissant des champs.
 Déclaration des classes
La déclaration d'une classe se fait de la façon suivante :
[Modificateurs] class NomClasse{
corps de la classe
Le nom de la classe doit débuter par une majuscule.
 Les types de classes
• Les classes final
Une classe peut être déclarée final, dans un but de sécurité ou d‟optimisation. Une classe
finale ne peut être étendue pour créer des sous-classes. Par conséquent, ses méthodes ne
peuvent pas être redéfinies et leur accès peut donc se faire sans recherche dynamique.
Une classe finale ne peut pas être clonée.
• Les classes internes
Une classe Java peut contenir, outre des primitives, des objets (du moins leurs références)
et des définitions de méthodes, des définitions de classe. Nous allons maintenant nous
intéresser de plus près à cette possibilité.
• Plusieurs classes dans un même fichier
Il arrive fréquemment que certaines classes ne soient utilisées que par une seule autre
classe. Considérons l‟exemple suivant :

Class Animal {
// champs
boolean vivant ; int âge ;
Coordonnées position ;
// constructeurs
Animal() {
position = new Coordonnées() ;
}
}
Class Coordonnées {
// champs
int x = 0; int y = 0;
}
Toutes ces classes sont définies dans le même fichier, ce qui convient dans le cadre de
la démonstration mais certainement pas pour la pratique courante de la programmation
efficace. Chacune de ces classes pourrait être définie séparément dans un fichier et affectée à
un package.
Lors de la compilation du précédent fichier, le compilateur produit deux fichiers :

Animal.class et Coordonnées.class.
• Les classes imbriquées ou static
Lorsque celle-ci concerne uniquement «la classe principale». Voyons pour notre exemple
:
Class Animal {
// champs
boolean vivant ; int âge ;
Coordonnées position ;
// classes imbriquées
static Class Coordonnées {
// champs
int x = 0; int y = 0;
}
// constructeurs
Animal() {
position = new Coordonnées() ;

}
}
Ailleurs, la référence à la classe Coordonnées devient Animal.Coordonnées. De

manière générale, les références à une classe imbriquée en Java se font en utilisant le point
comme séparateur.
Lors de la compilation du fichier ci-dessus, le compilateur produit deux fichiers :

Animal.class et Animal$Coordonnées.class pour la classe imbriquée.
Quant au chemin d‟accès, notons que mesclasses.Animal désigne la classe Animal

dans le package mesclasse, tandis que mesclasses.Animal.Coordonnées désigne la classe
Coordonnées imbriquée dans la classe Animal, elle-même contenu dans le package
mesclassses. Ainsi il est possible d‟utiliser la directive import pour importer les classes
imbriquées explicitement ou en bloc :
import mesclasses.Animal.Coordonnées ;
import mesclasses.Animal.* ;
Les classes imbriquées peuvent elles-mêmes contenir d‟autres classes imbriquées, sans
limitation de profondeur, du moins du point de vue de Java.
La classe Coordonnées a été déclarée static, ce qui est obligatoire pour toute classe
imbriquée. En revanche, les interfaces imbriquées sont automatiquement déclarées static et il
n‟est donc pas nécessaire de les déclarer explicitement comme telles.
• Les classes membre
• Les classes locales
• Les classes anonymes
 Création d’objets (object)
Tout objet java est une instance d‟une classe. Pour allouer la mémoire nécessaire à cet
objet, on utilise l‟opérateur new, qui lance l'exécution du constructeur.
La création d‟un Animal se fait à l‟aide de l‟instruction suivante :
Animal nouvelAnimal = new Animal(3);

 Initialisation des objets
Il existe en Java trois éléments pouvant servir à l‟initialisation :
- les constructeurs,
- les initialiseurs de variables d‟instances et statiques,
- les initialiseurs d‟instances et statiques.
Les initialiseurs de variables d’instances et statiques
Considérons la déclaration de variable suivante :
int a ;
Si cette déclaration se trouve dans une méthode, la variable n‟a pas de valeurs. Toute
tentative d‟y faire référence poduit une erreur de compilation.
En revanche, s‟il s‟agit d‟une variable d‟instance (dont la déclaration se trouve en

dehors de toute méthode), Java l‟initialise automatiquement au moment de l‟instanciation
avec une valeur par défaut. Pour les variables statiques, l‟initialisation est réalisée une fois
pour toute à la première utilisation de la classe.
Les variables de type numérique sont initialisées à 0. Le type booléen est initialisé à
false.
Nous pouvons cependant initialiser nous-mêmes les variables de la façon suivante :
int a = 1 ;
int b = a*7 ;
float c = (b–c)/3 ;
boolean d = (a < b) ;
Les initialiseurs de variables permettent d‟effectuer des opérations d‟une certaine

complexité, mais celle-ci est tout de même limitée. En effet, ils doivent tenir sur une seule
ligne. Pour effectuer des opérations plus complexes, il convient d‟utiliser les constructeurs ou
encore les initialiseurs d‟instances.
Les initialiseurs d’instances

Un initialiseur d‟instance est tout simplement placé, comme les variables d‟instances,
à l‟extérieur de toute méthode ou constructeur.
Voyons l‟exemple suivant :
class Exemple {
// champs
int a ;
int b ;
float c ;
boolean d ;
// initialiseurs
a=1;
b = a*7 ;
c = (b-a)/3 ;
d = (a < b);
}
Les initialiseurs d‟instances permettent de réaliser des initialisations plus complexes.

Ils offrent en outre l‟avantage par rapport aux constructeurs d‟être beaucoup plus rapides. De
plus les initialiseurs permettent d‟utiliser les exceptions pour traiter les conditions d‟erreurs.
Un autre avantage des initialiseurs est qu‟ils permettent d‟effectuer un traitement quelle que
soit la signature du constructeur appelé. Il est ainsi possible de placer le code d‟initialisation
commun à tous les constructeurs dans un initialiseur et de ne traiter dans les différents
constructeurs que les opérations spécifiques.
Les initialiseurs comportent cependant des limitations. Il n‟est pas possible de leur
passer des paramètres comme dans le cas des constructeurs. De plus, ils sont exécutés avant
les constructeurs et ne peuvent donc utiliser les paramètres de ceux-ci.
Les initialiseurs statiques
Un initialiseur statique est semblable à un initialiseur d‟instance, mais il est précédé du

mot static. Considérons l‟exemple suivant :
class Voiture {
// champs
static int capacité ;

// initialiseurs
static {
capacité = 80;
println("La variable vient d’être initialisée.\n") ;
}
// constructeurs
Voiture() {
}
// méthodes
static int getCapacité() {
return capacité;
}
}
L‟initialiseur statique est exécuté au premier chargement de la classe, que ce soit pour
utiliser un membre statique, Voiture.getCapacité()ou pour l‟instancier, Voiture maVoiture =
new Voiture().
Les membres statiques (ici la variable capacité) doivent être déclarés avant
l‟initialiseur. Il est possible de placer plusieurs initialiseurs statiques, où l‟on souhaite dans la
classe. Ils seront tous exécutés au premier chargement de celle-ci, dans l‟ordre où ils
apparaissent.
 La destruction des objets (garbage collector)
Avec certains langages, le programmeur doit s‟occuper lui-même de libérer la

mémoire en supprimant les objets devenus inutiles. Avec Java, le problème est résolu de
façon très simple : un programme, appelé garbage collector, ce qui signifie littéralement «
ramasseur d‟ordures », est exécuté automatiquement dès que la mémoire disponible devient
inférieure à un certain seuil. De cette façon, aucun objet inutilisé n‟encombrera la mémoire.
 Hiérarchie des classes
De plus chaque classe dérive d‟une classe de niveau supérieur, appelée sur-classe. Cela est
vrai pour toutes les classes sauf une. Il s‟agit de la classe Object, qui est l‟ancêtre de toutes les classes.

Toute instance d‟une classe est un objet du type correspondant, mais aussi du type de toutes ses classes
ancêtres.
SousClasse hérite de toutes les caractéristiques de Classe, et donc, par transitivité, de

SurClasse.
Une classe est toujours construite à partir d‟une autre classe dont elle est dérivée. Une classe
dérivée est une sous-classe d'une sur-classe.
• Extends
Lorsque le paramètre extends est omis, la classe déclarée est une sous classe de l'objet Objet.
b. Les objets
1. présentation des objets
Un objet est une instance d‟une classe, qui est l‟outil fondamental de programmation.
Une classe peut aussi être considérée comme une description de ce qu‟il faut faire pour créer
un objet. Les classe sont composées de méthodes et d‟attributs qui peuvent être public, private
ou protected.
Les différentes valeurs d‟un objet sont appelées attributs.
Pour accéder à la valeur d‟un attribut, on utilise la syntaxe suivante :
//accès à la valeur de l’attribut
TypeAttribut monAttribut = monObjet.nomAttribut;
//affectation d’une valeur à l’attribut
monObjet.nomAttribut = valeurAttribut;
Il peut exister des méthodes spécifiques permettant d‟interroger ou de transformer les

valeurs des attributs d‟un objet.
Pour appeler une méthode sur un objet, on utilise la syntaxe suivante :
TypeRetour valeurRetour = monObjet.nomMethode(parametre_1,.., parametre_N);
La méthode nomMethode permet d‟accéder ou de modifier les valeurs des attributs de

monObjet.

Si une méthode n‟accède pas ou ne modifie pas les attributs de l‟objet, on dit que cette
méthode est static.
La déclaration de la méthode est précédée du mot clé static.
2. Les types d’objets
a. L’objet prédéfini string
Il existe de nombreux objets prédéfinis en Java. Nous allons dans cette section
présenter l‟un d‟entre eux, incontournable
Le type “chaîne de caractères”, appelé String. Cet objet est le seul qui sera réellement
manipulé en première année.
Une chaîne de caractères représente un texte. C‟est une collection linéaire de

caractères qu‟il n‟est pas possible de modifier une fois que l‟objet a été instancié et initialisé.
Ces opérations se font selon la syntaxe :
//Déclaration, instanciation et initialisation
String ecole = new String("INSA-Lyon");
Noter la présence de guillemets doubles pour distinguer les chaînes de caractères des
éléments du langage de programmation Java (mots du langage, nom de variables, nom de
méthodes).
Comme le type String est très utilisé, une particularité de ce type est que l‟on accède à
l‟attribut principal de l‟objet, la chaîne de caractères, comme si c‟était un type primitif :
System.out.println(ecole); // affiche "INSA-Lyon"
Les objets de type String sont fournis avec un grand nombre de méthodes permettant
une manipulation facile de ces objets. Les quatre principales méthodes permettent d‟accéder à
chaque caractère de la chaîne, de connaître le nombre de caractères de la chaîne (sa longueur),
d‟extraire une partie de la chaîne et de comparer le contenu de deux chaînes :
• char charAt(int n) : cette méthode prend en paramètre un entier n et renvoie le n+ 1 ème

caractère de la chaîne (le premier caractère est à l‟indice 0 et le n + 1 ème à l‟indice n).

char c = ecole.charAt(2); //c contient le caractère ’S’

• int length() : cette méthode renvoie la longueur de la chaîne de caractères.

int longueur = ecole.length(); // longueur contient 9
Notez les parenthèses de la méthode length, parenthèses absentes lorsque l‟on appelle
cette méthode sur un tableau.
• String substring(int debut, int fin) : cette méthode renvoie un objet de type String qui
contient la sous-chaîne de caractères commençant à l‟indice debut et se terminant à l‟indice

fin-1.
//équivaut à String ecole = new String("INSA-Lyon");

String ville = ecole.substring(5, ecole.length());
ecole.substring(5, 9), ville contient "Lyon"
• equals(String s) : cette méthode renvoie une variable de type booléen qui vaut vrai si et
seulement si la chaîne de caractères s est la même que la chaîne de caractères de l‟objet sur
lequel on appelle la methode:
String ecoleA = new String("INSA-Lyon");

String ecoleB = new String("INSA-Lyon");
if(ecoleA.equals(ecoleB) == true){
//cette condition est satisfaite
if(ecoleA == ecoleB){
//cette condition n’est pas satisfaite,
//les deux objets n’ayant pas la même adresse
}
}
Une opération fréquente consiste à “coller” bout-à-bout deux chaînes de caractères. On

appelle cela la concaténation. L‟opérateur associé est + :
String ville = new String("Lyon");

String ecole = new String("INSA");
String monEcole = ecole + "-" + ville; // monEcole contient "INSA-Lyon"
Il peut être nécessaire de pouvoir convertir un type primitif en une chaîne de caractères
ou réciproquement.
La conversion d‟un type primitif en une chaîne de caractères se fait à l‟aide de l‟instruction
String.valueOf(valeurPrimitive);

int valeur = 22;

String chaine = String.valueOf(valeur); // chaine contient "22"
La conversion d‟une chaîne de caractères en un type primitif se fait à l‟aide des

instructions suivante :
Integer.parseInt(chaine); // renvoie une valeur de type int

Double.parseDouble(chaine); // renvoie une valeur de type double
Boolean.parseBoolean(chaine);// renvoie une valeur de type boolean
chaine.charAt(i); // renvoie une valeur de type char
String chaine = "22" ;
int valeur = Integer.parseInt(chaine); //valeur vaut 22
b. les objets propres
On peut également définir ses propres objets. C‟est ce que nous allons apprendre à
faire ici, en illustrant notre propos sur l‟exemple du début de section.
Les classes permettent de définir des types ou des catégories d‟objets (on pourra
prendre la métaphore du moule des objets). Elles contiennent la description des objets, (ex :
les abonnés), c‟est-à-dire métaphore du moule des objets). Elles contiennent la description des
objets, (ex : les abonnés), c‟est-à-dire qu‟elles définissent les attributs et les méthodes
communes aux objets d‟un certain type.
Les objets construits à partir de ces classes sont des instances. Les instances sont des
éléments créés depuis
La syntaxe de déclaration d‟une classe est :
class NomType {
// le corps de la classe vient ici
// les attributs
// les méthodes
}
On commence généralement par déclarer les attributs de la classe :
class Abonne {
//les attributs de la classe Abonne
String nom;
String prenom;

int nbLivres;
int nbJours;
}
Le constructeur : Toute classe doit contenir au moins une méthode particulière

appelé constructeur. Cette méthode porte le même nom que la classe et est appelée lorsque
l‟on instancie un nouvel objet. C‟est cette fonction qui généralement initialise les valeurs des
attributs. Cette méthode ne renvoie aucune valeur.
class Abonne {
//les attributs de la classe Abonne
String nom;
String prenom;
int nbLivres;
int nbJours;
Abonne() {
// premier constructeur
nom = new String("");
prenom = new String("");
nbLivres = 0;
nbJours = 0;
age = 0;
}
Abonne(String nom, String prenom, int nbLivres, int nbJours) {
// deuxième constructeur
this.nom = new String(nom);
this.prenom = new String(prenom);
this.nbLivres = nbLivres;
this.nbJours = nbJours;
}
}
Il peut exister plusieurs constructeurs qui se distinguent par leurs paramètres formels.
Ainsi, en fonction des paramètres effectifs (nombre de paramètres ou types des paramètres)
passés au constructeur au moment de l‟appel, l‟un ou l‟autre des constructeurs sera appelé.
Le mot clé this permet de spécifier que l‟attribut que l‟on référence est celui de l‟objet
en cours de con struction. En effet, l‟expression this.nom = nom; signifie que l‟attribut nom

de l‟objet en cours de con struction (this.nom) prend la valeur du paramètre formel nom de
type String du constructeur.
EXEMPLE : Regardons maintenant comment on peut construire notre programme qui

indique les abonnés qui ont emprunté un livre depuis plus de 21 jours. Nous venons de voir la
classe Abonne qui contient les attributs d‟un abonné. Ajoutons une méthode
renseigneUnAbonne qui permet de spécifier les nouvelles valeurs des attributs :
void renseigneUnAbonne(String nom, String prenom, int nbLivres, int nbJours) {

this.nom = new String(nom);
this.prenom = new String(prenom);
this.nbLivres = nbLivres;
this.nbJours = nbJours;
}
La classe EnsembleDesAbonnes va contenir l‟ensemble des abonnés de la

bibliothèque. Ses attributs sont alors un tableau d‟abonnés (lesAbonnes) et un entier qui
indique le nombre d‟abonnés. Son construc teur alloue l‟emplacement mémoire nécessaire au
tableau lesAbonnes et instancie chacun des abonnés :
class EnsembleDesAbonnes {
//Attributs de la classe EnsembleDesAbonnes
Abonne[] lesAbonnes;
int nbAbonnes;
//Constructeur
EnsembleDesAbonnes(int nbAbonnes) {
lesAbonnes = new Abonne[nbAbonnes];
this.nbAbonnes = nbAbonnes;
int i;
for(i = 0; i < this.nbAbonnes; i++) {
lesAbonnes[i] = new Abonne(); // instancie chaque abonné
}
}
}
Les attributs de la classe doivent être initialisés dans le constructeur, et en particulier,

les attributs de type non-primitifs doivent être instanciés via le mot clé new qui réserve
l‟emplacement mémoire de cet attribut.

Enfin, la méthode estEnRetard, qui renvoie la liste des abonnés dont le dernier
emprunt a été effectué il y a plus de 21 jours, compte le nombre d‟abonnés en retard, puis crée
un nouvel objet EnsembleDesAbonnes pouvant contenir tous les abonnés en retard, puis
recopie l‟adresse des abonnés en retard dans l‟objet resultat pouvant contenir tous les abonnés
en retard, puis recopie l‟adresse des abonnés en retard dans l‟objet resultat :
EnsembleDesAbonnes estEnRetard() {
int i;
int nbEnRetard = 0;
for(i = 0; i < lesAbonnes.length; i++) {
if( (lesAbonnes[i].nbJoursEmprunts > 21)&&(lesAbonnes[i].nbLivresEmpruntes
> 0)) {
nbEnRetard = nbEnRetard + 1;
}
}
EnsembleDesAbonnes resultat = new Abonnes(nbEnRetard);
int j = 0;
for(i = 0; i < lesAbonnes.length; i++) {
if( (lesAbonnes[i].nbJoursEmprunts > 21)
&&(lesAbonnes[i].nbLivresEmpruntes > 0)) {
resultat.lesAbonnes[j] = this.lesAbonnes[i];
j = j + 1;
}
}
return resultat;
}
Le tableau lesAbonnes de l‟objet resultat contient des références vers les abonnés du
tableau lesAbonnes de l‟objet en cours de définition.
Enfin, la méthode main de la classe EnsembleDesAbonnes instancie un objet

mesAbonnes comportant 4 abonnés, et appel la méthode estEnRetard sur cet objet qui renvoie
un nouvel objet abonnésEnRetard qui contient un tableau de références vers les abonnés en
retard :
public static void main (String[] args) {

EnsembleDesAbonnes mesAbonnes = new EnsembleDesAbonnes(4);
mesAbonnes.lesAbonnes[0].renseigneUnAbonne("Dupond", "Luc",4,0);

mesAbonnes.lesAbonnes[1].renseigneUnAbonne("Martin", "Jeanne",1,30);
mesAbonnes.lesAbonnes[2].renseigneUnAbonne("Vaus", "Paul",2,22);
mesAbonnes.lesAbonnes[3].renseigneUnAbonne("Bon", "Jean",0,27);
EnsembleDesAbonnes abonnesEnRetard = mesAbonnes.estEnRetard();
// abonnesEnRetard contient les références à Jeanne Martin et Paul Vaus
}
H. Les Flux Et Les Fichiers
A. Les flux
Il existe plusieurs classes prédéfinies en Java permettant de créer et manipuler des flux.
On distingue les flux selon 2 critères :
• Leur direction (flux en lecture ou en écriture), l„élément atomique pouvant être lu

ou écrit.
• Les classes relatives aux flux sont pour la plupart regroupées dans le paquetage
java.io, mais aussi dans d‟autres paquetages (java.util, java.util.zip, java.security,
javax.crypto)
1. Flux d’octets
Deux hiérarchies de classes prédéfinies existent en Java pour les flux d‟octets.
• La classe java.io.InputStream est la racine de la hiérarchie d‟héritage des classes

concernant les flux d‟octets en lecture (en entrée).
• La classe java.io.OutputStream est la racine de la hiérarchie d‟héritage des classes

concernant les flux d‟octets en écriture (en sortie)
2. Interface Closeable
Une seule méthode : ferme le flux et libère toutes les ressources systèmes associées au
flux. N‟a aucun effet si le flux est déjà fermé

Figure 2 : Interface Closeable
InputStream (abstraite)
Méthodes de lecture
abstract int read() throws IOException lit et retourne l‟octet suivant. Retourne -1 si
EOF. levée Bloque jusqu‟à la lecture de l‟octet, EOF ou d‟une IOException.
int read(byte[] t) throws IOException lit jusqu‟à t.length octets, les range dans t et retourne
le nombre d‟octets lus ou -1 si EOF. Lève une NullPointerException si t vaut null.
• InputStream (abstraite)
Méthodes de lecture (suite)
int read(byte[] t, int d, int lg) throwsIOException lit jusqu‟à lg octets, les range dans t à
partir de l‟indice d et retourne le nombre d‟octets lus ou -1 si EOF. Lève une
NullPointerException si t vaut null.
Autres méthodes
int available() retourne le nombre d‟octets disponibles (pouvant être lus sans bloquer avec
read()).
void close() throws IOException ferme le flux.
long skip(long n) throws IOException saute n octets et retourne le nombre d‟octets

effectivement sautés.

Autres méthodes (suite)
void mark(int limite) throws IOException positionne une marque à laquelle il est possible
de revenir par un reset. limite indique le nombre d‟octets pouvant être lus avant que cette
marque soit invalidée.
Boolean markSupported() throws IOException retourne true si et seulement si le flux

autorise l‟utilisation de mark et reset.
void reset() throws IOException repositionne la lecture à la dernière marque placée dans le
flux. Une IOException est levée si aucune marque valide existe ou si les marques ne sont pas
autorisées par le flux.
• FileInputStream
Constructeurs
FileInputStream (String name) throws FileNotFoundException ouvre une connexion en

lecture sur le fichier nommé name dans le système de fichiers. Levée d‟exception s‟il n‟est
pas possible de lire dans le fichier.
FileInputStream (File file) throws FileNotFoundException ouvre une connexion en

lecture sur le fichier file. Levée d‟exception s‟il n‟est pas possible de lire dans le fichier.
FileInputStream (FileDescriptor fd) throwsFileNotFoundException initialise le

FileInputStream d‟après fd (pouvant être obtenue) depuis une connexion existante).
• FileInputStream
Méthodes additionnelles
FileDescriptor getFD() throws IOException retourne le FileDescriptor représentant la

connexion courante au fichier.
FileChannel getChannel() throwsIOException retourne le FileChannel représentant la

connexion courante au fichier (avec la même position de lecture).
FilterInputStream(abstraite) La classe FilterInputStream est une classe abstraite dont

héritent de nombreuses sous-classes destinées à être des « décorateurs » pour un InputStream
existant, dont notamment :
BufferedInputStream

DataInputStream
InflaterInputStream (dans le paquetage java.util.zip)
• BufferedInputStream
Constructeurs
BufferedInputStrean (InputStream in) décore in en le dotant d‟un accès tamponné de 8192

octets.
BufferedInputStrean (InputStream in, inttaille) décore in en le dotant d‟un accès

tamponné de taille octets.
DataInputStream La classe DataInputStream hérite de FilterInputStream et réalise

l‟interface DataInput.
Constructeur
• DataInputStrean (InputStream in) décore in en le dotant d‟un accès conforme à

l‟interface DataInput.
• DataInputStream
Méthodes imposées par l‟interface DataInput (levée d‟une exception EOFException si

tentative de lire au-delà de la fin du flux)
void readFully(byte[] tab) lit tab.length octets dans le flux et les place dans tab, méthode
bloquante.
void readFully(byte[] tab, int d, int l) lit l octets dans le flux et les place dans tab, à partir
de l‟indice d, méthode bloquante.
int skipBytes(int n) tente de sauter n octets dans la lecture du flux et retourne le nombre
d‟octets effectivement sautés.
• DataInputStream

tentative de lire au-delà de la fin du flux) :
boolean readBoolean() lit l‟octet suivant et retourne true s‟il est différent de 0, false sinon.

byte readByte() lit 1 octet.
short readShort() lit 2 octets.
char readChar() lit 2 octets.
• DataInputStream Méthodes imposées par l‟interface DataInput (levée d‟une

exception EOFException si tentative de lire au-delà de la fin du flux) :
int readInt() lit 4 octets.
long readLong() lit 8 octets.
float readFloat() lit 4 octets.
double readDouble() lit 8 octets.
• DataInputStream Méthodes imposées par l‟interface
• DataInput (levée d‟une exception EOFException si tentative de lire au-delà de la fin

du flux) :
int readUnsignedByte()lit octet.
int readUnsignedShort() lit 2 octets.
• DataInputStream

tentative de lire au delà de la fin du flux) :
String readLine() lit plusieurs octets en les interprétant chacun comme des caractères
qui sont mis dans la String retournée. La lecture s‟arrête à une fin de ligne ou en fin de flux.
String readUTF() lit plusieurs octets constituant une chaîne de caractères au format
UTF8 modifié et retourne la String correspondante.
Exemple de lecture basique

B.LES FICHIERS
1. Manipulation des fichiers avec java.nio

#L'API java.nio.Files pour remplacer l'API existante java.io.File. Comme on va le
voir, la nouvelle API de java.nio.Files (opens new window) rend la manipulation des fichiers
et des répertoires très simple. Cet article décrit les méthodes de manipulation des fichiers et
des répertoires (ie, création, copie, déplacement, suppression) mais l'API comporte également
tout ce qu'il faut pour :
• La lecture et l'écriture de fichier (synchrone ou asynchrone),
• Le listage du contenu d'un répertoire,
• La notification des changements dans un répertoire et
• La manipulation de FileSystem (opens new window).
Sur la partie manipulation de fichier et de répertoire, les principales méthodes de l'API
décrites dans cet article sont les suivantes :

a. Création d’un fichier

Créer un fichier est aussi simple que créer un répertoire avec la méthode
java.nio.Files.createFile. Là encore, la méthode renvoie une exception si le fichier existe déjà.

b. Gestion des attributs de la création

Pour la création d'un fichier ou d'un répertoire, il est possible de spécifier les
attributs du système de fichier à utiliser. Sur les systèmes POSIX, cela revient à
donner les permissions à appliquer lors de la création du fichier. Ces permissions sont
définies par la classe PosixFilePermission. Il est facile de créer les permissions
souhaitées via la méthode statique.

Dans l'exemple précédent, le fichier a bien les droits d'écriture puisque ceux-ci ont été
donnés au propriétaire du fichier, ie l'utilisateur qui a lancé le programme. En revanche, le
fichier n'est pas considéré comme exécutable puisque personne n'a les droits d'exécution.
c. copier un fichier
La copie d'un fichier passe par la méthode Files.copy qui prends en paramètre les Path source
et destination de la copie :
Par défaut, Files.copy génère une exception FileAlreadyExistsException si le Path de

destination existe déjà. Il est cependant possible de demander à remplacer la destination plutôt
que de générer une exception dans ce cas-là. Pour cela, il faut spécifier l'option
StandardCopyOption.REPLACE_EXISTING lors de la copie :

c. Déplacer un fichier
Pour déplacer un fichier, il faut utiliser la méthode Files.move. Tout comme File.copy,
cette méthode prend en paramètre des Path sources et destinations.

Là encore, par défaut, cette méthode génère une exception si le Path de destination
existe déjà. Ce comportement se change en passant l'option
StandardCopyOption.REPLACE_EXISTING en dernier paramètre de la méthode :
e. supprimer un fichier
Il suffit d'appeler la méthode Files.delete pour supprimer un fichier :

Dans le cas où le fichier à supprimer n'existe pas, Files.delete génère une exception de type
NoSuchFileException. Pour ignorer ces cas, il faut utiliser la méthode deleteFileIfExists.
I. Les Enregistrements
En Java, un type enregistrement est défini à l'aide d'une classe, dans laquelle les
variables membres représentent les champs de l'enregistrement. Les variables membres sont
déclarées au début de la classe juste après l'accolade ouvrante.
Principales propriétés des enregistrements
• Le nom du type est libre (doit se conformer à la règle d‟écriture des identificateurs Java)
• Les noms des champs sont libres (idem : doivent être des identificateurs)
• Si m est le nom d‟un champ d‟un type enregistrement E et o un objet de type E, alors :
=> o.m permet de lire la valeur de la composante m de o
=> o.m = v est l‟affectation qui permet de modifier la valeur de la composante m de o.
• L‟opérateur new permet de créer un nouvel objet :
E o = new E();
• Tous les champs d‟un objet créé sont initialisés au zéro de leur type respectif.
Différence majeure entre un tableau et un enregistrement

Un tableau est un type complexe qui représente une catégorie de données dont la
valeur est une liste d‟éléments indépendants et de même nature (p. ex. une liste de
températures moyennes journalières). Mais comment représenter une donnée qui se compose
d‟un ensemble d‟éléments appartenant à des catégories différentes, par exemple, un compte

d‟utilisateur qui se compose d‟un identifiant (un entier), d‟un nom d‟utilisateur (un texte) et
d‟un nom complet ? La réponse est : avec un type enregistrement (record type).
Définir un type enregistrement (Déclaration)

En Java, un type enregistrement est défini à l‟aide d‟une classe, dans laquelle les
variables membres représentent les champs de l‟enregistrement. Les variables membres sont
déclarées au début de la classe juste après l‟accolade ouvrante. La déclaration d‟une variable
membre est similaire à celle d‟une variable locale, mais elle est précédée du modificateur
public. La figure 1 montre une définition possible du type UserAccount.
Nous pouvons, par exempe, déclarer ou définir une variable de type UserAccount,
déclarer paramètre formel du même type, ou encore définir une fonction qui renvoie un
enregistrement de ce type.
public class App {

public static void main(String[] args) {
UserAccount myAccount;
}
}
La variable est déclarée, mais pas encore définie. S‟il s‟agissait d‟un entier ou d‟une
chaîne de caractères, nous pourrions lui affecter une valeur littérale. Mais les valeurs de type
enregistrement n‟ont pas de représentation littérale en Java. Pour affecter une valeur à la
variable myAccount, nous devons créer une nouvelle instance du type UserAccount avec
l‟opérateur new.
public class App {

UserAccount myAccount = new UserAccount();
}
}
( Créer une nouvelle instance de UserAccount)
Avec l‟expression new UserAccount(), nous avons créé une instance de UserAccount
dans la mémoire, mais les valeurs des champs n‟ont pas été définies. Nous devons donc
initialiser chaque champ en lui affectant une valeur. On référence un champ d‟une variable
par le nom de la variable suivi immédiatement d‟un point et du nom du champ
(<variable>.<champ>).

public class App {

myAccount.uid = 10000;
myAccount.userName = "lovelacea";
myAccount.displayName = "Ada Lovelace";
}
}
( Initialiser les variables membres)
Maintenant que les champs ont une valeur, nous pouvons faire quelque chose de cette
variable; par exemple, la passer en paramètre à une méthode qui écrit le displayName dans la
sortie standard.
public class App {
myAccount.uid = 10000;
myAccount.userName = "lovelacea";
myAccount.displayName = "Ada Lovelace";
printDisplayName(myAccount);
}
public static void printDisplayName(UserAccount account) {

System.out.println(account.displayName);
}
}
(Utiliser la variable de type UserAccount)
Ce code fonctionne, mais il a un gros défaut. Comme un enregistrement n‟est pas
cohérent tant que tous les champs ne sont pas initialisés, c‟est une mauvaise idée de laisser à
l‟utilisateur du type le soin de le faire. Voyons comment nous pouvons traiter ce problème.
Encapsuler la création d’une instance

Une première possibilité est de créer une fonction qui prend en paramètre les données
de l‟enregistrement et qui renvoie une nouvelle instance de l‟enregistrement initialisée.
public class App {
UserAccount myAccount = createUserAccount(1000, "lovelacea",
"Ada Lovelace");
}
public static UserAccount createUserAccount(int uid, String userName,

String displayName) {
UserAccount a = new UserAccount();
a.uid = uid;
a.userName = userName;
a.displayName = displayName;
return a;
}
}
}
(Encapsuler la création de l'instance, 1er essai)
C‟est bien, mais la classe App n‟est probablement pas le meilleur endroit pour
implémenter la méthode createUserAccount. Puisqu‟elle sert à instancier un enregistrement de
type UserAccount et que ce type est défini avec une classe, pourquoi ne pas l‟implémenter la
méthode de création dans cette classe ? Faisons donc cela.
public class UserAccount {
public int uid;
public String userName;
public String displayName;
public static UserAccount createUserAccount(int uid, String userName,
String displayName) {
UserAccount a = new UserAccount();

a.uid = uid;
a.userName = userName;
a.displayName = displayName;
return a;
}
}
(Encapsuler la création de l'instance, 2e essai)
Voilà qui est beaucoup mieux. Comme une telle méthode est nécessaire pour tous les
types enregistrement, on peut s‟attendre à ce que cela soit prévu par le langage. C‟est
effectivement le cas : en Java, une classe peut avoir un ou plusieurs constructeurs. Le code
suivant montre le même programme que le précédent, mais avec un constructeur à la place de
la méthode de création.
public class App {
// Pour invoquer le constructeur, on utilise la même syntaxe que pour
// instancier un enregitrement vide, mais en passant les valeurs des
// champs en paramètres.
UserAccount myAccount = new UserAccount(1000, "lovelacea",
"Ada Lovelace");
}
}
}
package ch.epai.ict.exemples.record_types;

public int uid;
public String userName;
public String displayName;

// La définition du constructeur ressemble à la définition d'une méthode,

// mais il n'y a pas de modificateur static ni de spécification du type
// de retour. Le nom d'un constructeur est toujours identique à celui de
// la classe. Dans le constructure, on référence le nouvel enregistrement
// avec le mot clé `this`. Enfin, il n'y a pas d'instruction return.
public UserAccount(int uid, String userName, String displayName) {
this.uid = uid;
this.userName = userName;
this.displayName = displayName;
}
}
(Utilisation d'un constructeur)
En Java, une classe qui implémente un type enregistrement devrait toujours avoir au
moins un constructeur. Le rôle d‟un constructeur est d‟initialiser la valeur de toutes les
variables membres de la classe. Cela permet d‟assurer la cohérence des enregistrements.
Type enregistrement immuable

Lorsqu‟on initialise une variable de type int avec la valeur 1, par exemple, il n‟est pas
possible de modifier la valeur 1. On peut bien sûr donner une autre valeur à la variable, mais
la valeur 1, elle reste inchangée. On dit que la valeur est immuable (immutable). En Java,
c‟est aussi le cas des chaînes de caractères. Lorsque l‟on concatène deux chaînes de
caractères, on crée une troisième qui contient les deux chaînes appondues, mais les deux
chaînes, elles sont inchangées. En Java, les chaînes de caractères sont immuables.
En programmation, il est généralement souhaitable d‟avoir des valeurs immuables, car
elles permettent d‟éviter de nombreuses erreurs. Pour rendre les valeurs de nos
enregistrements immuables, nous devons demander au compilateur d‟empêcher la
modification des variables membres. En Java, nous pouvons faire cela avec le modificateur
final. Lorsqu‟une variable membre est déclarée avec le modificateur final, il n‟est possible de
lui affecter une valeur que dans un constructeur. Il n‟est donc plus possible de la modifier
après la création de l‟instance.
public class App {
"Ada Lovelace");
myAccount.uid = 2000; // Error !


}
}
public final int uid;
public final String userName;
public final String displayName;
public UserAccount(int uid, String userName, String displayName) {
this.uid = uid;
this.userName = userName;
this.displayName = displayName;
}
}
(- Encapsuler la création de l'instance, 3e essai (constructeur))
L‟utilisation d‟enregistrements immuables n‟empêche pas d‟effectuer des opérations,
mais ces opérations ne peuvent pas modifier les enregistrements auxquels elles sont
appliquées. Au lieu de cela, elles doivent créer une nouvelle instance du type enregistrement
avec de nouvelles valeurs. La figure 10 illustre la manière dont on peut réaliser une méthode
qui modifie le displayName d‟un compte d‟utilisateur avec des enregistrements immuables.
public class App {
"Ada Lovelace");
myAccount = changeDisplayName(myAccount, "Ada Byron,
Comtesse de Lovelace");
}
}

public static UserAccount changeDisplayName(UserAccount account,

String newDisplayName) {
return new UserAccount(account.uid, account.userName,
newDisplayName);
}
}
-( implémention d'une opération qui modifie le displayName.)
III- CHOIX APPROPRIE DES STRUCTURES DE DONNEES

Lorsqu‟il s‟agit de choisir des structures de données, il est important de prendre en
considération plusieurs facteurs, tels que les besoins fonctionnels, l‟optimisation des
performances et la facilité de maintenance du code. Le fait d‟utiliser une structure de données
appropriée à un traitement informatique peut également faire baisser de manière significative
la complexité d‟une application informatique et ainsi contribuer à diminuer le taux d‟erreurs.
A. Analyse Des Besoins Et Des Contraintes Des Besoins

Lorsqu'il s'agit de choisir les structures de données appropriées en Java, il est important de
bien comprendre les besoins spécifiques de votre application. Ci-dessous se trouve une
analyse approfondie des différents aspects à prendre en compte lors de la sélection des
structures de données.
1. Insertion, suppression et recherche
Il est important de considérer la fréquence et la complexité des opérations d'insertion, de

suppression et de recherche dans votre application. Certaines structures de données sont plus
performantes que d'autres pour certaines opérations. Par exemple, si vous devez effectuer
fréquemment des opérations d'insertion ou de suppression en milieu de liste, une LinkedList
peut être plus appropriée qu'une ArrayList.
2. Besoins de recherche

Choix Approprie Des Structures De Données
Il est important de déterminer si vous devez effectuer des recherches basées sur des clés
ou des valeurs. Si vous avez besoin de recherches rapides en fonction de clés uniques, une
structure de données basée sur une table de hachage telle que HashMap peut être plus
adaptée. Si vous avez besoin de recherches basées sur des plages de valeurs ou d'itérer sur les
éléments dans un ordre spécifique, une structure de données triée comme TreeMap peut être
plus appropriée.
3. Gestion des doublons
Si votre application nécessite l'élimination automatique des doublons, vous pouvez utiliser
des structures de données comme HashSet ou TreeSet, qui garantissent qu'aucun élément en
double ne sera stocké.
4. Taille de la collection
Considérez la taille estimée de la collection de données que vous devez stocker. Certaines
structures de données peuvent présenter des performances différentes en fonction de la taille
des données. Par exemple, l'insertion et la suppression d'éléments peuvent être coûteuses en
termes de performances dans une ArrayList lorsque la taille de la liste est très grande.
5. Complexité temporelle
Examinez la complexité temporelle des opérations de la structure de données. Par

exemple, ArrayList offre un accès aléatoire rapide en O(1), mais l'insertion et la suppression
d'éléments en milieu de liste ont une complexité O(n), où n est la taille de la liste. Comprenez
les compromis entre les opérations et choisissez une structure de données en fonction de vos
besoins spécifiques.
6. Complexité spatiale
Lors du choix de la structure de données, il faut tenir compte de la quantité de mémoire

requise par chaque structure de données. Certaines structures de données peuvent consommer
plus de mémoire que d'autres en raison de leur surcharge de stockage supplémentaire pour

maintenir des informations de structure. Assurez-vous que la structure de données choisie est
adaptée à vos contraintes de mémoire.
7. Besoins de synchronisation
Si votre application est multithreadée et nécessite une gestion de la concurrence, vous

devrez prendre en compte les aspects de synchronisation. Java fournit des versions
synchronisées de certaines structures de données, telles que Vector et Hashtable, qui peuvent
être utilisées lorsque vous avez besoin d'une synchronisation explicite.
B. Sélection De La Structure De Données A Adapter Aux

Besoins.
Selon le besoin spécifique, il est judicieux de faire une sélection de la structure de données
adapter à ce besoin. Différentes structures de données ont des forces et des faiblesses
différentes en termes par exemple de stockage, d‟accès, d‟insertion, de suppression ou encore
d‟opérations de recherche. Ainsi, selon le besoin spécifique, nous pouvons choisir :
1. Besoin de stockage d’un grand nombre d’éléments dans un ordre trié et effectuer des
recherches fréquentes
Si lors de la programmation d‟un programme, vous éprouvez le besoin de stocker un

grand nombre d‟éléments dans un ordre trié et effectuer des recherches fréquentes, vous
pouvez utiliser par exemple une arborescence ou une carte de hachage au lieu d’un
tableau ou d’une liste.
En effet, les opérations d'insertion et de suppression dans une arborescence peuvent être
plus efficaces que dans un tableau. Dans une arborescence, l'ajout ou la suppression d'un
élément ne nécessite généralement pas de déplacement massif des autres éléments. En
revanche, dans un tableau, l'insertion ou la suppression d'un élément peut nécessiter le
déplacement de tous les éléments suivants, ce qui peut être coûteux pour une grande quantité
de données.
2. Besoin de stockage d’un grand nombre d’éléments sans doublons et effectuer des
tests d’appartenance rapide
Pour un tel besoin, vous pouvez utiliser un ensemble au lieu d‟une liste car en termes
d‟élimination automatique des doublons, un ensemble garantit cette absence puisque, lorsque

vous insérez un élément dans un ensemble, il vérifie automatiquement si cet élément existe
déjà dans la collection. Cela évite d‟avoir à effectuer manuellement des vérifications de
doublons, ce qui peut être couteux en termes de performances, surtout lorsque vous travaillez
avec un grand nombre d‟éléments.
On peut aussi ajouter que les ensembles offrent une interface simple et intuitive pour
travailler avec des éléments uniques. Ils fournissent des méthodes claires pour ajouter,
supprimer et tester la présence d‟éléments sans doublons, ce qui facilite considérablement la
gestion de données.
3. Besoin de suppression ou d’ajout d’éléments
Si vous avez besoin d‟une liste dynamique qui permet l‟ajout et la suppression efficace
des éléments, il serait judicieux de choisir un ArrayList.
Si vous avez besoin d‟ajouter et de supprimer efficacement d‟éléments aux deux

extrémités d‟une file, il serait approprié d‟utiliser un ArrayDeque. Ceci est plus utile lorsque
vous avez besoin d‟une file d‟attente où vous devez ajouter et supprimer des éléments à la fois
à partir de l‟avant et de l‟arrière.
Pour un besoin d‟insertion fréquent et de suppression d‟éléments au milieu d‟une liste, il

est plus approprié de choisir une LinkeList car c‟est une liste doublement chainée où chaque
élément contient une référence vers l‟élément suivant et précédent.
4. Besoin d’une table de hachage basée sur le principe clé-valeur
Pour un besoin d‟une table de hachage basée sur le principe clé-valeur, il est approprié de
choisir un HashMap ou un TreeMap. Cependant, le HashMap, est plus approprié lorsque
vous devez associer des valeurs à des clés uniques et rechercher rapidement des valeurs en
fonction de leurs clés. Tandis que le TreeMap sera plus approprié lorsque vous avez besoin
d‟une table de hachage triée selon les clés.
C. Optimisation Des Performances En Utilisant Les Bonnes

Structures De Données.
L‟optimisation des performances d‟un programme Java en utilisant des structures de
données, consiste à sélectionner les structures de données les plus appropriées pour répondre

aux besoins fonctionnels du programme, tout en minimisant les coûts en termes de temps
d‟exécution et d‟utilisation de la mémoire.
Temps d'accès rapide : Le choix d'une structure de données appropriée peut réduire le
temps d'accès aux éléments. Par exemple, l'utilisation d'un tableau pour un accès
aléatoire rapide, ou d'un arbre de recherche binaire permettra de faire une recherche
efficace. Dès lors, l‟accès aux éléments devient plus rapide.
La complexité algorithmique : Les structures de données ont des performances
différentes en fonction des opérations effectuées. Par exemple, une liste chaînée peut être
plus efficace qu'un tableau pour des insertions fréquentes, tandis qu'un tableau trié peut
être plus rapide pour des recherches.
L’utilisation efficace de la mémoire : Certaines structures de données peuvent
consommer plus de mémoire que d'autres. En choisissant une structure de données
appropriée, vous pouvez minimiser l'utilisation de la mémoire et éviter les gaspillages
inutiles. Par exemple, vous pouvez utiliser le final mot-clé pour déclarer des constantes
qui ne changent pas, utilisez le bouton éphémère Mot-clé pour exclure les champs qui
n‟ont pas besoin d‟être sérialisés, utilisez le bouton faible ou mou les références pour
faire référence aux objets qui peuvent être ramassés et utiliser le System.gc() Méthode
pour demander l‟exécution du garbage collector.
Le parallélisme : Si votre programme peut bénéficier du traitement parallèle, certaines
structures de données, telles que les tableaux, peuvent offrir de meilleures performances
en permettant un accès simultané à différentes parties de la structure. Le parallélisme est
la capacité d‟effectuer plusieurs tâches ou opérations simultanément en utilisant plusieurs
processeurs ou cœurs. Le parallélisme peut améliorer les performances d‟un programme
en réduisant le temps d‟exécution global et en augmentant le débit. En Java, vous pouvez
utiliser diverses fonctionnalités et bibliothèques pour implémenter le parallélisme, telles
que les threads, les exécuteurs, les futures, les appelables, les exécutables, les
synchroniseurs, les verrous, les variables atomiques et les flux. Par exemple, vous
pouvez utiliser le parallelStream() Méthode permettant de créer un flux parallèle à partir
d‟une collection et d‟effectuer des opérations parallèles sur les éléments, telles que le filtrage,
le mappage, la réduction et la collecte. L‟exploitation du parallélisme peut augmenter
l‟efficacité et l‟évolutivité de votre programme et améliorer ses performances.

Cas Pratique : Utilisation Des Piles
L’évolutivité : Si votre programme doit gérer une grande quantité de données ou une
évolution future, choisir alors une structure de données qui s'échelonne bien avec la taille
des données peut améliorer les performances globales.
Il est important de noter que l'optimisation des performances ne consiste pas seulement
à choisir les structures de données les plus performantes, mais aussi à comprendre les
caractéristiques de votre programme, les patrons d'utilisation des données et à effectuer
des tests et des mesures pour évaluer les performances réelles.
IV- CAS PRATIQUES : Utilisation Des Piles

Confer le fichier java envoyé dans le groupe de la classe : ce fichier contient un code détaillé et
expliqué à l’aide de commentaires. Cependant, d’autres explications seront fournies pendant la
présentation.

Lexique
CONCLUSION
En résumé, l'essence des structures de données réside dans leur capacité à organiser et
à manipuler des données de manière efficace, ce qui contribue à améliorer la performance, la
fiabilité et la maintenabilité des systèmes informatiques. En outre, les structures de données
sont étroitement liées aux algorithmes, car ces derniers déterminent comment les opérations
sur les données sont effectuées. Une bonne compréhension des structures de données et des
algorithmes associés est essentielle pour concevoir des solutions efficaces et optimisées pour
divers problèmes informatiques.

Lexique
LEXIQUE
 Encapsulation: l‟encapsulation désigne le regroupement de données avec un

ensemble de routines qui en permettent la lecture et la manipulation.
 Filereader : permet à des applications web de lire le contenu de fichiers (ou de

tampons de mémoire brute) de façon asynchrone.
 Un accesseur : en Java est une méthode qui permet d‟accéder à la valeur d‟une
variable d‟instance privée d‟un objet depuis l‟extérieur de la classe.
 Instance : l'instance désigne une occurrence d'une classe
 Un Array : est une collection d‟un nombre fixe de types de données similaires.
 Un ArrayList : est une structure de données qui permet de stocker et de manipuler

une liste d‟éléments.
 Un doublon : fait référence à la présence répétée d‟un même élément dans une
collection telle qu‟une liste ou un tableau.
 Un HashSet : est une collection d‟objets où chaque élément est unique.
 Un TreeSet est une collection d‟objets où chaque élément est unique et trié selon un
ordre spécifié.
 Un LinkedHashSet : en Java est une structure de données qui combine les

caractéristiques d‟un HashSet et d‟une LinkedLis.
 Un hashMap : est une structure de données qui mappe les clés aux valeurs. On
l‟appelle également table de hachage, carte de hachage ou tableau associatif.
 Un tree map (ou treemap) :est une technique de visualisation de données qui
représente des relations de partie à tout dans une hiérarchie de catégories.
 Un LinkedHashMap :est une structure de données qui combine les caractéristiques

d‟un HashSet et d‟une LinkedList.
 Un InputStream : est une classe abstraite qui représente un flux d‟octets en entrée.
 Un OutputStream : en Java est une classe abstraite qui représente un flux d‟octets en
entrée.
 Un hashcode : en Java est un nombre entier généré par un algorithme de hachage.
 Une API, pour Application Programming Interface, est un programme permettant

à deux applications distinctes de communiquer entre elles et d‟échanger des données

Références Bibliographiques
REFERENCES BIBLIOGRAPHIQUES
 Ce document est inspiré grandement de la page web de SUN sur les collections, qui se trouve à
l’adresse :
http://developer.java.sun.com/developer/onlineTraining/collections/Collection.html 16h48 le
18/03/24
 Zukowski, John : "Java Collections". Éditeur : Apress. www.apress.com ; en réserve à la

bibliothèque de math/info. Le livre contient une description des collections en java. Attention
le livre contient peu d'exemples, c'est plutôt une description de point de vue technique des
collections.
 https://openclassrooms.com/fr/courses/6173501-apprenez-a-programmer-en-java/6458461-
gerez-les-piles-de-donnees-avec-la-bonne-collection à 17h22 le 17/03/24
 http://gallium.inria.fr/~maranget/X/421/poly/piles.html#sec31 à 21h35 le 18/03/24
 https://eddirasa.com/wp-content/uploads/univ/ESI/esi-cours_files_piles.pdf à 14h22 le
17/03/24
 Codegym.cc
 miahs www.u-ga.fr
 jmdoudoux.fr
 docplayer.fr
 www.epai-ict.ch>m22trecord-type

Exposé Java Groupe 3

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exposé Java Groupe 3

Transféré par

Droits d'auteur :

Formats disponibles

République du Cameroun Republic of Cameroon

INFORMATIQUE ET PROGRAMMATION GCU 332

Par les membres du groupe 3:

 BATCHANOU YANSE KIZIA (SOUS CHEF) 21P148

Sous la supervision de l’Ingénieur de Conception de Génie Civil et Chercheur à

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 2

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

 Au directeur de l‟École Nationale Supérieure Polytechnique de Yaoundé Pr.

 Au chef de département de la filière Génie civil de l‟École Nationale Supérieure

Polytechnique de Yaoundé Pr. MANDJIA MARCELLINE ;

 À notre enseignant Monsieur ENYEGUE GERMAIN, à qui nous exprimons

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 3

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

Les structures de données sont un concept de programmation très important. Elles

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 4

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

LISTE DES FIGURES

Figure 1: Interfaces En Java......................................................................................................... 41

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 6

LISTE DES IMAGES

Image 1 : Exemples D’utilisations Des Opérateurs De Transtypage ............................................. 26

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 7

LISTE DES TABLEAUX

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 8

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

TABLES DES MATIERES

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 9

III- CHOIX APPROPRIE DES STRUCTURES DE DONNEES ........................................................... 92

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 10

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 11

I- PRESENTATION DES STRUCTURES DE DONNEES

 Les structures de données primitives ( miahs www.u-ga.fr )

En informatique une structure de données primitive fait référence à un type de données de de

_ Booléen : C'est l'ensemble des valeurs true or false

Byte : (1 octet) entiers compris entre -128 et +127.

Short : (2 octet) entiers compris entre -32768 et +32767

Int : (4 octet) entiers compris entre -2147483648 et +2147483647

Long : (8 octet) entiers compris entre -9223372036854775808 et

_ Les types flottants :

 Les tableaux (codegym.cc)

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 12

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

 Les collections (jmdoudoux.fr)

 Les structures de données non linéaires (docplayer.fr)

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 13

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

Un graphe non orienté

 Structure de données en hachage

 Un objet particulier a un code de hachage particulier.

Le résultat de l'application de la fonction de hachage à un objet est appelé hashCode.

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 14

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

Les classes et les objets sont les composants fondamentaux de la Programmation

 Etat : Il est représenté par les attributs d‟un objet.

 Les flux et les fichiers

En Java, les flux peuvent être divisés en plusieurs catégories :

Les fichiers (Files) :

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 15

Génie Civil Et Urbanisme : Promotion 2026 Groupe D’exposé No 3

 Les enregistrements en Java

Par exemple, un compte d‟utilisateur peut être décrit par :

 Un identifiant numérique (uid) de type entier

2. Rôles des structures de données

Exposé Informatique Et Programmation GCU 332 Rédigé Et Présenté Par : 16