Java - Il mio comparatore personale

Nel tutorial precedente abbiamo ordinato una lista di oggetti di tipo ContactExample implementando un compratore al volo direttamente nel codice e specificando quindi il metodo compare che manipolasse le proprietà del nostro oggetto.

L'uso di classi private interne ad un'altra classe non è inusuale. Per quanto possa sembrare che vada contro la logica stessa della programmazione ad oggetti, in questi casi la cosa ha senso perché il provider dei dati così come il comparatore, era strettamente legato all'oggetto di manipolazione ovvero ContactExample.
E' infatti inutile creare una classe una classe esterna di comparazione legata ad un oggetto se questo verrà usato solo nella Iterator di chi manipola l'oggetto stesso.

In pratica è come creare una classe per gestire il cambio shimano su una bici che però può essere solo il modello X25 della Bianchi. Tanto vale creare una classe privata dentro la classe X25 perché la logica di riutilizzo dell'oggetto Java si perde con la restrizione dell'oggetto stesso.

E' però interessante vedere come avremmo dovuto fare nel caso masochistico in cui volessimo esternare l'oggetto comparatore.

Ecco la classe risultante:

package it.trewps.heavyexamples.web;

import java.util.Comparator;

public class ContactExampleComparator implements Comparator<ContactExample> {
    
    Boolean ascendingOrder = true;
    String    probe           = "name";
    
    public ContactExampleComparator(Boolean ascending, String probe){
        this.ascendingOrder = ascending;
        this.probe            = probe;
    }
    
    @Override
    public int compare(ContactExample o1, ContactExample o2) {
       int sortDirection = (this.ascendingOrder) ? 1 : -1;
       if ("name".equals(this.probe)){
           return sortDirection * (o1.getContactName().compareTo(o2.getContactName())); 
       }
       if ("surname".equals(this.probe)){
           return sortDirection * (o1.getContactSurname().compareTo(o2.getContactSurname())); 
       }
       return sortDirection  * (o1.getContactEmail().compareTo(o2.getContactEmail()));
    }

}

La prima cosa che salta all'occhio è il fatto che al costruttore occorre passare due parametri che prima erano gratuiti. Implementando infatti la classe dentro l'altro, questa aveva lo scope di tutte le variabili tra cui il metodo getSort().
Qui invece devo passargliele dall'esterno perché questa classe tecnicamente è stand-alone. I due parametri indicano quindi l'etichetta su cui sto ordinando (il famoso "cippalippa") ed il tipo di ordinamento (ascendente o discendente).

Il metodo compare è invece identico al precedente con ovviamente solo il cambio di nome variabili.

Lo stretto legame tra questo comparatore e l'oggetto è anche esplicitato nel prototipo che come vediamo implementa Comparator ma legato al tipo ContactExample.