EISTI-ING1-GI
/
Java-2017-2018


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724
							<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="pandoc" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <title>Collections</title>
  <style type="text/css">
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
  </style>
  <style type="text/css">
a.sourceLine { display: inline-block; line-height: 1.25; }
a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
a.sourceLine:empty { height: 1.2em; position: absolute; }
.sourceCode { overflow: visible; }
code.sourceCode { white-space: pre; position: relative; }
div.sourceCode { margin: 1em 0; }
pre.sourceCode { margin: 0; }
@media screen {
div.sourceCode { overflow: auto; }
}
@media print {
code.sourceCode { white-space: pre-wrap; }
a.sourceLine { text-indent: -1em; padding-left: 1em; }
}
pre.numberSource a.sourceLine
  { position: relative; }
pre.numberSource a.sourceLine:empty
  { position: absolute; }
pre.numberSource a.sourceLine::before
  { content: attr(data-line-number);
    position: absolute; left: -5em; text-align: right; vertical-align: baseline;
    border: none; pointer-events: all;
    -webkit-touch-callout: none; -webkit-user-select: none;
    -khtml-user-select: none; -moz-user-select: none;
    -ms-user-select: none; user-select: none;
    padding: 0 4px; width: 4em;
    color: #aaaaaa;
  }
pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
div.sourceCode
  {  }
