TP 1 — Utilisation des collections

import java.util.Objects;

/**
 * Version finale de la classe Iris : equals et hashCode redéfinis (Q6),
 * et Comparable implémentée (Q8, pour que le TreeSet sache ordonner).
 */
public class Iris implements Comparable<Iris> {

    private String variety;
    private Double length;
    private Double width;

    public Iris(String variety, Double length, Double width) {
        this.variety = variety;
        this.length = length;
        this.width = width;
    }

    public String getVariety() { return variety; }
    public Double getLength() { return length; }
    public Double getWidth() { return width; }

    public void affiche() {
        System.out.println(this);
    }

    @Override
    public String toString() {
        return variety + " " + length + " " + width;
    }

    // Q6 — deux iris sont égaux s'ils ont la même variété, la même longueur
    //      et la même largeur.
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Iris)) return false;
        Iris iris = (Iris) o;
        return Objects.equals(variety, iris.variety)
                && Objects.equals(length, iris.length)
                && Objects.equals(width, iris.width);
    }

    // Q6 — indispensable pour que hashCode reste cohérent avec equals
    //      (a.equals(b) => a.hashCode() == b.hashCode()).
    @Override
    public int hashCode() {
        return Objects.hash(variety, length, width);
    }

    // Q8 — l'ordre naturel : variété, puis longueur, puis largeur.
    @Override
    public int compareTo(Iris autre) {
        int parVariete = variety.compareTo(autre.variety);
        if (parVariete != 0) return parVariete;
        int parLongueur = length.compareTo(autre.length);
        if (parLongueur != 0) return parLongueur;
        return width.compareTo(autre.width);
    }
}

import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

/** Le main complet : Q4 à Q9 avec la classe Iris corrigée. */
public class UseIris {

    public static void main(String[] args) {
        // Q2 — les 5 iris du sujet
        Iris i1 = new Iris("Setosa", 5.1, 3.5);
        Iris i2 = new Iris("Setosa", 4.9, 3.0);
        Iris i3 = new Iris("Setosa", 4.7, 3.2);
        Iris i4 = new Iris("Versicolor", 7.0, 3.2);
        Iris i5 = new Iris("Versicolor", 6.4, 3.2);

        // Q3 — un HashSet
        Set<Iris> fleurs = new HashSet<>();
        fleurs.add(i1);
        fleurs.add(i2);
        fleurs.add(i3);
        fleurs.add(i4);
        fleurs.add(i5);

        // Q4 — affichage
        System.out.println("— la collection —");
        for (Iris fleur : fleurs) {
            fleur.affiche();
        }

        // Q5/Q6 — le doublon est maintenant refusé
        Iris doublon = new Iris("Versicolor", 6.4, 3.2);
        boolean ajoute = fleurs.add(doublon);
        System.out.println("ajout du doublon accepté ? " + ajoute + " (taille = " + fleurs.size() + ")");

        // Q7 — quatre opérations en une ligne chacune
        System.out.println("— les fleurs de longueur > 5 —");
        fleurs.stream().filter(f -> f.getLength() > 5).forEach(System.out::println);

        System.out.println("— triées par longueur décroissante —");
        fleurs.stream().sorted(Comparator.comparingDouble(Iris::getLength).reversed()).forEach(System.out::println);

        System.out.println("— largeur moyenne —");
        System.out.println(fleurs.stream().mapToDouble(Iris::getWidth).average().orElse(0.0));

        System.out.println("— le triple des longueurs —");
        List<Double> triples = fleurs.stream().map(f -> f.getLength() * 3).collect(Collectors.toList());
        System.out.println(triples);

        // Q8 — un TreeSet ordonne selon compareTo
        System.out.println("— le TreeSet —");
        Set<Iris> arbre = new TreeSet<>(fleurs);
        for (Iris fleur : arbre) {
            fleur.affiche();
        }

        // Q9 — retrait des Setosa
        fleurs.removeIf(f -> f.getVariety().equals("Setosa"));
        System.out.println("— après retrait des Setosa (taille = " + fleurs.size() + ") —");
        for (Iris fleur : fleurs) {
            fleur.affiche();
        }
    }
}

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Le « compteur de mots » du TP 1 (partie 2) : une Map mot -> nombre
 * d'occurrences. Q1 : le type de la clé (String) et de la valeur (Integer).
 */
