Confronti timestamps

[Javino89]

Salve.

Devo confrontare due timestamps in questo formato: HH:mm:ss.SSS e vedere se posso "abbinarli".

Io la prima cosa che faccio è vedere se sono identici considerando tutti i campi.

La seconda cosa che faccio è rimuovere i millisecondi e vedere se sono identici considerando
i campi rimanenti.

A questo punto vorrei vedere se sono molto vicini, cioè uno è in mezzo all'altro +/- 30 secondi ad esempio. (Tecnicamente prima di questo dovrei verificare nell'intorno dei millisecondi se voglio essere più preciso).

Il problema è che quando vado a sommare/sottrarre i secondi, questa operazione sembra rovinarmi tutte le date precedenti.

Questo è il codice. Magari c'è un modo più semplice e pulito per ottenere la stessa cosa (ma soprattutto corretto).

public static boolean match(String casas, String gtruth) throws ParseException {
        
        // Calendar per casas TOTALE
        Date casasHour = new SimpleDateFormat("HH:mm:ss.SSS").parse(casas);
        Calendar casasCalendar = new GregorianCalendar();
        casasCalendar.setTime(casasHour);


        // Calendar per ground TOTALE
        Date gtHour = new SimpleDateFormat("HH:mm:ss.SSS").parse(gtruth);
        Calendar gtCalendar = new GregorianCalendar();
        gtCalendar.setTime(gtHour);
        
        // Calendar per casas SENZA millisecondi
        String casasNoMilliseconds = casas.substring(0, 8);
        Date cnmDate = new SimpleDateFormat("HH:mm:ss").parse(casasNoMilliseconds);
        Calendar cnmCalendar = new GregorianCalendar();
        cnmCalendar.setTime(cnmDate);
        
        // Calendar per ground truth SENZA millisecondi
        String gtNoMilliseconds = gtruth.substring(0, 8);
        Date gtnmDate = new SimpleDateFormat("HH:mm:ss").parse(gtNoMilliseconds);
        Calendar gtnmCalendar = new GregorianCalendar();
        gtnmCalendar.setTime(gtnmDate);
        
        // +/- 30 Secondi al timestamp di casas
        Date plus30Date = new SimpleDateFormat("HH:mm:ss").parse(casasNoMilliseconds);
        Calendar cnmCalendarPlus30 = new GregorianCalendar();
        cnmCalendarPlus30.setTime(plus30Date);
        cnmCalendarPlus30.add(Calendar.SECOND, 30);
        Date plus30 = cnmCalendarPlus30.getTime();
        
        Date minus30Date = new SimpleDateFormat("HH:mm:ss").parse(casasNoMilliseconds);
        Calendar cnmCalendarMinus30 = new GregorianCalendar();
        cnmCalendarMinus30.setTime(minus30Date);
        cnmCalendarMinus30.add(Calendar.SECOND, -30);
        Date minus30 = cnmCalendarMinus30.getTime();
        
        if(casasCalendar.equals(gtCalendar)) { // matching totale --> ore:minuti:secondi.millisecondi
            return true;
        } 
        else if(cnmCalendar.equals(gtnmCalendar)) { // matching ore:minuti:secondi
            return true;
        }
        else if(minus30.before(gtnmDate) && plus30.after(gtnmDate)) { // matching ore:minuti:secondi +/- 30 secondi
            return true;
        }
        else {
            return false;
        }
    }

Non capisco perché se considero l'ultimo else if, ciò che prima veniva matchato nel penultimo, viene matchato nell'ultimo con i secondi cambiati... Mi sto a perde

-----
Ok ho capito almeno qual è il problema:

I timestamp che non combaciano precisi (che vengono PRIMA di quelli che verrebbero matchati con precisione), vengono erroneamente matchati a causa di quel +30/-30 secondi.