2014-02-12

Interface et collections

Interface

Une interface est un contrat qui se définit avec le mot clef interface

public interface MonInterface {
   // Une interface peut définir des constantes
   int MAX = 4;

   // et des méthodes
   void maMethode();
   int monAutreMethode();
}

• une interface n'est pas instanciable

• une interface peut hériter d'une autre interface

  public interface MonInterface extends MonInterfaceParente

• Une interface se déclare dans un fichier comme une classe

• Les interfaces partagent leur espace de noms avec les classes
• Une interface se compile comme une classe
• Une interface peut contenir de la javadoc

Une classe peut implémenter une (ou plusieurs) interface(s) (mot clef implements). Elle doit alors implémenter les méthodes déclarées dans ces interfaces.

public class MaClasse implements MonInterface {
    // Attributs
    ...

    // Méthodes
    ...

    // Les méthodes déclarées dans mon interface
    public void maMethode() {
       ...
    }

    public int monAutreMethode() {
       ...
    }
}

Collections

Un ensemble d'interfaces et de classes fournies dans le JDK (package java.util) pour manipuler des collections d'objets. Avantages :

• réduire le temps de programmation
• se baser sur du code testé et optimisé
• un ensemble cohérent d'API et de classes d'implémentation
• des collections qui intègrent tous les types d'objet

3 types principaux :

• listes implémentant l'interface java.util.List
• ensembles implémentant l'interface java.util.Set
• dictionnaires implémentant l'interface java.util.Map

Usage

Famille	Implémentation ex.	Usage
java.util.List	java.util.ArrayList	Liste ordonnée d'objets, accès séquentiel
java.util.Set	java.util.HashSet	Ensemble d'objets uniques, dédoublonnage
java.util.Map	java.util.HashMap	Table de correspondance

Utilisation

Liste

    List<String> maListe = new ArrayList<String>();
    maListe.add("mardi"); // ajouter un élément en fin de liste
    maListe.add(0, "lundi"); // ajouter à la position 0
    maListe.get(1); // Renvoie "mardi"
    maListe.contains("mardi"); // renvoie true
    maListe.remove(1); // supprime "mardi"
    maListe.contains("mardi"); // renvoie false
    maListe.size(); // renvoie 1

Ensemble

    Set<String> monEnsemble = new HashSet<String>();
    monEnsemble.add("lundi"); // ajoute "lundi"
    monEnsemble.add("lundi"); // "lundi" existe déjà, il n'est pas ajouté
    monEnsemble.add("mardi"); // ajoute "mardi"
    // Retourne un tableau avec les éléments dans un ordre non déterminé
    monEnsemble.toArray(new String[0]); 
    monEnsemble.contains("lundi"); // renvoie true

Dictionnaires

    Map<String, Integer> occurrences = new HashMap<String, Integer>();
    occurrences.put("truc", new Integer(45)); // Associe "de" à 45
    occurrences.put("chose", new Integer(112)); // Associe "chose" à 112
    occurrences.get("truc"); // Retourne 45
    occurrences.get("machine"); // Retourne null
    occurrences.containsKey("truc"); // Retourne true

Algorithmes

Tri des objets

Ordre naturel

Les objets à trier doivent implémenter l'interface java.lang.Comparable

Pour trier les listes, on utilisera la méthode java.util.Collections.sort()

Ordre complémentaire

Utilisation d'un objet implémentant java.lang.Comparator à passer en deuxième paramètre de la méthode java.util.Collections.sort()

TP - manipulation de texte avec les collections

TP1 - différentes opérations sur les textes

L'objectif de ce TP est de créer une classe fr.crim.a2013.TextUtil permettant de :
- charger une liste de mots vides contenus dans un fichier texte
- extraire une liste de mots à partir d'un fichier texte
- établir une liste de fréquence des mots dans le fichier

Initialisation