public class Compte {

    // Q1/Q2 — le dictionnaire d'occurrences, une HashMap pour commencer
    private Map<String, Integer> occurrences = new HashMap<>();

    // Q2 — compter les mots d'une phrase (et cumuler si le mot est déjà là)
    public void compter(String phrase) {
        for (String mot : phrase.split("\\s+")) {
            if (!mot.isEmpty()) {
                occurrences.merge(mot, 1, Integer::sum);
            }
        }
    }

    // Q7 — compter les mots d'un fichier : on vide d'abord, puis ligne par ligne
    public void compterFichier(String chemin) throws IOException {
        occurrences.clear();
        for (String ligne : Files.readAllLines(Path.of(chemin), StandardCharsets.UTF_8)) {
            for (String mot : ligne.split("\\s+")) {
                if (!mot.isEmpty()) {
                    occurrences.merge(mot, 1, Integer::sum);
                }
            }
        }
    }

    // Q8 (amélioration) — découpage nettoyé : minuscules, apostrophes et
    // ponctuation comme séparateurs, et on ne garde que les mots d'au moins
    // deux lettres.
    static List<String> decouperProprement(String ligne) {
        String[] bruts = ligne.toLowerCase()
                .replaceAll("[’']", " ")
                .replaceAll("[^a-zàâäçéèêëîïôöùûüœæ]", " ")
                .split("\\s+");
        return Stream.of(bruts).filter(mot -> mot.length() > 1).collect(Collectors.toList());
    }

    public void compterFichierPropre(String chemin) throws IOException {
        occurrences.clear();
        for (String ligne : Files.readAllLines(Path.of(chemin), StandardCharsets.UTF_8)) {
            for (String mot : decouperProprement(ligne)) {
                occurrences.merge(mot, 1, Integer::sum);
            }
        }
    }

    // Q3 — l'affichage : on parcourt la Map avec entrySet()
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, Integer> couple : occurrences.entrySet()) {
            sb.append(couple.getKey()).append(" : ").append(couple.getValue()).append('\n');
        }
        return sb.toString();
    }

    // Q6 — retirer les mots vus une seule fois (it.remove retire proprement)
    public void retirerOccurrencesUniques() {
        Iterator<Map.Entry<String, Integer>> it = occurrences.entrySet().iterator();
        while (it.hasNext()) {
            if (it.next().getValue() <= 1) {
                it.remove();
            }
        }
    }

    // Q8 — les n mots les plus fréquents, du plus fréquent au moins fréquent
    public void afficherPlusFrequents(int n) {
        occurrences.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                .limit(n)
                .forEach(couple -> System.out.println(couple.getKey() + " : " + couple.getValue()));
    }

    public int taille() {
        return occurrences.size();
    }
}

/** Q4 à Q6 sur la phrase du sujet (et l'observation de l'ordre de la Map). */
public class TestPhrase {

    public static void main(String[] args) {
        Compte compte = new Compte();

        // Q4 — la phrase du sujet
        compte.compter("Un chasseur sachant chasser doit savoir chasser sans son chien");

        System.out.println("— la Map telle quelle —");
        System.out.println(compte);

        // Q6 — on retire les mots vus une seule fois
        compte.retirerOccurrencesUniques();
        System.out.println("— après retrait des mots vus une seule fois —");
        System.out.println(compte);
    }
}

/** Q7 et Q8 sur le vrai texte : Notre-Dame de Paris. */
public class TestRoman {

    public static void main(String[] args) throws Exception {
        String chemin = args[0];

        // Q7 — comptage brut (découpage sur les espaces)
        Compte brut = new Compte();
        long debut = System.currentTimeMillis();
        brut.compterFichier(chemin);
        long duree = System.currentTimeMillis() - debut;
        System.out.println("brut    : " + brut.taille() + " mots distincts, en " + duree + " ms");
        brut.afficherPlusFrequents(5);

        // Q8 — comptage nettoyé (minuscules, ponctuation, longueur > 1)
        Compte propre = new Compte();
        propre.compterFichierPropre(chemin);
        System.out.println("nettoyé : " + propre.taille() + " mots distincts");
        propre.afficherPlusFrequents(5);
    }
}