Scarica Confronto tra oggetti e classi di utilità in Java e più Schemi e mappe concettuali in PDF di Programmazione Java solo su Docsity!
Java — Confronto tra Oggetti e Classi di
Utilità
Comparable, Comparator, Collections, Arrays
Argomenti trattati
- Ordinamento di Oggetti
- Interfaccia Comparable
- Interfaccia Comparator
- La classe di utilità Collections
- La classe di utilità Arrays
1. Ordinamento di Oggetti
Con il termine ordinamento si intende la disposizione di oggetti all'interno di una collezione generica in base a una sequenza crescente o decrescente rispetto a determinati criteri.
Quando si aggiungono elementi a un ArrayList, questi vengono memorizzati nell'ordine di inserimento. Se si desidera un ordinamento basato su criteri diversi, occorre definire esplicitamente la logica di confronto.
Tale logica può risiedere in due posti distinti:
- All'interno dell'oggetto stesso → si usa l'interfaccia Comparable.
- In un oggetto esterno dedicato → si usa l'interfaccia Comparator.
Esempio pratico: si vuole ordinare una lista di oggetti Persona (con attributi nome, cognome, età) prima per cognome in ordine alfabetico e, in caso di parità, per nome. Questo scenario sarà usato come filo conduttore nelle sezioni seguenti.
2. Interfaccia Comparable
Definizione e contratto
L'interfaccia Comparable appartiene al package java.lang (importata automaticamente) e definisce un unico metodo astratto: compareTo. Una classe che implementa questa interfaccia stabilisce un ordine naturale per i propri oggetti.
package java.lang; public interface Comparable { public int compareTo(T other); }
Valore restituito da compareTo
Valore restituito Significato
Negativo (< 0) L'oggetto corrente (this) è minore di other → viene prima nell'ordinamento
Zero (= 0) I due oggetti sono equivalenti ai fini dell'ordinamento
Positivo (> 0) L'oggetto corrente (this) è maggiore di other → viene dopo nell'ordinamento
Comparable nella libreria standard
L'interfaccia Comparable è implementata da centinaia di classi della libreria Java standard. Ad esempio la classe String è dichiarata come:
public final class String implements Comparable { ... }
Questo significa che le stringhe supportano nativamente il confronto lessicografico tramite compareTo.
Esempio: classe Persona con ordine naturale per cognome/nome
public class Persona implements Comparable { private String nome; private String cognome; private int eta; public Persona(String nome, String cognome) { this.nome = nome; this.cognome = cognome; } // getter e setter omessi per brevità @Override public int compareTo(Persona p) { // Criterio primario: cognome if (this.cognome.compareTo(p.cognome) == 0) { // Criterio secondario: nome return this.nome.compareTo(p.nome); } return this.cognome.compareTo(p.cognome); } } Come funziona: il metodo compareTo è chiamato sull'oggetto corrente (this) ricevendo come parametro un altro oggetto della stessa classe. Poiché la classe String implementa già Comparable, è possibile delegare il confronto direttamente a String.compareTo().
Nota: la forma compatta con sottrazione è valida solo quando i valori sono abbastanza piccoli da non causare overflow intero. Per confrontare valori numerici in modo sicuro si può usare Integer.compare(p1.getEta(), p2.getEta()).
Riepilogo comparativo: Comparable vs Comparator
Caratteristica Comparable Comparator
Package java.lang^ java.util
Metodo da implementare compareTo(T^ other)^ compare(T^ o1,^ T^ o2)
Numero di parametri 1 (si confronta con this)
2 (entrambi passati)
Posizione del codice Nella classe da ordinare
In una classe esterna
Ordinamenti supportati Uno solo (ordine naturale)
Multipli (uno per classe)
Modifica della classe originale
Sì, necessaria No
4. La classe di utilità Collections
La classe Collections (package java.util) contiene esclusivamente metodi statici che operano su liste e collezioni generiche. Non va confusa con l'interfaccia Collection (senza 's').
Metodi principali
Firma Descrizione
sort(List list) (^) Ordina la lista in ordine crescente secondo l'ordine naturale (gli elementi devono implementare Comparable)
sort(List list, Comparator c)
Ordina la lista secondo il criterio definito dal Comparator c
binarySearch(List list, T key)
Ricerca binaria nella lista (deve essere già ordinata). Restituisce l'indice o -1. Gli elementi devono essere Comparable
binarySearch(List list, T key, Comparator c)
Ricerca binaria usando il Comparator c (la lista deve essere ordinata con lo stesso Comparator)
max(Collection coll) (^) Restituisce l'elemento massimo secondo l'ordine naturale (Comparable)
max(Collection coll, Comparator comp)
Restituisce l'elemento massimo secondo il Comparator specificato
min(Collection coll) (^) Restituisce l'elemento minimo secondo l'ordine naturale (Comparable)
min(Collection coll, Comparator comp)
Restituisce l'elemento minimo secondo il Comparator specificato
shuffle(List list) (^) Mescola casualmente gli elementi della lista
copy(List dest, List src)
Copia tutti gli elementi di src in dest (dest deve avere dimensione >= src)
Esempio d'uso: ordinamento con sort
List persone = new ArrayList<>(); persone.add(new Persona("Mario", "Rossi")); persone.add(new Persona("Anna", "Bianchi")); // Ordina usando l'ordine naturale (Comparable: cognome, poi nome) Collections.sort(persone); // Ordina usando un Comparator alternativo (per età) Collections.sort(persone, new PersonaComparator());
5. La classe di utilità Arrays
La classe Arrays (package java.util) è l'equivalente di Collections per gli array ordinari. Contiene metodi statici per ordinare, cercare e manipolare array. Il simbolo T nei metodi indica un tipo generico che implementa Comparable.
Metodi principali
Firma Descrizione
sort(T[] a) (^) Ordina l'array in ordine crescente secondo l'ordine naturale (Comparable)
sort(T[] a, Comparator c) (^) Ordina l'array secondo il criterio definito dal Comparator c
binarySearch(T[] a, T key) (^) Ricerca binaria nell'array (deve essere già ordinato). Restituisce l'indice o -
binarySearch(T[] a, T key, Comparator c)
Ricerca binaria usando il Comparator c (array ordinato con lo stesso Comparator)
Esempio d'uso: ordinamento e ricerca su array
Persona[] arr = { new Persona("Mario", "Rossi"), new Persona("Anna", "Bianchi") }; // Ordina secondo l'ordine naturale (Comparable) Arrays.sort(arr); // Ricerca binaria dopo l'ordinamento int idx = Arrays.binarySearch(arr, new Persona("Anna", "Bianchi")); // Ordina con Comparator (per età) Arrays.sort(arr, new PersonaComparator()); // Ricerca binaria con lo stesso Comparator int idx2 = Arrays.binarySearch(arr, target, new PersonaComparator());
Collections vs Arrays — riepilogo comparativo
Aspetto Collections Arrays
Package java.util^ java.util
Opera su List e Collection Array ordinari ([])
Ordinamento sort(List, ...)^ sort(T[],^ ...)
Ricerca binaria binarySearch(List, ...)
binarySearch(T[], ...)
Max/Min Sì (max, min) Non direttamente
Shuffle casuale Sì (shuffle) No
Prerequisito ricerca Lista ordinata con stesso criterio
Array ordinato con stesso criterio
Regola pratica: usare Collections quando si lavora con ArrayList, LinkedList o altre implementazioni di List/Collection. Usare Arrays quando si lavora con array tradizionali. In entrambi i casi il prerequisito della ricerca binaria è che la struttura dati sia già ordinata con lo stesso criterio (Comparable o Comparator) usato per la ricerca.
