Java Academy · Lezione

Ordinare array e collezioni nella pratica

Applichi l'ordinamento a liste di prodotti, classifiche e calendari di eventi utilizzando esempi reali.

Lezione 4 di 414 passaggi

Ordinare array e collezioni nella pratica è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 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 nella pratica

Questa lezione applica le tecniche di ordinamento a scenari realistici: cataloghi di prodotti, classifiche, pianificazione di eventi e posizionamento dei risultati di ricerca.

Arrays.sort per array di primitivi

Arrays.sort() per gli array di tipi primitivi utilizza un quicksort a doppio pivot, estremamente veloce, con complessità media O(n log n).

int[] scores = {45, 90, 78, 62, 88, 33};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [33, 45, 62, 78, 88, 90]

// Sort a range only
int[] data = {9, 3, 7, 1, 5};
Arrays.sort(data, 1, 4); // sort indices 1-3 only
System.out.println(Arrays.toString(data)); // [9, 1, 3, 7, 5]

Arrays.sort per array di oggetti

Per gli array di oggetti, Arrays.sort() utilizza TimSort, che è stabile. È possibile fornire un Comparator per definire un ordinamento personalizzato.

String[] names = {"Charlie", "Alice", "Bob", "Diana"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Alice, Bob, Charlie, Diana]

// Custom order: by length, then alphabetically
Arrays.sort(names, Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println(Arrays.toString(names)); // [Bob, Alice, Diana, Charlie]

Collections.sort e List.sort

Entrambi ordinano List sul posto. List.sort() è il metodo moderno da preferire.

List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9, 3));

// Old way
Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

// Modern way (same result)
nums.sort(Comparator.naturalOrder());
nums.sort(null); // null means natural order

// Descending
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 3, 2, 1]

Stream.sorted() per uno stile funzionale

Utilizzi stream().sorted() quando costruisce una pipeline: produce un nuovo stream ordinato senza modificare la sorgente.

List<String> cities = List.of("Tokyo", "London", "New York", "Paris", "Sydney");

// Sorted stream — source list unchanged
List<String> sorted = cities.stream()
    .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
    .collect(Collectors.toList());

System.out.println(sorted);
// [Paris, Tokyo, London, Sydney, New York]

Ordinamento di una Map per valore

Una domanda classica dei colloqui tecnici: ordinare una Map in base ai suoi valori utilizzando stream e Comparator.

import java.util.*;
import java.util.stream.*;

Map<String, Integer> scores = Map.of(
    "Alice", 95, "Bob", 87, "Charlie", 92, "Diana", 87
);

Map<String, Integer> sorted = scores.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder())
        .thenComparing(Map.Entry.comparingByKey()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey, Map.Entry::getValue,
        (v1, v2) -> v1, LinkedHashMap::new));

sorted.forEach((k, v) -> System.out.println(k + ": " + v));
// Alice: 95 / Charlie: 92 / Bob: 87 / Diana: 87

Ordinamento con Collator per la localizzazione

Per ordinare le stringhe tenendo conto della lingua, utilizzi java.text.Collator invece di String.compareTo: gestisce accenti, maiuscole e minuscole e l'ordinamento specifico della lingua.

import java.text.*;
import java.util.*;

List<String> names = new ArrayList<>(List.of("éclair", "apple", "Über", "banana"));

Collator collator = Collator.getInstance(Locale.GERMAN);
names.sort(collator);
System.out.println(names); // locale-aware sort

Ordinamento di oggetti con più criteri

Ordinamento di prodotti e-commerce: prima quelli disponibili, poi per prezzo in offerta, quindi per valutazione e infine per nome.

record Product(String name, double price, double salePrice, double rating, boolean inStock) {}

Comparator<Product> bestFirst = Comparator
    .comparing(Product::inStock).reversed()           // in-stock first
    .thenComparingDouble(Product::salePrice)          // cheapest sale price
    .thenComparingDouble(Product::rating).reversed()  // highest rated
    .thenComparing(Product::name);                    // alphabetical tiebreak

