Des fractions comparables

On normalise une fois pour toutes dans le constructeur : ensuite, deux fractions égales ont exactement les mêmes attributs, et equals se réduit à les comparer.

class Fraction {
    private final int num, den;      // forme irréductible, den > 0

    Fraction(int num, int den) {
        if (den == 0) throw new IllegalArgumentException("dénominateur nul");
        if (den < 0) { num = -num; den = -den; }
        int g = pgcd(Math.abs(num), den);
        this.num = num / g;
        this.den = den / g;
    }

    private static int pgcd(int a, int b) { return b == 0 ? Math.max(a, 1) : pgcd(b, a % b); }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Fraction f)) return false;
        return num == f.num && den == f.den;   // formes irréductibles : comparaison directe
    }

    @Override
    public int hashCode() { return 31 * num + den; }

    @Override
    public String toString() { return num + "/" + den; }
}

La fraction $0/d$ devient $0/1$, car le pgcd de $0$ et de $d$ vaut $d$. Le Math.max(a, 1) est une simple précaution : il garantit que pgcd ne renvoie jamais $0$, ce qui n'arriverait que pour $0/0$, déjà refusé par le constructeur. Le test :

Fraction a = new Fraction(1, 2), b = new Fraction(2, 4), c = new Fraction(-3, -6);
System.out.println(a + " " + b + " " + c);
System.out.println(a.equals(b) + " " + b.equals(c) + " " + a.equals("1/2"));
Set<Fraction> s = new HashSet<>();
s.add(a); s.add(b); s.add(c); s.add(new Fraction(1, 3));
System.out.println(s.size());

1/2 1/2 1/2
true true false
2

a.equals("1/2") est faux : une chaîne n'est pas une fraction, même si elle s'affiche pareil.