@media screen {
a.sourceLine::before { text-decoration: underline; }
}
code span.al { color: #ff0000; font-weight: bold; } /* Alert */
code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
code span.at { color: #7d9029; } /* Attribute */
code span.bn { color: #40a070; } /* BaseN */
code span.bu { } /* BuiltIn */
code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
code span.ch { color: #4070a0; } /* Char */
code span.cn { color: #880000; } /* Constant */
code span.co { color: #60a0b0; font-style: italic; } /* Comment */
code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
code span.do { color: #ba2121; font-style: italic; } /* Documentation */
code span.dt { color: #902000; } /* DataType */
code span.dv { color: #40a070; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #40a070; } /* Float */
code span.fu { color: #06287e; } /* Function */
code span.im { } /* Import */
code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
code span.kw { color: #007020; font-weight: bold; } /* Keyword */
code span.op { color: #666666; } /* Operator */
code span.ot { color: #007020; } /* Other */
code span.pp { color: #bc7a00; } /* Preprocessor */
code span.sc { color: #4070a0; } /* SpecialChar */
code span.ss { color: #bb6688; } /* SpecialString */
code span.st { color: #4070a0; } /* String */
code span.va { color: #19177c; } /* Variable */
code span.vs { color: #4070a0; } /* VerbatimString */
code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
  </style>
  <link rel="stylesheet" href="pandoc.css">
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="doctitle">Collections</div>
<nav id="TOC">
<ul>
<li><a href="#introduction">Introduction</a></li>
<li><a href="#les-list">Les “List”</a><ul>
<li><a href="#linterface-list">L’interface List</a></li>
<li><a href="#propriétés">Propriétés</a><ul>
<li><a href="#taille-de-la-liste">Taille de la liste</a></li>
<li><a href="#ordre-des-éléments">Ordre des éléments</a></li>
<li><a href="#doublons">Doublons</a></li>
</ul></li>
<li><a href="#méthodes-principales">Méthodes principales</a><ul>
<li><a href="#taille-de-la-liste-1">Taille de la liste</a></li>
<li><a href="#accès-aux-éléments">Accès aux éléments</a></li>
<li><a href="#ajout-et-suppression-déléments">Ajout et suppression d’éléments</a></li>
<li><a href="#typage-des-objets-contenu">Typage des objets contenu</a></li>
<li><a href="#création">Création</a></li>
</ul></li>
</ul></li>
<li><a href="#typage-des-objets-et-généricité">Typage des objets et généricité</a><ul>
<li><a href="#avant-les-generics">Avant les Generics</a><ul>
<li><a href="#avant-java-5.0-tiger">Avant Java 5.0 (Tiger)</a></li>
<li><a href="#transtypage-nécessaire">Transtypage nécessaire</a></li>
</ul></li>
<li><a href="#avec-les-generics">Avec les Generics</a><ul>
<li><a href="#association-du-type-à-la-liste">Association du type à la liste</a></li>
<li><a href="#diamond-operator">Diamond operator</a></li>
<li><a href="#avant-java-7">Avant Java 7</a></li>
<li><a href="#exemple-dutilisation">Exemple d’utilisation</a></li>
</ul></li>
</ul></li>
<li><a href="#autoboxing-unboxing">Autoboxing / unboxing</a><ul>
<li><a href="#stockage-des-types-primitifs">Stockage des types primitifs</a><ul>
<li><a href="#exemple">Exemple</a></li>
<li><a href="#un-type-une-contenant">Un type = une contenant</a></li>
</ul></li>
</ul></li>
<li><a href="#boucles-for-et-for-each">Boucles for(;;) et for-each</a><ul>
<li><a href="#deux-formes-ditérations">Deux formes d’itérations</a></li>
<li><a href="#interface-list-et-classes-associées">Interface List et classes associées</a></li>
</ul></li>
<li><a href="#exercices">Exercices</a><ul>
<li><a href="#parcours-de-liste">Parcours de liste</a></li>
</ul></li>
<li><a href="#vue-densemble-des-collections">Vue d’ensemble des Collections</a><ul>
<li><a href="#les-classes-collection">Les classes Collection</a></li>
<li><a href="#set">Set</a><ul>
<li><a href="#définition">Définition</a></li>
<li><a href="#exemple-1">Exemple</a></li>
<li><a href="#sous-types">Sous-types</a></li>
</ul></li>
<li><a href="#queue">Queue</a><ul>
<li><a href="#usage">Usage</a></li>
<li><a href="#méthodes">Méthodes</a></li>
<li><a href="#exemple-2">Exemple</a></li>
</ul></li>
</ul></li>
<li><a href="#linterface-map-et-ses-sous-classes">L’interface Map et ses sous-classes</a><ul>
<li><a href="#association-clef-valeur">Association clef-valeur</a></li>
<li><a href="#types-des-clefs-et-des-valeurs">Types des clefs et des valeurs</a></li>
<li><a href="#exemple-3">Exemple</a></li>
<li><a href="#classes-de-type-map">Classes de type Map</a></li>
</ul></li>
<li><a href="#parcours">Parcours</a><ul>
<li><a href="#interface-iterator">Interface Iterator</a></li>
<li><a href="#cas-particulier-map">Cas particulier: Map</a></li>
<li><a href="#iterator">Iterator</a><ul>
<li><a href="#exemple-de-parcours">Exemple de parcours</a></li>
<li><a href="#parcours-avec-for-et-for-each">Parcours avec for et for-each</a></li>
</ul></li>
</ul></li>
<li><a href="#application">Application</a><ul>
<li><a href="#list-création-de-listes-de-véhicules">List : création de listes de véhicules</a></li>
<li><a href="#list-affichage-dune-liste-de-véhicules">List: affichage d’une liste de véhicules</a></li>
<li><a href="#queue-et-set">(Queue et Set)</a></li>
<li><a href="#map-référencement-de-véhicule">Map : référencement de véhicule</a></li>
<li><a href="#iterator-application">Iterator: application</a></li>
</ul></li>
</ul>
</nav>
<h1 id="introduction">Introduction</h1>
<p>Les collections en Java permettent de gérer des <strong>ensembles</strong> d’objets.</p>
<p>Java propose par défaut une bibliothèque de classes permettant de couvrir l’essentiel des besoins d’un programmeur pour gérer des <strong>ensembles</strong>.</p>
<p>Pour commencer, nous allons étudier la gestion de liste d’objets (<code>List</code>/<code>ArrayList</code>), mais nous verrons plus tard qu’il est possible d’utiliser d’autres types d’ensemble.</p>
<p>Nous allons également découvrir l’utilité des Generics dans l’usage des collections, ainsi que l’Autoboxing/Unboxing.</p>
<h1 id="les-list">Les “List”</h1>
<h2 id="linterface-list">L’interface List</h2>
<p>Un premier type de collection très utilisé est <code>List</code>.</p>
<p>Il permet de traiter un ensemble d’objets sous la forme de liste.</p>
<h2 id="propriétés">Propriétés</h2>
<h3 id="taille-de-la-liste">Taille de la liste</h3>
<ul>
<li>C’est le nombre d’éléments qu’elle contient.</li>
<li>Elle peut être vide</li>
</ul>
<h3 id="ordre-des-éléments">Ordre des éléments</h3>
<p>Une liste est ordonnée.</p>
<h3 id="doublons">Doublons</h3>
<p>Le nombre d’objets distinct peut être différent du nombre d’enregistrement.</p>
<ul>
<li>Autrement dit, elle peut contenir des doublons.</li>
</ul>
<h2 id="méthodes-principales">Méthodes principales</h2>
<p><code>java.util.List</code> est une interface qui propose les fonctions suivantes (non exhaustif).</p>
<h3 id="taille-de-la-liste-1">Taille de la liste</h3>
<ul>
<li><code>public int size()</code> : détermine le nombre d’éléments dans la liste (et donc l’index maximal auquel on peut accéder)</li>
</ul>
<h3 id="accès-aux-éléments">Accès aux éléments</h3>
<ul>
<li><code>public E get(int index)</code> : récupère l’élément positionné à l’index donné en paramètre</li>
<li><code>public boolean contains(Object o)</code>: indique si oui ou non l’objet passé en paramètre est contenu dans la liste.</li>
<li><code>public int indexOf(Object o)</code> : indique l’index où se positionne l’objet passé en paramètre dans la liste.</li>
</ul>
<h3 id="ajout-et-suppression-déléments">Ajout et suppression d’éléments</h3>
<ul>
<li><code>public void add(E e)</code> : ajoute un élément de type <code>E</code> dans la liste</li>
<li><code>public E remove(int index)</code> : supprime un élément de type <code>E</code> dans la liste et renvoie cet élément</li>
<li><code>public boolean remove(Object o)</code> : supprime la première occurrence trouvé de l’élément passé en paramètre de la liste</li>
</ul>
<h3 id="typage-des-objets-contenu">Typage des objets contenu</h3>
<p>Vous aurez remarqué le type de retour de <code>get(int)</code>. <code>E</code> est le type d’objet contenu par la liste. Nous allons voir à quoi cela correspond dans le paragraphe suivant.</p>
<h3 id="création">Création</h3>
<p>L’interface <code>List</code> ne peut être instanciée directement.</p>
<p><code>java.util.ArrayList</code> est une classe (concrète) qui implémente cette interface et qui peut être instanciée.</p>
<h1 id="typage-des-objets-et-généricité">Typage des objets et généricité</h1>
<p>Une <code>List</code>, par essence, permet de stocker n’importe quel objet. Ce sont donc des instances d’<code>Object</code> qui sont stockés dans une liste.</p>
<p>Il serait peu pratique de devoir spécifier à chaque appel des méthodes <code>get(int)</code>, <code>remove(int)</code> le type de l’objet retourné.</p>
<h2 id="avant-les-generics">Avant les Generics</h2>
<h3 id="avant-java-5.0-tiger">Avant Java 5.0 (Tiger)</h3>
<p>Dans les version antérieures à la version 1.5 (ou 5.0) de Java, il était nécessaire d’écrire ceci:</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb1-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> AvantLesGenerics{</a>
<a class="sourceLine" id="cb1-2" data-line-number="2">  <span class="bu">List</span> list = <span class="kw">new</span> <span class="bu">ArrayList</span>();</a>
<a class="sourceLine" id="cb1-3" data-line-number="3">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">init</span>(){</a>
<a class="sourceLine" id="cb1-4" data-line-number="4">    <span class="bu">Date</span> date = <span class="kw">new</span> <span class="bu">Date</span>(<span class="dv">11</span>, <span class="dv">12</span>, <span class="dv">2013</span>);</a>
<a class="sourceLine" id="cb1-5" data-line-number="5">    list.<span class="fu">add</span>(date);</a>
<a class="sourceLine" id="cb1-6" data-line-number="6">  }</a>
<a class="sourceLine" id="cb1-7" data-line-number="7"></a>
<a class="sourceLine" id="cb1-8" data-line-number="8">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testSiPremiereDateValide</span>(){</a>
<a class="sourceLine" id="cb1-9" data-line-number="9">    <span class="bu">Date</span> d = (<span class="bu">Date</span>)list.<span class="fu">get</span>(<span class="dv">0</span>); <span class="co">//Transtypage indispensable</span></a>
<a class="sourceLine" id="cb1-10" data-line-number="10">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(d.<span class="fu">estValide</span>());</a>
<a class="sourceLine" id="cb1-11" data-line-number="11">  }</a>
<a class="sourceLine" id="cb1-12" data-line-number="12">}</a></code></pre></div>
<h3 id="transtypage-nécessaire">Transtypage nécessaire</h3>
<p>En l’absence de transtypage, le compilateur indiquait une erreur, car la classe par défaut de <code>List</code> est <code>Object</code> et non <code>Date</code>.</p>
<p>Ce type de programmation était lourd. En effet, à la place de :</p>
<div class="sourceCode" id="cb2"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb2-1" data-line-number="1"><span class="bu">Date</span> d = (<span class="bu">Date</span>)list.<span class="fu">get</span>(<span class="dv">0</span>); <span class="co">//Transtypage indispensable</span></a></code></pre></div>
<p>il serait plus simple d’écrire:</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb3-1" data-line-number="1"><span class="bu">Date</span> d = list.<span class="fu">get</span>(<span class="dv">0</span>); <span class="co">//Utilisation directe de la méthode</span></a></code></pre></div>
<p>Ceci est possible depuis la version 1.5 de Java :</p>
<ul>
<li>grâce aux <code>Generics</code></li>
</ul>
<h2 id="avec-les-generics">Avec les Generics</h2>
<h3 id="association-du-type-à-la-liste">Association du type à la liste</h3>
<p>Juste après la déclaration du type (<code>List</code>), il est possible d’indiquer le type d’objet qu’elle contient.</p>
<p>Pour cela, il suffit de noter le type entre chevrons <code>&lt;</code> et <code>&gt;</code> :</p>
<p>Cette déclaration indique que la liste contiendra des objets de type <code>Date</code>.</p>
<p><code>List &lt;Date&gt;</code>.</p>
<h3 id="diamond-operator">Diamond operator</h3>
<p>Une fois le type déclaré pour l’interface <code>List</code>, il n’est pas utile de le rappeler lors de l’instanciation.</p>
<div class="sourceCode" id="cb4"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb4-1" data-line-number="1"><span class="bu">List</span>&lt;<span class="bu">Date</span>&gt; list = <span class="kw">new</span> <span class="bu">ArrayList</span>&lt;&gt;();</a></code></pre></div>
<p>Vous noterez que <code>ArrayList</code> est suivi d’un <em>diamant</em> (<em>diamond operator</em>): deux chevrons accolés <code>&lt;&gt;</code>.</p>
<p>Ceci permet au compilateur de savoir que le type générique correspondra à celui de la variable telle que déclarée précédemment</p>
<h3 id="avant-java-7">Avant Java 7</h3>
<p>Il était obligatoire d’écrire explicitement le type lors de l’appel au constructeur avant la version Java SE 7:</p>
<p>la version du code qui compilait dans ce cas était:</p>
<p><code>List&lt;Date&gt; list = new ArrayList&lt;Date&gt;();</code></p>
<p>Ce n’est plus nécessaire depuis la version 7.0.</p>
<h3 id="exemple-dutilisation">Exemple d’utilisation</h3>
<div class="sourceCode" id="cb5"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb5-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> AvecLesGenerics{</a>
<a class="sourceLine" id="cb5-2" data-line-number="2">  <span class="bu">List</span>&lt;<span class="bu">Date</span>&gt; list = <span class="kw">new</span> <span class="bu">ArrayList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb5-3" data-line-number="3">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">init</span>(){</a>
<a class="sourceLine" id="cb5-4" data-line-number="4">    <span class="bu">Date</span> date = <span class="kw">new</span> <span class="bu">Date</span>(<span class="dv">11</span>,<span class="dv">12</span>,<span class="dv">2013</span>);</a>
<a class="sourceLine" id="cb5-5" data-line-number="5">    list.<span class="fu">add</span>(date);</a>
<a class="sourceLine" id="cb5-6" data-line-number="6">  }</a>
<a class="sourceLine" id="cb5-7" data-line-number="7"></a>
<a class="sourceLine" id="cb5-8" data-line-number="8">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testSiPremiereDateValide</span>(){</a>
<a class="sourceLine" id="cb5-9" data-line-number="9">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(list.<span class="fu">get</span>(<span class="dv">0</span>).<span class="fu">estValide</span>());</a>
<a class="sourceLine" id="cb5-10" data-line-number="10">  }</a>
<a class="sourceLine" id="cb5-11" data-line-number="11">}</a></code></pre></div>
<p>Nous disposons donc d’un outil puissant et versatile pour stocker des listes d’objets.</p>
<p>Cette notion de <code>Generics</code> reste à approfondir mais ce que nous venons de voir va nous suffire dans un premier temps.</p>
<h1 id="autoboxing-unboxing">Autoboxing / unboxing</h1>
<h2 id="stockage-des-types-primitifs">Stockage des types primitifs</h2>
<h3 id="exemple">Exemple</h3>
<p>L’intérêt des collections est qu’elles permettent également de gérer des types primitifs.</p>
<p>En effet, même si ces types ne sont pas des instances, ils vont pouvoir être encapsulés dans des objets.</p>
<p>Ainsi, on aura la possibilité de stocker un <code>int</code> dans un objet de type <code>Integer</code>.</p>
<p>Observez bien le code suivant:</p>
<div class="sourceCode" id="cb6"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb6-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> IntBoxing {</a>
<a class="sourceLine" id="cb6-2" data-line-number="2">    <span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; listeInt = <span class="kw">new</span> <span class="bu">ArrayList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb6-3" data-line-number="3">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">init</span>(){</a>
<a class="sourceLine" id="cb6-4" data-line-number="4">        <span class="dt">int</span> monNombrePrimitif = <span class="dv">24</span>;</a>
<a class="sourceLine" id="cb6-5" data-line-number="5">        listeInt.<span class="fu">add</span>(monNombrePrimitif);</a>
<a class="sourceLine" id="cb6-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb6-7" data-line-number="7"></a>
<a class="sourceLine" id="cb6-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">faire</span>(){</a>
<a class="sourceLine" id="cb6-9" data-line-number="9">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(listeInt.<span class="fu">get</span>(<span class="dv">0</span>) + <span class="dv">12</span>);</a>
<a class="sourceLine" id="cb6-10" data-line-number="10">    }</a>
<a class="sourceLine" id="cb6-11" data-line-number="11">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb6-12" data-line-number="12">        IntBoxing ib = <span class="kw">new</span> <span class="fu">IntBoxing</span>();</a>
<a class="sourceLine" id="cb6-13" data-line-number="13">        ib.<span class="fu">init</span>();</a>
<a class="sourceLine" id="cb6-14" data-line-number="14">        ib.<span class="fu">faire</span>();</a>
<a class="sourceLine" id="cb6-15" data-line-number="15">    }</a>
<a class="sourceLine" id="cb6-16" data-line-number="16">}</a></code></pre></div>
<p>Il est parfaitement fonctionnel.</p>
<h3 id="un-type-une-contenant">Un type = une contenant</h3>
<p>Il vous est possible d’utiliser les collections pour stocker les types primitifs suivants en utilisant les <em>réceptacles</em> associés :</p>
<table>
<thead>
<tr class="header">
<th> Type primitif</th>
<th>Classe réceptacle</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>boolean</td>
<td>Boolean </td>
</tr>
<tr class="even">
<td>byte</td>
<td>Byte  </td>
</tr>
<tr class="odd">
<td>char</td>
<td>Character</td>
</tr>
<tr class="even">
<td>float</td>
<td>Float</td>
</tr>
<tr class="odd">
<td>int</td>
<td>Integer</td>
</tr>
<tr class="even">
<td>long</td>
<td>Long</td>
</tr>
<tr class="odd">
<td>short</td>
<td>Short</td>
</tr>
<tr class="even">
<td>double</td>
<td>Double</td>
</tr>
</tbody>
</table>
<p>Ces réceptacles sont des objets <em>boîtes</em> (box) dans lesquelles sont stockées les valeurs primitives afin qu’elles soient prises en charge par les collections comme des objets.</p>
<h1 id="boucles-for-et-for-each">Boucles for(;;) et for-each</h1>
<h2 id="deux-formes-ditérations">Deux formes d’itérations</h2>
<p>Il est possible de parcourir une liste de deux manières avec une boucle <code>for</code>:</p>
<ul>
<li>la construction classique : <code>for(int i = 0 ; i &lt; l.size() ; i++)</code></li>
<li>la construction <em>for-each</em> : <code>for (Date date : listeDate)</code></li>
</ul>
<h2 id="interface-list-et-classes-associées">Interface List et classes associées</h2>
<p>Nous avons utilisé l’interface <code>List</code> avec la classe <code>ArrayList</code>. Mais il est possible de l’interchanger avec une autre classe sans effet sur le reste du code.</p>
<p>Par exemple avec la classe <code>LinkedList</code>:</p>
<div class="sourceCode" id="cb7"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb7-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> IntBoxing {</a>
<a class="sourceLine" id="cb7-2" data-line-number="2">    <span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; listeInt = <span class="kw">new</span> <span class="bu">LinkedList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb7-3" data-line-number="3">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">init</span>(){</a>
<a class="sourceLine" id="cb7-4" data-line-number="4">        <span class="dt">int</span> monNombrePrimitif = <span class="dv">24</span>;</a>
<a class="sourceLine" id="cb7-5" data-line-number="5">        listeInt.<span class="fu">add</span>(monNombrePrimitif);</a>
<a class="sourceLine" id="cb7-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb7-7" data-line-number="7">  <span class="co">//... (le reste du code est identique à l&#39;exemple précédent</span></a>
<a class="sourceLine" id="cb7-8" data-line-number="8">}</a></code></pre></div>
<p>La classe <code>LinkedList</code> est une liste chaînée. Selon le cas, son mode de fonctionnement sera plus performant que si on utilise une <code>ArrayList</code>.</p>
<p>Vous pouvez tester cela avec le code suivant:</p>
<div class="sourceCode" id="cb8"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb8-1" data-line-number="1"><span class="kw">import</span><span class="im"> java.util.ArrayList;</span></a>
<a class="sourceLine" id="cb8-2" data-line-number="2"><span class="kw">import</span><span class="im"> java.util.LinkedList;</span></a>
<a class="sourceLine" id="cb8-3" data-line-number="3"><span class="kw">import</span><span class="im"> java.util.List;</span></a>
<a class="sourceLine" id="cb8-4" data-line-number="4"></a>
<a class="sourceLine" id="cb8-5" data-line-number="5"><span class="kw">public</span> <span class="kw">class</span> PerformancesList {</a>
<a class="sourceLine" id="cb8-6" data-line-number="6"></a>
<a class="sourceLine" id="cb8-7" data-line-number="7">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">final</span> <span class="dt">int</span> MAX_VALUE = <span class="dv">100000</span>;</a>
<a class="sourceLine" id="cb8-8" data-line-number="8"></a>
<a class="sourceLine" id="cb8-9" data-line-number="9">    <span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; arrayList = <span class="kw">new</span> <span class="bu">ArrayList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb8-10" data-line-number="10">    <span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; linkedList = <span class="kw">new</span> <span class="bu">LinkedList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb8-11" data-line-number="11"></a>
<a class="sourceLine" id="cb8-12" data-line-number="12">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">insert</span>(<span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; liste, <span class="dt">int</span> maxValue) {</a>
<a class="sourceLine" id="cb8-13" data-line-number="13">        <span class="kw">for</span> (<span class="dt">int</span> i = <span class="dv">0</span>; i &lt; maxValue; i++) {</a>
<a class="sourceLine" id="cb8-14" data-line-number="14">            liste.<span class="fu">add</span>(<span class="dv">0</span>, i);</a>
<a class="sourceLine" id="cb8-15" data-line-number="15">        }</a>
<a class="sourceLine" id="cb8-16" data-line-number="16">    }</a>
<a class="sourceLine" id="cb8-17" data-line-number="17"></a>
<a class="sourceLine" id="cb8-18" data-line-number="18">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">parcours</span>(<span class="bu">List</span>&lt;<span class="bu">Integer</span>&gt; liste, <span class="dt">int</span> maxValue) {</a>
<a class="sourceLine" id="cb8-19" data-line-number="19">        <span class="kw">for</span> (<span class="dt">int</span> i = <span class="dv">0</span>; i &lt; maxValue; i++) {</a>
<a class="sourceLine" id="cb8-20" data-line-number="20">            <span class="bu">Integer</span> integer = liste.<span class="fu">get</span>(i);</a>
<a class="sourceLine" id="cb8-21" data-line-number="21">        }</a>
<a class="sourceLine" id="cb8-22" data-line-number="22">    }</a>
<a class="sourceLine" id="cb8-23" data-line-number="23"></a>
<a class="sourceLine" id="cb8-24" data-line-number="24">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb8-25" data-line-number="25">        PerformancesList pl = <span class="kw">new</span> <span class="fu">PerformancesList</span>();</a>
<a class="sourceLine" id="cb8-26" data-line-number="26">        pl.<span class="fu">insert</span>(pl.<span class="fu">arrayList</span>, <span class="dv">10</span>);</a>
<a class="sourceLine" id="cb8-27" data-line-number="27">        pl.<span class="fu">insert</span>(pl.<span class="fu">linkedList</span>, <span class="dv">10</span>);</a>
<a class="sourceLine" id="cb8-28" data-line-number="28"></a>
<a class="sourceLine" id="cb8-29" data-line-number="29">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Insertion&quot;</span>);</a>
<a class="sourceLine" id="cb8-30" data-line-number="30">        <span class="dt">long</span> debutOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-31" data-line-number="31">        pl.<span class="fu">insert</span>(pl.<span class="fu">linkedList</span>, MAX_VALUE);</a>
<a class="sourceLine" id="cb8-32" data-line-number="32">        <span class="dt">long</span> finOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-33" data-line-number="33">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Linked :&quot;</span> + (finOp - debutOp) / <span class="dv">1000000</span> + <span class="st">&quot;ms&quot;</span>);</a>
<a class="sourceLine" id="cb8-34" data-line-number="34"></a>
<a class="sourceLine" id="cb8-35" data-line-number="35">        debutOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-36" data-line-number="36">        pl.<span class="fu">insert</span>(pl.<span class="fu">arrayList</span>, MAX_VALUE);</a>
<a class="sourceLine" id="cb8-37" data-line-number="37">        finOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-38" data-line-number="38">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Array :&quot;</span> + (finOp - debutOp) / <span class="dv">1000000</span> + <span class="st">&quot;ms&quot;</span>);</a>
<a class="sourceLine" id="cb8-39" data-line-number="39"></a>
<a class="sourceLine" id="cb8-40" data-line-number="40">        pl.<span class="fu">parcours</span>(pl.<span class="fu">arrayList</span>, <span class="dv">10</span>);</a>
<a class="sourceLine" id="cb8-41" data-line-number="41">        pl.<span class="fu">parcours</span>(pl.<span class="fu">linkedList</span>, <span class="dv">10</span>);</a>
<a class="sourceLine" id="cb8-42" data-line-number="42"></a>
<a class="sourceLine" id="cb8-43" data-line-number="43">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Parcours&quot;</span>);</a>
<a class="sourceLine" id="cb8-44" data-line-number="44">        debutOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-45" data-line-number="45">        pl.<span class="fu">parcours</span>(pl.<span class="fu">linkedList</span>, MAX_VALUE);</a>
<a class="sourceLine" id="cb8-46" data-line-number="46">        finOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-47" data-line-number="47">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Linked :&quot;</span> + (finOp - debutOp) / <span class="dv">1000000</span> + <span class="st">&quot;ms&quot;</span>);</a>
<a class="sourceLine" id="cb8-48" data-line-number="48"></a>
<a class="sourceLine" id="cb8-49" data-line-number="49">        debutOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-50" data-line-number="50">        pl.<span class="fu">parcours</span>(pl.<span class="fu">arrayList</span>, MAX_VALUE);</a>
<a class="sourceLine" id="cb8-51" data-line-number="51">        finOp = <span class="bu">System</span>.<span class="fu">nanoTime</span>();</a>
<a class="sourceLine" id="cb8-52" data-line-number="52">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Array :&quot;</span> + (finOp - debutOp) / <span class="dv">1000000</span> + <span class="st">&quot;ms&quot;</span>);</a>
<a class="sourceLine" id="cb8-53" data-line-number="53"></a>
<a class="sourceLine" id="cb8-54" data-line-number="54">    }</a>
<a class="sourceLine" id="cb8-55" data-line-number="55">}</a></code></pre></div>
<p>Que constatez-vous à l’exécution de ce code ?</p>
<h1 id="exercices">Exercices</h1>
<h2 id="parcours-de-liste">Parcours de liste</h2>
<p>Remplissez une liste avec des entiers numérotés de 1 à 10.</p>
<p>Utilisez les deux types de boucle <code>for</code> pour parcourir une <code>List</code> d’entiers (de 1 à 20).</p>
<h1 id="vue-densemble-des-collections">Vue d’ensemble des Collections</h1>
<h2 id="les-classes-collection">Les classes Collection</h2>
<p>Le diagramme suivant donne une vision globale des Collections en Java</p>
<figure>
<img src="images/Collection-Map.png" alt="Collections" /><figcaption>Collections</figcaption>
</figure>
<p>On s’aperçoit que <code>List</code> est un sous-type de <code>Collection</code>, tout comme <code>Set</code> ou <code>Queue</code>.</p>
<p>Nous allons ici nous intéresser sur certaines fonctionnalités de base de ces classes <code>Set</code> et <code>Queue</code>.</p>
<p>Vous pouvez trouver une documentation plus complète sur les collections <a href="https://en.wikibooks.org/wiki/Java_Programming/Collection">ici</a></p>
<h2 id="set">Set</h2>
<h3 id="définition">Définition</h3>
<p>L’interface <code>Set</code> permet de contenir un ensemble d’objets. Cet ensemble ne contient pas de doublon (un objet y est stocké une et une seule fois).</p>
<ul>
<li>Selon son contrat, toute classe qui implémente l’interface <code>Set</code> se base sur la méthode <code>equals</code> pour s’assurer qu’aucun doublon n’est inséré dans la collection.</li>
<li>Ainsi, l’ajout d’un élément déjà présent dans le <code>Set</code> n’aura aucun effet.</li>
<li>De même l’ajout d’un élément dont la méthode <code>equals</code> renvoie <code>true</code> pour un des éléments du <code>Set</code>, n’entraînera pas sa présence en doublon.</li>
</ul>
<h3 id="exemple-1">Exemple</h3>
<div class="sourceCode" id="cb9"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb9-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.collections;</span></a>
<a class="sourceLine" id="cb9-2" data-line-number="2"></a>
<a class="sourceLine" id="cb9-3" data-line-number="3"><span class="kw">import</span><span class="im"> java.util.Set;</span></a>
<a class="sourceLine" id="cb9-4" data-line-number="4"><span class="kw">import</span><span class="im"> java.util.TreeSet;</span></a>
<a class="sourceLine" id="cb9-5" data-line-number="5"></a>
<a class="sourceLine" id="cb9-6" data-line-number="6"><span class="kw">public</span> <span class="kw">class</span> ExempleSet {</a>
<a class="sourceLine" id="cb9-7" data-line-number="7">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb9-8" data-line-number="8">        <span class="bu">Set</span>&lt;<span class="bu">Integer</span>&gt; entiers = <span class="kw">new</span> <span class="bu">TreeSet</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb9-9" data-line-number="9">        entiers.<span class="fu">add</span>(<span class="dv">1</span>);</a>
<a class="sourceLine" id="cb9-10" data-line-number="10">        entiers.<span class="fu">add</span>(<span class="dv">2</span>);</a>
<a class="sourceLine" id="cb9-11" data-line-number="11">        entiers.<span class="fu">add</span>(<span class="dv">3</span>);</a>
<a class="sourceLine" id="cb9-12" data-line-number="12">        entiers.<span class="fu">add</span>(<span class="dv">2</span>);</a>
<a class="sourceLine" id="cb9-13" data-line-number="13">        entiers.<span class="fu">add</span>(<span class="dv">3</span>);</a>
<a class="sourceLine" id="cb9-14" data-line-number="14">        entiers.<span class="fu">add</span>(<span class="dv">4</span>);</a>
<a class="sourceLine" id="cb9-15" data-line-number="15">        entiers.<span class="fu">remove</span>(<span class="dv">3</span>);</a>
<a class="sourceLine" id="cb9-16" data-line-number="16">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(entiers);</a>
<a class="sourceLine" id="cb9-17" data-line-number="17">    }</a>
<a class="sourceLine" id="cb9-18" data-line-number="18">}</a></code></pre></div>
<h3 id="sous-types">Sous-types</h3>
<ul>
<li><code>TreeSet</code>
<ul>
<li>Un <code>Set</code> dont les éléments sont ordonnés</li>
<li><code>SortedSet</code></li>
</ul></li>
<li><code>HashSet</code>
<ul>
<li>Un <code>Set</code> dont les éléments ne sont pas ordonnés</li>
</ul></li>
</ul>
<h2 id="queue">Queue</h2>
<h3 id="usage">Usage</h3>
<p>Les sous-classes de l’interface <code>Queue</code> permettent de gérer des files d’attentes (de type FIFO ou LIFO).</p>
<h3 id="méthodes">Méthodes</h3>
<p>Deux façons d’utiliser un objet de type <code>Queue</code></p>
<table>
<thead>
<tr class="header">
<th>Type d’opération</th>
<th>Lance une exception</th>
<th>Renvoie une valeur spéciale</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>Insert</td>
<td>add(elem)</td>
<td>offer(elem) </td>
</tr>
<tr class="even">
<td>Remove</td>
<td>remove()</td>
<td>poll() </td>
</tr>
<tr class="odd">
<td>Examine</td>
<td>element()</td>
<td>peek() </td>
</tr>
</tbody>
</table>
<h3 id="exemple-2">Exemple</h3>
<div class="sourceCode" id="cb10"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb10-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.collections;</span></a>
<a class="sourceLine" id="cb10-2" data-line-number="2"></a>
<a class="sourceLine" id="cb10-3" data-line-number="3"><span class="kw">import</span><span class="im"> java.util.LinkedList;</span></a>
<a class="sourceLine" id="cb10-4" data-line-number="4"><span class="kw">import</span><span class="im"> java.util.Queue;</span></a>
<a class="sourceLine" id="cb10-5" data-line-number="5"></a>
<a class="sourceLine" id="cb10-6" data-line-number="6"><span class="kw">public</span> <span class="kw">class</span> ExempleQueue {</a>
<a class="sourceLine" id="cb10-7" data-line-number="7"></a>
<a class="sourceLine" id="cb10-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb10-9" data-line-number="9">        <span class="dt">int</span> nombreClients = <span class="dv">0</span> ;</a>
<a class="sourceLine" id="cb10-10" data-line-number="10">        <span class="bu">Queue</span>&lt;<span class="bu">String</span>&gt; queue = <span class="kw">new</span> <span class="bu">LinkedList</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb10-11" data-line-number="11"></a>
<a class="sourceLine" id="cb10-12" data-line-number="12">        <span class="kw">while</span> (nombreClients &lt; <span class="dv">10</span>){</a>
<a class="sourceLine" id="cb10-13" data-line-number="13">            queue.<span class="fu">add</span>(<span class="st">&quot;Client(&quot;</span>+nombreClients+<span class="st">&quot;)&quot;</span>);</a>
<a class="sourceLine" id="cb10-14" data-line-number="14">            nombreClients++;</a>
<a class="sourceLine" id="cb10-15" data-line-number="15">        }</a>
<a class="sourceLine" id="cb10-16" data-line-number="16"></a>
<a class="sourceLine" id="cb10-17" data-line-number="17">        <span class="kw">while</span> (!queue.<span class="fu">isEmpty</span>()) {</a>
<a class="sourceLine" id="cb10-18" data-line-number="18">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(queue.<span class="fu">remove</span>());</a>
<a class="sourceLine" id="cb10-19" data-line-number="19">        }</a>
<a class="sourceLine" id="cb10-20" data-line-number="20">    }</a>
<a class="sourceLine" id="cb10-21" data-line-number="21">}</a></code></pre></div>
<h1 id="linterface-map-et-ses-sous-classes">L’interface Map et ses sous-classes</h1>
<h2 id="association-clef-valeur">Association clef-valeur</h2>
<p>Une <code>Map</code> permet de stocker des éléments en les référençant via une clef d’accès.</p>
<p>C’est l’équivalent d’un dictionnaire. Pour trouver la définition d’un mot, on cherche le mot en question. Une fois trouvé, il est possible d’en lire la définition.</p>
<p>L’utilisation des <code>Map</code> permet de stocker et récupérer facilement une information, un pointeur ou un objet associé à un autre objet.</p>
<h2 id="types-des-clefs-et-des-valeurs">Types des clefs et des valeurs</h2>
<p>Une <code>Map</code> va associer</p>
<ul>
<li>une clef
<ul>
<li>instance d’un objet ayant un certain type (par exemple <code>Date</code>)</li>
</ul></li>
<li>avec une valeur
<ul>
<li>instance d’un objet d’un autre type : par exemple <code>Personne</code></li>
</ul></li>
<li>Utilisation des Generics
<ul>
<li><code>Map &lt;Date, Personne&gt; personneParAnniversaire</code></li>
</ul></li>
<li>On peut ainsi retrouver une personne à partir de sa date d’anniversaire.</li>
</ul>
<h2 id="exemple-3">Exemple</h2>
<div class="sourceCode" id="cb11"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb11-1" data-line-number="1"><span class="kw">import</span><span class="im"> java.util.Map;</span></a>
<a class="sourceLine" id="cb11-2" data-line-number="2"><span class="kw">import</span><span class="im"> java.util.HashMap;</span></a>
<a class="sourceLine" id="cb11-3" data-line-number="3"></a>
<a class="sourceLine" id="cb11-4" data-line-number="4"><span class="kw">public</span> <span class="kw">class</span> Anniversaire {</a>
<a class="sourceLine" id="cb11-5" data-line-number="5">    <span class="kw">private</span> <span class="bu">Map</span>&lt;<span class="bu">String</span>, Personne&gt; anniv = <span class="kw">new</span> <span class="bu">HashMap</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb11-6" data-line-number="6">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">init</span>(){</a>
<a class="sourceLine" id="cb11-7" data-line-number="7">        anniv.<span class="fu">put</span>(<span class="st">&quot;19/05/1955&quot;</span>, <span class="kw">new</span> <span class="fu">Personne</span>(<span class="st">&quot;Gosling&quot;</span>, <span class="st">&quot;James&quot;</span>));</a>
<a class="sourceLine" id="cb11-8" data-line-number="8">        anniv.<span class="fu">put</span>(<span class="st">&quot;09/09/1941&quot;</span>, <span class="kw">new</span> <span class="fu">Personne</span>(<span class="st">&quot;Ritchie&quot;</span>, <span class="st">&quot;Dennis&quot;</span>));</a>
<a class="sourceLine" id="cb11-9" data-line-number="9">        anniv.<span class="fu">put</span>(<span class="st">&quot;04/02/1943&quot;</span>, <span class="kw">new</span> <span class="fu">Personne</span>(<span class="st">&quot;Thompson&quot;</span>, <span class="st">&quot;Ken&quot;</span>));</a>
<a class="sourceLine" id="cb11-10" data-line-number="10">    }</a>
<a class="sourceLine" id="cb11-11" data-line-number="11"></a>
<a class="sourceLine" id="cb11-12" data-line-number="12">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">affichePrenom</span>(<span class="bu">String</span> date){</a>
<a class="sourceLine" id="cb11-13" data-line-number="13">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(anniv.<span class="fu">get</span>(date).<span class="fu">prenom</span>);</a>
<a class="sourceLine" id="cb11-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb11-15" data-line-number="15"></a>
<a class="sourceLine" id="cb11-16" data-line-number="16">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb11-17" data-line-number="17">        Anniversaire a = <span class="kw">new</span> <span class="fu">Anniversaire</span>();</a>
<a class="sourceLine" id="cb11-18" data-line-number="18">        a.<span class="fu">init</span>();</a>
<a class="sourceLine" id="cb11-19" data-line-number="19">        a.<span class="fu">affichePrenom</span>(<span class="st">&quot;04/02/1943&quot;</span>);</a>
<a class="sourceLine" id="cb11-20" data-line-number="20">    }</a>
<a class="sourceLine" id="cb11-21" data-line-number="21">}</a>
<a class="sourceLine" id="cb11-22" data-line-number="22"></a>
<a class="sourceLine" id="cb11-23" data-line-number="23"><span class="kw">class</span> Personne{</a>
<a class="sourceLine" id="cb11-24" data-line-number="24">    <span class="bu">String</span> nom;</a>
<a class="sourceLine" id="cb11-25" data-line-number="25">    <span class="bu">String</span> prenom;</a>
<a class="sourceLine" id="cb11-26" data-line-number="26">    <span class="fu">Personne</span>(<span class="bu">String</span> nom, <span class="bu">String</span> prenom){</a>
<a class="sourceLine" id="cb11-27" data-line-number="27">        <span class="kw">this</span>.<span class="fu">nom</span> = nom;</a>
<a class="sourceLine" id="cb11-28" data-line-number="28">        <span class="kw">this</span>.<span class="fu">prenom</span> = prenom;</a>
<a class="sourceLine" id="cb11-29" data-line-number="29">    }</a>
<a class="sourceLine" id="cb11-30" data-line-number="30">}</a></code></pre></div>
<h2 id="classes-de-type-map">Classes de type Map</h2>
<p>On peut utiliser à la place de <code>HashMap</code> un type <code>TreeMap</code> ou <code>EnumMap</code> ainsi que d’autres classes (voir la <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html">Javadoc correspondante</a>)</p>
<p>Les différences d’implémentation entre ces différentes classes ne seront pas discutées ici.</p>
<h1 id="parcours">Parcours</h1>
<h2 id="interface-iterator">Interface Iterator</h2>
<p>Parmi les fonctionnalités communes aux collections, il y a la possibilité de parcourir la liste des éléments d’une collection via l’interface <code>Iterator</code>.</p>
<h2 id="cas-particulier-map">Cas particulier: Map</h2>
<p><code>Map</code> est ici un peu à part. Elle est liée aux collections dans le fait qu’elle possède deux méthodes qui renvoient des instances de l’interface <code>Set</code>:</p>
<ul>
<li><code>Set&lt;K&gt;   keySet()</code>: ensemble des clefs</li>
<li><code>Set&lt;Map.Entry&lt;K,V&gt;&gt;  entrySet()</code> : ensemble des entrées</li>
</ul>
<p>À partir de ces instances de <code>Set</code> il est possible de récupérer un <code>Iterator</code> pour en parcourir les éléments de la <code>Map</code>.</p>
<h2 id="iterator">Iterator</h2>
<h3 id="exemple-de-parcours">Exemple de parcours</h3>
<p>Voici un exemple d’utilisation d’un <code>Iterator</code>. Ceci est applicable à toute sous-interface de <code>Collection</code>:</p>
<div class="sourceCode" id="cb12"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb12-1" data-line-number="1"></a>
<a class="sourceLine" id="cb12-2" data-line-number="2"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">parcourir</span>(<span class="bu">Collection</span> collection) {</a>
<a class="sourceLine" id="cb12-3" data-line-number="3">   <span class="bu">Iterator</span> it = collection.<span class="fu">iterator</span>();</a>
<a class="sourceLine" id="cb12-4" data-line-number="4"></a>
<a class="sourceLine" id="cb12-5" data-line-number="5">   <span class="kw">while</span>(it.<span class="fu">hasNext</span>()) {</a>
<a class="sourceLine" id="cb12-6" data-line-number="6">      <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(it.<span class="fu">next</span>());</a>
<a class="sourceLine" id="cb12-7" data-line-number="7">   }</a>
<a class="sourceLine" id="cb12-8" data-line-number="8"> }</a></code></pre></div>
<h3 id="parcours-avec-for-et-for-each">Parcours avec for et for-each</h3>
<div class="sourceCode" id="cb13"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb13-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.collections;</span></a>
<a class="sourceLine" id="cb13-2" data-line-number="2"></a>
<a class="sourceLine" id="cb13-3" data-line-number="3"><span class="kw">import</span><span class="im"> java.util.Iterator;</span></a>
<a class="sourceLine" id="cb13-4" data-line-number="4"><span class="kw">import</span><span class="im"> java.util.Set;</span></a>
<a class="sourceLine" id="cb13-5" data-line-number="5"><span class="kw">import</span><span class="im"> java.util.TreeSet;</span></a>
<a class="sourceLine" id="cb13-6" data-line-number="6"></a>
<a class="sourceLine" id="cb13-7" data-line-number="7"><span class="kw">public</span> <span class="kw">class</span> ExempleIteration {</a>
<a class="sourceLine" id="cb13-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb13-9" data-line-number="9">        <span class="bu">Set</span>&lt;<span class="bu">Integer</span>&gt; entiers = <span class="kw">new</span> <span class="bu">TreeSet</span>&lt;&gt;();</a>
<a class="sourceLine" id="cb13-10" data-line-number="10">        entiers.<span class="fu">add</span>(<span class="dv">1</span>);</a>
<a class="sourceLine" id="cb13-11" data-line-number="11">        entiers.<span class="fu">add</span>(<span class="dv">2</span>);</a>
<a class="sourceLine" id="cb13-12" data-line-number="12">        entiers.<span class="fu">add</span>(<span class="dv">3</span>);</a>
<a class="sourceLine" id="cb13-13" data-line-number="13">        entiers.<span class="fu">add</span>(<span class="dv">4</span>);</a>
<a class="sourceLine" id="cb13-14" data-line-number="14">        entiers.<span class="fu">remove</span>(<span class="dv">3</span>);</a>
<a class="sourceLine" id="cb13-15" data-line-number="15">        entiers.<span class="fu">add</span>(<span class="dv">16</span>);</a>
<a class="sourceLine" id="cb13-16" data-line-number="16">        entiers.<span class="fu">add</span>(<span class="dv">8</span>);</a>
<a class="sourceLine" id="cb13-17" data-line-number="17"></a>
<a class="sourceLine" id="cb13-18" data-line-number="18">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;For sur Iterator&quot;</span>);</a>
<a class="sourceLine" id="cb13-19" data-line-number="19">        <span class="kw">for</span> (<span class="bu">Iterator</span>&lt;<span class="bu">Integer</span>&gt; iterator = entiers.<span class="fu">iterator</span>(); iterator.<span class="fu">hasNext</span>();) {</a>
<a class="sourceLine" id="cb13-20" data-line-number="20">            <span class="bu">Integer</span> entier = iterator.<span class="fu">next</span>();</a>
<a class="sourceLine" id="cb13-21" data-line-number="21">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(entier);</a>
<a class="sourceLine" id="cb13-22" data-line-number="22">        }</a>
<a class="sourceLine" id="cb13-23" data-line-number="23"></a>
<a class="sourceLine" id="cb13-24" data-line-number="24">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;For-each&quot;</span>);</a>
<a class="sourceLine" id="cb13-25" data-line-number="25">        <span class="kw">for</span> (<span class="bu">Integer</span> entier : entiers) {</a>
<a class="sourceLine" id="cb13-26" data-line-number="26">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(entier);</a>
<a class="sourceLine" id="cb13-27" data-line-number="27">        }</a>
<a class="sourceLine" id="cb13-28" data-line-number="28">    }</a>
<a class="sourceLine" id="cb13-29" data-line-number="29">}</a></code></pre></div>
<h1 id="application">Application</h1>
<h2 id="list-création-de-listes-de-véhicules">List : création de listes de véhicules</h2>
<p>Nous allons cette fois gérer des listes de <code>Vehicule</code> (en créant une nouvelle classe <code>Vehicule</code> dans le paquet <code>com.example.gestionflotte</code>).</p>
<p>Cette classe comportera les attributs permettants de stocker les informations suivantes:</p>
<ul>
<li>marque</li>
<li>modèle</li>
<li>identifiant (un entier dont la valeur est distincte pour chaque instance de la classe véhicule)</li>
</ul>
<p>D’un point de vue administratif, une personne (physique ou morale) est propriétaire d’un ou plusieurs véhicules. Ces véhicules peuvent être des types suivants (le nombre de type est ici limité pour simplifier le programme) :</p>
<ul>
<li>Véhicule Léger (automobile)</li>
<li>Véhicule de transport de personnes (plus de huit places assises)</li>
</ul>
<p>Une entreprise doit gérer une flotte de véhicule ayant ces différents types.</p>
<p>Pour chacun des points demandés, tester le code à partir la méthode <code>main</code> de la classe <code>GestionFlotte</code> créée plus bas.</p>
<div class="warning">
<p><strong>Il n’est pas demandé de gérer l’ajout ou l’affichage par des commandes au clavier</strong>.</p>
<p>Le test du programme se fera en ajoutant “en dur” différents véhicules et en examinant la sortie (console) qu’il fournit.</p>
<p>Le programme doit s’exécuter entièrement automatiquement et afficher des messages sur chaque instruction en cours d’exécution.</p>
</div>
<p>Création des types de véhicules</p>
<ol type="1">
<li>Créer la classe <code>Vehicule</code> et faite en sorte qu’un identifiant unique soit associé à chaque nouvelle instance.</li>
<li>Créer une classe pour chaque type (<code>VehiculeLeger</code>, <code>VehiculeLourd</code>, <code>VehiculeTransportPassagers</code>)</li>
<li>Pour la classe <code>VehiculeTransportPassagers</code>, ajouter un attribut indiquant le nombre maximal de passagers nommé <code>nombreMaxPassagers</code></li>
<li>Pour la classe <code>VehiculeLeger</code>, indiquer le type: entreprise (voiture à deux places), utilitaire ou particulier (véhicule à 5 places).</li>
<li>Redéfinir la méthode <code>equals</code> qui permet de vérifier si deux véhicules sont identiques (même marque, même modèle). Ils peuvent avoir des identifiants différents.</li>
<li>Implémenter la méthode <code>toString</code> de la classe véhicule pour afficher l’identifiant, la marque et le modèle sous cette forme: <code>&quot;[134,marque,modèle]&quot;</code></li>
</ol>
<p>On souhaite pouvoir gérer les listes suivantes:</p>
<ul>
<li>liste de tous les véhicules appartenant à l’entreprise: <code>listeGlobale</code></li>
<li>liste de tous les véhicules de transports de passagers: <code>listeTransportPassagers</code></li>
<li>liste de tous les véhicules légers: <code>listeVehiculesLegers</code></li>
</ul>
<p>La classe <code>GestionFlotte</code> va comporter une méthode <code>main</code>.</p>
<ol start="7" type="1">
<li>Cans la classe <code>GestionFlotte</code>, ajouter ces trois listes. Il ne doit pas être possible d’ajouter un type incorrect dans les différentes listes (pas de Véhicule Léger dans la liste des véhicules de transport de passagers).</li>
<li>Ajouter une méthode permettant d’ajouter un véhicule quelconque dans la liste globale: <code>ajouterVehicule(Vehicule v)</code></li>
<li>Ajouter une méthode permettant de supprimer un véhicule de la liste globale: <code>supprimerVehicule(Vehicule v)</code></li>
<li>Ajouter une méthode indiquant le nombre de véhicules dans la liste globale : <code>getNombreVehicules()</code></li>
<li>Tester le code en ajoutant puis supprimant plusieurs véhicules et en vérifiant si les valeur renvoyées sont cohérentes</li>
</ol>
<h2 id="list-affichage-dune-liste-de-véhicules">List: affichage d’une liste de véhicules</h2>
<p>Dans cette partie, il s’agit d’afficher les listes de véhicules sous forme de chaînes de caractères.</p>
<ol start="12" type="1">
<li>Créer une méthode permettant de récupérer sous forme de chaîne de caractère l’ensemble des véhicules pour chaque type (trois méthodes à créer):</li>
</ol>
<pre><code>- `getListeInformationsTousVehicules()`
- `getListeInformationsVehiculesLegers()`
- `getListeInformationsVehiculesTransportsPassagers()`</code></pre>
<ol start="13" type="1">
<li>Ajouter une méthode permettant de remplir automatiquement les deux listes spécialisées à partir de la liste globale. Un élément déjà présent dans une liste ne doit pas être ajouté.</li>
</ol>
<pre><code>- `synchroniserListesSpecialisees()`</code></pre>
<ol start="14" type="1">
<li>Faire en sorte que tout ajout de véhicule dans la flotte complète automatiquement les listes spécialisées si elles sont concernées (à chaque appel de la méthode <code>ajouterVehicule(Vehicule v)</code>).</li>
<li>Tester avec au moins deux instances pour chaque type de véhicule.</li>
</ol>
<h2 id="queue-et-set">(Queue et Set)</h2>
<p>Reprendre les classes permettant la gestion d’une flotte de véhicules (<code>GestionFlotte</code>).</p>
<ol start="16" type="1">
<li>Ajouter à la classe <code>GestionFlotte</code> un attribut <code>marquesVehicules</code> de type <code>Set</code> donnant l’ensemble des marques de véhicules gérés par <code>GestionFlotte</code>.</li>
</ol>
<pre><code>```java

Set&lt;String&gt; marquesVehicules = new HashSet&lt;&gt;();

```</code></pre>
<ol start="17" type="1">
<li>Créer une méthode <code>void syncMarquesVehicules()</code> permettant de remplir cet ensemble à partir de la liste de tous les véhicules (<code>listeGlobale</code>).</li>
<li>Créer une méthode <code>String getListeMarquesVehicules()</code> qui renvoie une chaîne de caractères représentant les données contenues dans <code>marquesVehicules</code> (exemple: <code>&quot;Mercedes,Toyota,Peugeot&quot;</code>)</li>
<li>Ajouter à la classe <code>GestionFlotte</code> un attribut <code>modelesVehicule</code> de type <code>Set</code> qui permet de gérer l’ensemble des marques et modèles de véhicule (un modèle de véhicule pouvant être présent plusieurs fois dans <code>listeGlobale</code>).</li>
<li>Créer une méthode <code>syncModelesVehicules</code> qui permet de remplir automatiquement <code>modelesVehicule</code> (lire la documentation de <code>Set.addAll(Collection)</code> et souvenez-vous de l’implémentation de la méthode <code>equals</code>)</li>
<li>Créer une méthode <code>String getListeModelesVehicules()</code> qui renvoie une chaîne de caractères représentant les données contenues dans <code>modelesVehicule</code> (exemple: <code>&quot;[Mercedes/Classe A],[Toyota/Prius],[Toyota/Yaris],[Peugeot/Partner]&quot;</code>)</li>
</ol>
<h2 id="map-référencement-de-véhicule">Map : référencement de véhicule</h2>
<p>Dans ce qui suit, vous traiterez les cas d’erreurs avec des exceptions (pour lesquelles vous créerez des classes).</p>
<p>Dans cette partie, nous allons références les véhicules par leur identifiant.</p>
<ol start="22" type="1">
<li>Créer une <code>Map</code> permettant de stocker la liste des véhicules en les référençant par leur identifiant.</li>
</ol>
<ul>
<li><p>quel est le type de l’identifiant ?</p>
<ol start="23" type="1">
<li>Créer une méthode permettant de récupérer un véhicule à partir de son identifiant: <code>getVehicule(int id)</code></li>
<li>Créer une <code>Map</code> permettant de classer les véhicules par constructeur (marque).</li>
</ol></li>
<li><p>quel doit être le type de la clef ?</p>
<ol start="25" type="1">
<li>Créer une méthode permettant de récupérer une chaîne de caractères représentant la liste des véhicules pour un constructeur passé en paramètres: <code>getListeVehiculePourMarque(...)</code></li>
<li>Faites en sorte de rendre cohérent le contenu de ses <code>Map</code> avec celui des listes de véhicules (à chaque ajout et/ou via une méthode de synchronisation)</li>
</ol></li>
<li><p>quelle manière semble la plus appropriée ?</p></li>
</ul>
<h2 id="iterator-application">Iterator: application</h2>
<p>Utilisez un Iterator pour afficher l’ensemble des éléments de la liste des véhicules légers.</p>
</body>
</html>