• Créer un nouveau projet dans Eclipse
• Créer une nouvelle classe fr.crim.a2013.TextUtil
• Créer un dossier rsc à la racine du projet dans lequel on déposera 2 fichiers
• motsvides.txt (liste de mots vides, un par ligne, les lignes commençant par # et les lignes vides sont à ignorer)
• rimbaud_poesies.txt (notre texte d'étude)
• Par souci de simplification, toutes les méthodes que l'on développera dans cette classe seront statiques

Chargement des mots vides

Implémenter la méthode chargeMotsVides :

/**
 * Charge une liste de mots vides à partir d'un fichier encodé en UTF-8
 * @param fichierMotsVides Le fichier contenant les mots vides
 * @return la collection de mots vides chargée
 * @throws IOException en cas de souci de lecture
 */
public static Collection<String> chargeMotsVides(File fichierMotsVides)
     throws IOException {
   ....
}

Note : on pourra utiliser la classe java.util.Scanner pour la lecture

Tester le fonctionnement de la méthode en affichant dans la méthode main la taille de votre collection et son contenu :

Collection<String> motsVides = chargeMotsVides(new File("rsc/motsvides.txt");
System.out.println(motsVides.size() + " mots vides");
System.out.println(motsVides);

Extraction d'une liste de mots

Implémenter la méthode extraitMots :

/**
 * Extrait une liste de mots à partir d'un fichier encodé en UTF-8. On réalisera un
 * découpage grossier sur les espaces et signes de ponctuation
 * @param fichierTexte Le fichier à lire
 * @return La liste de mots
 * @throws IOException en cas de souci de lecture
 */
public static List<String> extraitMots(File fichierTexte)
    throws IOException {
    ...
}

Tester le fonctionnement de la méthode en affichant dans la méthode main la taille de votre liste et son contenu

Note : la méthode extraitMots passera en minuscules les mots extraits du fichier texte, ceci afin de faciliter le test d'appartenance dans l'ensemble de mots vides.

Prise en compte des mots vides

Implémenter une deuxième méthode extraitMots

/**
 * Extrait une liste de mots à partir d'un fichier encodé en UTF-8. On réalisera un
 * découpage grossier sur les espaces et signes de ponctuation. On ignorera les mots
 * vides présents dans la collection passée en paramètre
 * @param fichierTexte Le fichier à lire
 * @param motsVides la liste des mots vides à filtrer
 * @return La liste de mots
 * @throws IOException en cas de souci de lecture
 */
public static List<String> extraitMots(File fichierTexte, Collection<String> motsVides)
    throws IOException {
    ...
}

Tester le fonctionnement de la méthode en affichant dans la méthode main la taille de la liste de mots extraites en prenant en compte les mots vides et son contenu.

Création d'une liste de fréquences

Implémenter une méthode freqList :

/**
 * Crée un dictionnaire mot -> occurrence à partir d'une liste de mots
 * @param mots liste de mots
 * @return dictionnaire
 */
public static Map<String,Integer> freqList(Collection<String> mots) {
    ....
}

Tester le fonctionnement de la méthode en affichant dans la méthode main la taille du dictionnaire et son contenu.

TP2 - liste de fréquences

L'objectif ici est d'afficher la liste de fréquences calculée par la méthode freqList() dans l'ordre décroissant de fréquences (1ère clef de tri). Si plusieurs mots apparaissent à la même fréquence, ceux-ci doivent être trié par ordre alphabétique (2ème clé de tri).

Ex :

    et (530)
    en (156)
    que (156)
    qui (156)
    au (122)
    je (120)
    ...

Note : cet exemple est fictif et met surtout en valeur le fait que la liste de mots vides utilisée est à compléter !

On utilisera pour ceci un objet MotFreq (cf. ci-dessous).

Initialisation

Créer une nouvelle classe fr.crim.a2013.MotFreq qui contiendra 2 attributs d'instance privés :

• mot (de type String)
• freq (de type int)

Ajouter un constructeur à la classe permettant de créer un nouvel objet de type MotFreq en lui passant le mot et sa fréquence en paramètre

Affichage de la liste de fréquence

Dans la classe fr.crim.a2013.TextUtil, créer une méthode afficheFreqList :

/**
 * Affiche la liste de fréquences passée en paramètre dans l'ordre décroissant de
 * fréquence, puis alphabétiquement
 * @param freqList Un dictionnaire mot -> frequence
 */
public static void afficheFreqList(Map<String,Integer> freqList) {
   ....
}

Le travail à réaliser dans la méthode est le suivant :

• Parcourir le dictionnaire pour réaliser une liste d'objets MotFreq
• Trier la liste des MotFreq selon leur ordre naturel (implémentation de l'interface java.lang.Comparable)
• Afficher le contenu de la liste (on ajoutera une méthode toString() à la classe MotFreq pour obtenir un affichage du type "terme (freq)"

Complément

Lorsque l'affichage fonctionne, compléter la liste de mots vides pour voir apparaître des mots signifiants parmi les plus fréquents

[crim.fr, prof java]

Fichier de mots vides

[crim.fr, prof java]

Fichier à traiter

[crim.fr, prof java]

Ce TP (TP1 et TP2) démarré en séance est à terminer individuellement et à renvoyer sur la liste javacrim-coop. Il sera noté dans le cadre du contrôle continu du 2nd semestre.

Date limite des envois : mardi 4/3 à minuit.

Attendu : le code source des classes fr.crim.a2013.TextUtil et fr.crim.a2013.MotFreq commentés + fichier motsvides.txt complété.