TD 1 — Set et Map

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.stream.Stream;

/** Exercice 1 du TD 1 — l'interface Set : les 7 questions dans un seul main. */
public class Ensembles {

    /** Tire au hasard n entiers différents entre 1 et borneMax (add refuse les doublons). */
    static Set<Integer> tirage(Random r, int n, int borneMax) {
        Set<Integer> s = new HashSet<>();
        while (s.size() < n) {
            s.add(r.nextInt(borneMax) + 1);
        }
        return s;
    }

    public static void main(String[] args) {
        Random r = new Random();

        // Q1 — deux ensembles de 5 entiers entre 1 et 100
        Set<Integer> ens1 = tirage(r, 5, 100);
        Set<Integer> ens2 = tirage(r, 5, 100);
        System.out.println("Q1  ens1 = " + ens1);
        System.out.println("Q1  ens2 = " + ens2);

        // Q2 — 980 entiers différents entre 1 et 1000
        Set<Integer> grand = tirage(r, 980, 1000);
        System.out.println("Q2  tirage  : grand.size() = " + grand.size());
        List<Integer> tous = new ArrayList<>();
        for (int i = 1; i <= 1000; i++) {
            tous.add(i);
        }
        Collections.shuffle(tous);
        Set<Integer> grand2 = new HashSet<>(tous.subList(0, 980));
        System.out.println("Q2  mélange : grand2.size() = " + grand2.size());

        // Q3 — nombre d'éléments, puis parcours avec un itérateur, puis un foreach
        System.out.println("Q3  " + ens1.size());
        Iterator<Integer> it = ens1.iterator();
        StringBuilder viaIterateur = new StringBuilder();
        while (it.hasNext()) {
            viaIterateur.append(it.next()).append(' ');
        }
        System.out.println("Q3  itérateur : " + viaIterateur.toString().trim());
        StringBuilder viaForeach = new StringBuilder();
        for (Integer v : ens1) {
            viaForeach.append(v).append(' ');
        }
        System.out.println("Q3  foreach   : " + viaForeach.toString().trim());
        System.out.println("Q3  toString  : " + ens1);

        // Q4 — intersection avec un foreach, puis sans
        Set<Integer> interForeach = new HashSet<>();
        for (Integer v : ens1) {
            if (ens2.contains(v)) {
                interForeach.add(v);
            }
        }
        Set<Integer> interRetain = new HashSet<>(ens1);
        interRetain.retainAll(ens2);
        System.out.println("Q4  intersection (foreach)   = " + interForeach);
        System.out.println("Q4  intersection (retainAll) = " + interRetain);

        // Q5 — union
        Set<Integer> union = new HashSet<>(ens1);
        union.addAll(ens2);
        System.out.println("Q5  union = " + union);

        // Q6 — Stream filtré sur les éléments strictement supérieurs à 5
        Stream<Integer> sup5 = ens1.stream().filter(v -> v > 5);
        StringBuilder affichage = new StringBuilder();
        sup5.forEach(v -> affichage.append(v).append(' '));
        System.out.println("Q6  éléments > 5 : " + affichage.toString().trim());

        // Q7 — max, min, somme : boucle (itérateur/foreach), puis Stream
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        int somme = 0;
        for (Integer v : ens1) {
            if (v > max) max = v;
            if (v < min) min = v;
            somme += v;
        }
        System.out.println("Q7  boucle : max = " + max + ", min = " + min + ", somme = " + somme);
        int maxS = ens1.stream().max(Integer::compare).orElseThrow();
        int minS = ens1.stream().min(Integer::compare).orElseThrow();
        int sommeS = ens1.stream().mapToInt(Integer::intValue).sum();
        System.out.println("Q7  stream : max = " + maxS + ", min = " + minS + ", somme = " + sommeS);
        System.out.println("Q7  Collections.max/min : " + Collections.max(ens1) + " / " + Collections.min(ens1));
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;

/**
 * Exercice 2 du TD 1 — l'interface Map : annuaire de téléphones.
 * Q1 à Q7 : un nom (String, la clé) -> un téléphone (Telephone, la valeur).
 */
public class Annuaire {

    /** Q6 — le téléphone du nom, ou une exception si le nom est inconnu. */
    static Telephone telephoneDe(Map<String, Telephone> annuaire, String nom) {
        Telephone t = annuaire.get(nom);
        if (t == null) {
            throw new NoSuchElementException("Pas de numéro pour " + nom);
        }
        return t;
    }

    public static void main(String[] args) {
        // Q2 — instanciation de la Map
        Map<String, Telephone> annuaire = new HashMap<>();

        // Q3 — Pierre et son numéro
        annuaire.put("Pierre", new Telephone(6, 54, 67, 34, 12));
        // quelques amis en plus pour la suite
        annuaire.put("Dupont", new Telephone(6, 11, 22, 33, 44));
        annuaire.put("Dassis", new Telephone(7, 77, 88, 99, 11));
        annuaire.put("Martin", new Telephone(6, 55, 44, 33, 22));

        // Q4 — tous les numéros de l'annuaire
        System.out.println("— Q4 : tous les numéros —");
        for (Telephone t : annuaire.values()) {
            System.out.println(t);
        }

        // Q5 — les numéros des amis dont le nom commence par 'D'
        System.out.println("— Q5 : les amis en 'D' —");
        for (Map.Entry<String, Telephone> couple : annuaire.entrySet()) {
            if (couple.getKey().startsWith("D")) {
                System.out.println(couple.getKey() + " : " + couple.getValue());
            }
        }

        // Q7 — les téléphones des noms passés en argument
        if (args.length > 0) {
            System.out.println("— Q7 : les noms passés en argument —");
            for (String nom : args) {
                System.out.println(nom + " -> " + telephoneDe(annuaire, nom));
            }
        }
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

/**
 * Exercice 2, questions 8 et 9 : les amis ont plusieurs numéros.
 * La valeur V devient List<Telephone> (une liste par nom).
 */
public class AnnuaireListes {

    static Map<String, List<Telephone>> annuaire = new HashMap<>();

    /** Ajoute un numéro à un ami (crée la liste au premier numéro). */
    static void ajouter(String nom, Telephone numero) {
        List<Telephone> numeros = annuaire.get(nom);
        if (numeros == null) {
            numeros = new ArrayList<>();
            annuaire.put(nom, numeros);
        }
        numeros.add(numero);
    }

    /** Q9·6 — un des téléphones possibles du nom, ou exception si inconnu. */
    static Telephone telephoneDe(String nom) {
        List<Telephone> numeros = annuaire.get(nom);
        if (numeros == null || numeros.isEmpty()) {
            throw new NoSuchElementException("Pas de numéro pour " + nom);
        }
        return numeros.get(0);
    }

    public static void main(String[] args) {
        // Q9·1 et Q9·2 — même clé String, valeur List<Telephone>
        ajouter("Pierre", new Telephone(6, 54, 67, 34, 12));
        ajouter("Pierre", new Telephone(6, 12, 34, 56, 78)); // un second numéro
        ajouter("Dupont", new Telephone(6, 11, 22, 33, 44));
        ajouter("Dassis", new Telephone(7, 77, 88, 99, 11));

        // Q9·4 — tous les numéros : values() renvoie des listes
        System.out.println("— Q9·4 : tous les numéros —");
        for (List<Telephone> numeros : annuaire.values()) {
            for (Telephone t : numeros) {
                System.out.println(t);
            }
        }

        // Q9·5 — les amis en 'D'
        System.out.println("— Q9·5 : les amis en 'D' —");
        for (Map.Entry<String, List<Telephone>> couple : annuaire.entrySet()) {
            if (couple.getKey().startsWith("D")) {
                System.out.println(couple.getKey() + " : " + couple.getValue());
            }
        }

        // Q9·6 — un des téléphones de Pierre, puis d'un inconnu
        System.out.println("— Q9·6 —");
        System.out.println("Pierre -> " + telephoneDe("Pierre"));
        System.out.println("Inconnu -> " + telephoneDe("Inconnu"));
    }
}

import java.util.Objects;

/**
 * Le type « Telephone » du sujet : un constructeur à 5 entiers (le numéro
 * en 5 groupes), un affichage, une méthode equals et une méthode hashCode.
 */
public class Telephone {

    private final int a, b, c, d, e;

    public Telephone(int a, int b, int c, int d, int e) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
    }

    @Override
    public String toString() {
        return String.format("%02d %02d %02d %02d %02d", a, b, c, d, e);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Telephone)) return false;
        Telephone t = (Telephone) o;
        return a == t.a && b == t.b && c == t.c && d == t.d && e == t.e;
    }

    @Override
    public int hashCode() {
        return Objects.hash(a, b, c, d, e);
    }
}