Как сделать пересечение и разность множеств?

public class Rational implements Comparable<Rational> {
    private int n, d;
 
    
    //@param n - целое
    public Rational(int n) { 
        setValue(n); 
        }
    /**
     * @param n - числитель
     * @param d - знаменатель
    */
    public Rational(int n, int d) throws IllegalArgumentException {
        setValue(n, d);
    }
    public Rational(Rational f) {
        setValue(f);
    }
    
    public int getNumerator() {
        return n; 
        }
    public int getDenominator() {
        return d; 
        }
    
    public void setNumerator(int n) {
        setValue(n, this.d); 
        }
    public void setDenominator(int d) {
        setValue(this.n, d);
        }
    
    //Новая дробь из целого числа
    public void setValue(int n) {
        this.n = n; this.d = 1;
        }
    // Новая дробь из числиетля и знаменателя
    public void setValue(int n, int d) throws IllegalArgumentException {
        if (d == 0)
            throw new IllegalArgumentException("Ошибка: Знаменатель не может быть равен 0");
        this.n = n;
        this.d = d;
        reduce();
    }
    public void setValue(Rational f) {
        this.n = f.n; 
        this.d = f.d; 
        }
    
    //Сокращение
    private void reduce() {
        int gcd = Arithmetics.gcd(n, d);
        n /= gcd;
        d /= gcd;
        if (d < 0) {
            d *= -1; 
            n *= -1; 
        }
    }
    
    //Сложение
    private void add(int n, int d) {
        this.n = this.n * d + n * this.d;
        this.d *= d;
        reduce();
    }
    //Вычитание
    private void substract(int n, int d) {
        add(n * -1, d);
    }
    //Умножение
    private void multiply(int n, int d) {
        this.n *= n;
        this.d *= d;
        reduce();
    }
    //Деление
    private void divide(int n, int d) {
        this.n *= d;
        this.d *= n;
        reduce();
    }
    
    //Сложение с целым числом
    public void add(int n) {
        add(n, 1);
    }
    //Прибавить другую дробь
    public void add(Rational f) {
        add(f.n, f.d);
    }
    
    //Вычитание с целым числом
    public void substract(int n) {
        add(n * -1); 
        }
    //Отнять другую дробь
    public void substract(Rational f) {
        substract(f.n, f.d);
    }
    
    //Умножение с целым числом
    public void multiply(int n) {
        multiply(n, 1);
    }
    //Умножение с другой дробью
    public void multiply(Rational f) {
        multiply(f.n, f.d);
    }
    
    //Деление с целым числом
    public void divide(int n) throws ArithmeticException {
                if (n == 0) throw new ArithmeticException("Ошибка: Деление на 0");
        divide(n, 1);
    }
    //Деление с другой дробью
    public void divide(Rational f) throws ArithmeticException {
        if (f.n == 0) throw new ArithmeticException("Ошибка: Деление на 0");
        divide(f.n, f.d);
    }
    
    //Сравнить дробь на равенство с другой дробью 
    public boolean equals(Rational f) {
        return (n == f.n && d == f.d); //true - equals, false - notequals
    }
    //Сравнить дробь на с другой дробью
    public int compareTo(Rational f) {
        return (equals(f)) ? 0 : (n * f.d - f.n * d > 0) ? 1 : -1; //0 - равны, 1 - больше, -1 - меньше
    }
    
    public String toString() {
        return n + "/" + d;
    }
}

import java.util.ArrayList;
import java.util.List;
 
public class SetRational {
    private int cardinality; // Мощность множества
    private List<Rational> numbers; // Значения множества
 
    // Конструктор инициализируется только значением мощности множества, без инициализации значениями
    SetRational(int cardinality) {
        this.cardinality = cardinality;
        this.numbers = new ArrayList<>(cardinality);
    }
 
    // Конструктор инициализируется с заданными начальными значениями
    SetRational(List<Rational> numbers) {
        this.numbers = numbers;
        calculateCardinality();
    }
 
    // Получить все значения множества
    List<Rational> getNumbers() {
        return numbers;
    }
 
    // Задать значения множества
    void setNumbers(List<Rational> numbers) {
        this.numbers = numbers;
        calculateCardinality();
    }
 
    // Пересчитать мощность множества при изменении данных
    private void calculateCardinality() {
        this.cardinality = numbers.size();
    }
 
    // Получить мощность множества
    public int getCardinality() {
        return cardinality;
    }
 
    // Получить множество в виде строки
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Мощность множества: ")
                .append(cardinality)
                .append(". ")
                .append("Значения: {");
        for (int i = 0; i < numbers.size(); i++) {
            sb.append(numbers.get(i).toString());
            if (i != numbers.size() - 1) {
                sb.append(", ");
            } else {
                sb.append("}");
            }
        }
        return sb.toString();
    }
 
    // Проверить, принадлежит ли значение множеству
    boolean isNumberBelongToSet(Rational number) {
        return numbers.contains(number);
    }
    
    //Другая реализация поиска элемента в множестве (результат тот же)
    boolean In(Rational e) {
        for (int i = 0; i < cardinality; i++)
            if (numbers.get(i) == e) return true;
        return false;
    }
 
    // Объединить передаваемое множество с текущим
    void joinSet(SetRational newSet) {
        this.numbers.addAll(newSet.getNumbers());
        calculateCardinality();
    }
    
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            
            List<Rational> listOne = new ArrayList<>();
            List<Rational> listTwo = new ArrayList<>();
 
            for(int i = 1; i < 2; i++) {
                for(int j = 8; j > 0; j --) {
                    Rational l1 = new Rational(i, j);
                    listOne.add(l1);
                }
            }
            for(int i = 1; i < 2; i++) {
                for(int j = 4; j > 0; j --) {
                    Rational l2 = new Rational(j, i);
                    listTwo.add(l2);
                }
            }
     
            SetRational setOne = new SetRational(listOne); // Инициализируем множество значениями
            SetRational setTwo = new SetRational(listTwo);
     
            System.out.println("Первое множество: ");
            System.out.println(setOne.toString()); // Выводим множество на печать
     
            System.out.println("Второе множество: ");
            System.out.println(setTwo.toString()); // Выводим множество на печать
     
            setOne.joinSet(setTwo); // Объединяем множества
     
            System.out.println("Первое множество после объединения со вторым: ");
            System.out.println(setOne.toString()); // Выводим множество на печать
     
            Rational numberToCheck = new Rational(1, 1);
            if (setOne.isNumberBelongToSet(numberToCheck)) { // Проверяем, принадлежит ли число множеству
                System.out.println(numberToCheck + " принадлежит множеству.");
            } else {
                System.out.println(numberToCheck + " не принадлежит множеству.");
            }
            scanner.close();
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}