0Pricing
Java Academy · Lezione

Comparator e ordinamento con lambda

Crei istanze di Comparator con espressioni lambda e i metodi factory Comparator.comparing.

Comparator e ordinamento con lambda è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Ordinamento con Comparator e lambda

Comparator<T> definisce un ordinamento esterno per gli oggetti. A differenza di Comparable, può creare tutti i Comparator necessari senza modificare la classe.

Creare Comparator

Crei un Comparator con una lambda o un riferimento a metodo e lo passi ai metodi di ordinamento.

import java.util.*;

record Product(String name, double price, int stock) {}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse",    29.99, 50),
    new Product("Laptop",  999.00, 5),
    new Product("USB Hub",  24.99, 100)
));

// Lambda comparator
products.sort((a, b) -> Double.compare(a.price(), b.price()));
System.out.println(products);
// [USB Hub, Mouse, Laptop] (by price ascending)

Factory Comparator.comparing

Comparator.comparing(keyExtractor) crea un Comparator a partire da una funzione di estrazione della chiave, in modo più pulito rispetto alle lambda non strutturate.

import java.util.Comparator;

Comparator<Product> byPrice = Comparator.comparingDouble(Product::price);
Comparator<Product> byName  = Comparator.comparing(Product::name);
Comparator<Product> byStock = Comparator.comparingInt(Product::stock);

products.sort(byPrice);
System.out.println(products); // sorted by price ascending

products.sort(byName);
System.out.println(products); // sorted alphabetically

reversed()

reversed() inverte l'ordinamento di qualsiasi comparator.

import java.util.Comparator;

Comparator<Product> mostExpensiveFirst =
    Comparator.comparingDouble(Product::price).reversed();

products.sort(mostExpensiveFirst);
System.out.println(products);
// [Laptop($999.0), Mouse($29.99), USB Hub($24.99)]

naturalOrder e reverseOrder

Comparator.naturalOrder() utilizza Comparable della classe. reverseOrder() lo inverte.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));

names.sort(Comparator.naturalOrder());
System.out.println(names); // [Alice, Bob, Charlie]

names.sort(Comparator.reverseOrder());
System.out.println(names); // [Charlie, Bob, Alice]

// Sort integers descending
List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9));
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 2, 1]

Comparator sicuri rispetto ai valori null

Comparator.nullsFirst() e nullsLast() gestiscono gli elementi null senza generare NPE.

import java.util.*;

List<String> withNulls = new ArrayList<>(Arrays.asList("Charlie", null, "Alice", null, "Bob"));

withNulls.sort(Comparator.nullsLast(Comparator.naturalOrder()));
System.out.println(withNulls); // [Alice, Bob, Charlie, null, null]

withNulls.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(withNulls); // [null, null, Alice, Bob, Charlie]

Stream sorted() con Comparator

Utilizzi l'operazione intermedia sorted() degli stream con un Comparator per ordinare secondo uno stile funzionale.

import java.util.stream.*;

record Employee(String name, String dept, double salary) {}

List<Employee> employees = List.of(
    new Employee("Alice",   "Engineering", 95000),
    new Employee("Bob",     "Marketing",   72000),
    new Employee("Charlie", "Engineering", 105000)
);

// Sort by salary descending in a stream pipeline
employees.stream()
    .sorted(Comparator.comparingDouble(Employee::salary).reversed())
    .forEach(e -> System.out.println(e.name() + ": $" + e.salary()));
// Charlie: $105000.0 / Alice: $95000.0 / Bob: $72000.0

Comparator come lambda o riferimento a metodo

I riferimenti a metodo rendono i comparator ancora più concisi quando la funzione di estrazione della chiave è un semplice getter.

// Lambda
Comparator<String> c1 = (a, b) -> a.length() - b.length();

// Comparator.comparing with lambda
Comparator<String> c2 = Comparator.comparing(s -> s.length());

// Comparator.comparingInt with method reference (cleanest)
Comparator<String> c3 = Comparator.comparingInt(String::length);

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(c3);
System.out.println(words); // [fig, kiwi, apple, banana]

Comparator con stato

Sebbene i comparator debbano generalmente essere privi di stato, può iniettare la configurazione tramite i parametri del costruttore.

class DistanceComparator implements Comparator<String> {
    private final String target;
    DistanceComparator(String target) { this.target = target; }

    @Override
    public int compare(String a, String b) {
        return Integer.compare(distance(a), distance(b));
    }

    private int distance(String s) { return Math.abs(s.length() - target.length()); }
}

List<String> words = new ArrayList<>(List.of("Java", "Go", "Python", "C", "Kotlin"));
words.sort(new DistanceComparator("Java"));
System.out.println(words); // closest length to "Java" first

Ordinamento personalizzato per un catalogo di prodotti

Ordinare un catalogo di prodotti prima in base alla disponibilità, poi al prezzo e infine al nome.

import java.util.*;

record Item(String name, double price, boolean inStock) {}

List<Item> catalog = List.of(
    new Item("Laptop",  999.0,  true),
    new Item("Case",     19.99, false),
    new Item("Mouse",    29.99, true),
    new Item("Monitor", 349.0,  true)
);

Comparator<Item> catalogSort =
    Comparator.comparing(Item::inStock).reversed()     // in-stock first
    .thenComparingDouble(Item::price)                  // then cheapest
    .thenComparing(Item::name);                        // then alphabetical

catalog.stream().sorted(catalogSort)
    .forEach(i -> System.out.printf("%s %-15s $%.2f%n",
        i.inStock() ? "[Y]" : "[N]", i.name(), i.price()));

Arrays.sort con Comparator

Arrays.sort(array, comparator) ordina gli array di oggetti con un comparator personalizzato.

String[] words = {"banana", "fig", "apple", "kiwi", "cherry"};

// Sort by length, then alphabetically for same length
Arrays.sort(words,
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder()));

System.out.println(Arrays.toString(words));
// [fig, kiwi, apple, banana, cherry]

Verifica rapida

Che cosa produce Comparator.comparingDouble(Product::price).reversed()?

Riepilogo: ordinamento con Comparator e lambda

Punti chiave:

  • Comparator<T> definisce un ordinamento esterno: ne può utilizzare quanti ne servono
  • Comparator.comparing(keyExtractor) crea comparator a partire dai getter
  • reversed() inverte qualsiasi comparator; naturalOrder()/reverseOrder() per i tipi Comparable
  • nullsFirst() e nullsLast() gestiscono gli elementi null in sicurezza
  • Utilizzi sorted(comparator) nelle pipeline Stream per un ordinamento secondo uno stile funzionale
  • I comparator possono essere passati a sort(), Arrays.sort(), TreeSet e TreeMap

Domande Frequenti

La lezione «Comparator e ordinamento con lambda» è gratuita?

Sì — il testo completo di «Comparator e ordinamento con lambda» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Comparator e ordinamento con lambda»?

Crei istanze di Comparator con espressioni lambda e i metodi factory Comparator.comparing. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Comparator e ordinamento con lambda»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. L'interfaccia Comparable
  2. Comparator e ordinamento con lambda
  3. Ordinamento per più chiavi con thenComparing
  4. Ordinare array e collezioni nella pratica
← Torna a Java Academy