Soit la classe Etudiant. En utilisant les collections, Écrire une
classe promotion, disposant des méthodes suivantes :


  add(Etudiant e);
  remove(Etudiant e);
  Iterator iterator()
  double getMoyenne()



* utilisez une ArrayList pour implémenter Promotion
* vous écrirez la méthode \texttt{moyenne} en utilisant un itérateur ;


Correction :
********************************************************************************
// Version de promotion pour l'exercice 1 :

import java.util.*;


public class Promotion {
    private ArrayList etudiants;

    public Promotion() {
        etudiants= new ArrayList();
    }

    public void add(Etudiant e) {
        etudiants.add(e);
    }
    
    public void remove(Etudiant e) {
        etudiants.remove(e);
    }
    
    public Iterator iterator() {
        return etudiants.iterator();
    }
    
    double getMoyenne() {
        double somme= 0.0;
        for (Iterator i= iterator(); i.hasNext(); )
            {
                Etudiant e= (Etudiant)i.next();
                somme+= e.getMoyenne();
            }
        return somme / etudiants.size();
    }

    public String toString() {
        String s= "";
        for (Iterator i= iterator(); i.hasNext(); )
            {
                s+= i.next() + "\n";
            }
        return s;
    }
    
    public static void main(String args[]) {
        Promotion promo= new Promotion();
        Etudiant e, e1;
        e= new Etudiant(20, "Turing");
        e.setMoyenne(16);
        promo.add(e);
        e= new Etudiant(10, "Babbage");
        e.setMoyenne(12);
        promo.add(e);
        e1= e;
        e= new Etudiant(34, "Lovelace");
        e.setMoyenne(18);
        promo.add(e);
        e= new Etudiant(2, "Wirth");
        e.setMoyenne(13);
        promo.add(e);
        
        System.out.println(promo);

        promo.remove(e1);
        
        System.out.println(promo);

        System.out.println("moyenne "+ promo.getMoyenne());
    }
}
    
**********************************************************
  
  On pourrait écrire Promotion extends ArrayList.}  Cependant,
  la solution choisie est plus correcte. En effet, on peut ajouter
  n'importe quoi dans une ArrayList}.  Par contre, dans notre
  classe Promotion,} il est impossible d'ajouter autre chose
  qu'un étudiant.
  
  L'iterateur, seul pose un léger problème car il oblige à un cast.
  Une solution possible, mais un peu lourde, consiste à définir une
  classe PromotionIterator,} dont la méthode next}
  retourne un Etudiant} et non un Object}. La méthode
  iterator est modifiée :


public PromotionIterator iterator() {
  return new PromotionIterator(this);


avec

********************************************************************************
public class PromotionIterator {
  Iterator representation;

  PromotionIterator(Promotion p) {
    representation= p.iterator();
  }

  public boolean hasNext() 
  {
    return representation.hasNext();
  }

  public Etudiant next() 
  {
    return (Etudiant)representation.next();
  }
}  
********************************************************************************
  
Exercice 2

Même chose, mais on veut remplacer la liste des éléments par un
ensemble ordonné, les étudiants étant classés par ordre
alphabétique (et affichés de même).


  Correction.: Il suffit de remplacer ArrayList par
  TreeSet dans l'exercice précédent. Pour que cela fonctionne,
  il faut modifier la classe Etudiant qui doit implémenter
  l'interface Comparable. La méthode compareTo à
  écrire est :
  

 //... Dans la classe Etudiant ...
 public int compareTo(Object o) {
   Etudiant e= (Etudiant)o;
   // On compare les noms.
   int res= nom.compareTo(e.nom);
   
   // Deux étudiants de même nom, mais de numéros
   // différents, sont différents. D'où le test qui 
   // suit :
   if (res!=0) 
   {
     return res;
   }
   else 
   {
     return numero - e.numero;
   }
 }


Exercice

La classe DicoFrame est l'interface d'un dictionnaire.
L'utilisateur peut y insérer un mot et visualiser les définitions existantes.

On veut compléter DicoFrame en écrivant une classe
Dictionnaire. Vous pourrez utiliser une Map.


* faites fonctionner le bouton insérer
* faites fonctionner le bouton chercher
* faites fonctionner le bouton lister : la liste des mots
  définis apparaîtra dans la fenêtre centrale.
* Regardez la documentation de SortedMa}. modifiez
  la fonction de recherche pour qu'elle renvoie le premier mot qui commence par
  ce qui est tapé dans la fenêtre du haut.