Ordinamento degli eventi per data e ora

Ordinamento cronologico di un calendario di eventi utilizzando i tipi java.time, che implementano Comparable.

import java.time.*;
import java.util.*;

record Event(String title, LocalDate date, LocalTime time) {}

List<Event> schedule = new ArrayList<>(List.of(
    new Event("Workshop",  LocalDate.of(2024,7,15), LocalTime.of(9, 0)),
    new Event("Keynote",   LocalDate.of(2024,7,14), LocalTime.of(10, 30)),
    new Event("Lunch Talk",LocalDate.of(2024,7,15), LocalTime.of(12, 0)),
    new Event("Hackathon", LocalDate.of(2024,7,14), LocalTime.of(9, 0))
));

schedule.sort(Comparator.comparing(Event::date).thenComparing(Event::time));
schedule.forEach(e -> System.out.println(e.date() + " " + e.time() + " " + e.title()));

Elementi Top-N con l'ordinamento

Per trovare in modo efficiente i primi N elementi, ordini in senso decrescente e prenda i primi N, oppure utilizzi una PriorityQueue per dataset di grandi dimensioni.

List<Integer> values = List.of(42, 17, 88, 5, 73, 56, 91, 33);

// Simple approach: sort descending, take first 3
List<Integer> top3 = values.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
System.out.println(top3); // [91, 88, 73]

// For very large datasets: PriorityQueue min-heap approach is O(n log k)
import java.util.PriorityQueue;
PriorityQueue<Integer> heap = new PriorityQueue<>(3);
for (int v : values) {
    heap.offer(v);
    if (heap.size() > 3) heap.poll();
}
System.out.println(new TreeSet<>(heap).descendingSet()); // [73, 88, 91]

Deduplicazione con l'ordinamento

Dopo l'ordinamento, i duplicati sono adiacenti: è possibile rilevarli con complessità O(n).

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr); // sort first

// Remove duplicates in O(n) after sorting
int[] unique = Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique)); // [1, 2, 3, 4, 5, 6, 9]

Prestazioni: scelta del metodo di ordinamento

Scelta dell'approccio di ordinamento più adatto:

Array di primitivi: Arrays.sort(), il più veloce, con quicksort sul posto
Array o liste di oggetti con Comparable: Collections.sort() oppure List.sort(null)
Ordinamenti multipli: catene di Comparator con thenComparing
Primi N elementi da uno stream di grandi dimensioni: PriorityQueue oppure Stream.sorted().limit(N)

Verifica rapida

Quale algoritmo di ordinamento utilizza Java per gli array di oggetti in Arrays.sort()?

Rispondi nella lezione interattiva

Riepilogo: ordinamento di array e collezioni nella pratica

Punti chiave:

Arrays.sort() utilizza un quicksort a doppio pivot per i primitivi e TimSort, stabile, per gli oggetti
List.sort(comparator) e Collections.sort() utilizzano entrambi TimSort, stabile
stream().sorted() produce un nuovo stream ordinato senza modificare la sorgente
Per ordinare una Map per valore: entrySet().stream().sorted(Map.Entry.comparingByValue())
Utilizzi Collator per ordinare le stringhe tenendo conto della lingua
Per i primi N elementi da una grande quantità di dati, una PriorityQueue con capacità k è più efficiente di un ordinamento completo

Gratis per iniziare

Impara Java con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 104
Lezioni: 374

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Ordinare array e collezioni nella pratica» è gratuita?

Sì — il testo completo di «Ordinare array e collezioni nella pratica» è 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 «Ordinare array e collezioni nella pratica»?

Applichi l'ordinamento a liste di prodotti, classifiche e calendari di eventi utilizzando esempi reali. 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 4 di 4.

Quanto tempo richiede la lezione «Ordinare array e collezioni nella pratica»?

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

L'interfaccia Comparable
Comparator e ordinamento con lambda
Ordinamento per più chiavi con thenComparing
Ordinare array e collezioni nella pratica

← Torna a Java Academy