Correction
  on notera en particulier le parcours du tableau associatif.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
// Il serait plus propre d'avoir une classe dictionnaire séparée.

public class DicoFrame1 extends JFrame implements ActionListener {
    
    private JButton chercher;
    private JButton inserer;
    private JButton lister;
    // Le mot à definir ou à chercher :
    private JTextField mot;
    private JTextArea definition;

    private TreeMap dictionnaire;
    
    public DicoFrame1() {
        // On donne à la fenêtre le nom "Dictionnaire".
        super("Dictionnaire");
        Container p= getContentPane();
        // On fixe le layout.
        p.setLayout(new BorderLayout());
        
        // On crée les champs textes et on les ajoute :
        mot= new JTextField();
        definition= new JTextArea(10,30);
        p.add(mot, BorderLayout.NORTH);
        p.add(definition, BorderLayout.CENTER);
        
        // On crée un panneau pour les boutons :
        JPanel sub= new JPanel();
        // On crée les boutons et on les ajoute.
        chercher= new JButton("chercher");
        inserer= new JButton("inserer");
        lister= new JButton("lister");
        chercher.addActionListener(this);
        inserer.addActionListener(this);
        lister.addActionListener(this);
        sub.setLayout(new FlowLayout());
        sub.add(chercher);
        sub.add(inserer);
        sub.add(lister);

        // On ajoute le panneau des boutons à l'application.
        p.add(sub, BorderLayout.SOUTH);
        
        // On crée le dictionnaire
        dictionnaire= new TreeMap();
    }

    /**
     *
     * @param param1 event
     */
    
    public void actionPerformed(ActionEvent param1) {
        if (param1.getSource() ==  chercher) 
            {
                definition.setText((String)dictionnaire.get(mot.getText()));
            } 
        else if ( param1.getSource() ==  inserer)
            {
                dictionnaire.put(mot.getText(), definition.getText());
                mot.setText("");
                definition.setText("");
            }
        else if ( param1.getSource() ==  lister)
            {
                Set entrees= dictionnaire.entrySet();
                definition.setText("");
                for (Iterator i= entrees.iterator(); i.hasNext();)
                    {
                        // Récupérer la clef
                        Map.Entry entree= (Map.Entry)i.next();
                        String clef = (String) entree.getKey();
                        // L'ajouter dans la fenêtre de texte :
                        definition.append(clef+ "\n");
                    }
            }
    }

    public static void main(String arg[]) {
        DicoFrame1 f= new DicoFrame1();
        f.pack();
        f.setVisible(true);
    }
}


  Pour la dernière question, on utilise la méthode tailMap
  (voir SortedMap dans la javadoc). Cette méthode retourne une sous-Map, 
  qui est l'ensemble de toutes les entrées d'une Map qui sont plus grandes qu'une
  entrée donnée.  Comme une TreeMap est une SortedMap, il suffit d'écrire :

        if (param1.getSource() ==  chercher) 
            {
              // On considère le dictionnaire des mots 
              // supérieurs ou égaux à mot.getText();
              Map sousDico= dictionnaire.tailMap(mot.getText());
              // On veut en récupérer le premier élément -- s'il
              // existe ! Il y a de nombreuses solutions.
              // La suivante n'est pas la plus efficace, mais elle
              // est simple :
              
              // S'il y a au moins un mot >= prefixe cherché :
              if (sousDico.size() > 0) {
                String premier= sousDico.firstKey();
                // et que le plus petit de ces mots commence
                // effectivement par le mot cherché ...
                if (premier.startsWith(mot.getText()) {
                  mot.setText(premier);
                  definition.setText((String)dictionnaire.get(premier));
                }
              }
            }