Collezioni Java sort()

Una delle funzioni più comuni di cui abbiamo bisogno come sviluppatori che si occupano di dati è l'ordinamento: essendo in grado di ordinare i nostri dati, possiamo ottimizzare i nostri algoritmi in modo che vengano eseguiti molto più velocemente e trovare i dati di cui hanno bisogno in una frazione del tempo necessario ci vorrebbe altrimenti. Nella lezione di oggi parleremo delle raccolte Java sort(). Come rapido esperimento mentale: immagina di cercare un nome nell'elenco di un'università. Potrebbero esserci decine di migliaia di studenti in questa scuola. Se l'elenco che ti è stato assegnato non era in ordine alfabetico, dovresti sfogliare ogni singola pagina e guardare molto attentamente per assicurarti di non aver saltato un solo nome da nessuna parte, finché non trovi finalmente il nome che stai cercando. D'altra parte, se l'elenco era in ordine alfabetico, non solo bisogna essere meno rigorosi nella ricerca, ma potresti facilmente saltare alla sezione dell'elenco con la stessa prima lettera e continuare a saltare le pagine a grandi balzi finché non atterri sulla persona che stavi cercando. Maggiore è il numero di dati con cui lavori, più importante è utilizzarli nel modo più efficace ed efficiente possibile. In questo articolo, esamineremo come ordinare qualsiasi implementazione List in Java (incluso ArrayList) utilizzando il metodo Collections sort.

Come ordinare un ArrayList in Java utilizzando il metodo di ordinamento delle raccolte Java

Parliamo del metodo Java Collections.sort. Il pacchetto java.util contiene molte utilità e pacchetti utili che vengono spesso utilizzati dagli sviluppatori, incluso ArrayList. Supponiamo di avere il seguente semplice programma:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

Si desidera poter stampare l'elenco dei colori, ma in ordine alfabetico. Come potresti farlo? Usando java.util.Collections, l'ordinamento è facile come una riga:

Collections.sort(colors);

Ta-da! L'elenco dei colori è stato ora ordinato sul posto. Se dovessi stampare l'elenco, come tale:

System.out.println(colors);

Quindi otterrai il seguente output:

[Blue, Green, Orange, Red]

Quanto è stato facile?! Sarebbe altrettanto facile usare Collections.sort() per ordinare in ordine crescente un elenco di numeri interi, float o qualsiasi altro tipo di dati semplice per quella materia. Ma cosa succede se si desidera ordinare in ordine decrescente? Ci sono sicuramente casi in cui questo ha senso: immagina di avere un elenco di punteggi dei test per una determinata classe e di voler capire chi sono gli studenti con i punteggi migliori. Sarebbe molto più sensato ordinare l'elenco in ordine decrescente (prima i punteggi più alti), in modo che le risposte che stai cercando siano proprio in cima. Per fortuna, Collections.sort() viene sovrascritto con un secondo parametro facoltativo, che ti consente di fare proprio questo:

sort(List l, Comparator c)

Ma cos'è un comparatore? Bene, un comparatore è semplicemente una funzione che confronta due input e restituisce un numero che rappresenta quale input viene prima. Se stai ordinando un ArrayList di tipi di dati primitivi, Java Collections ti fornisce già un comparatore reverseOrder(). Può essere chiamato così:

Collections.sort(colors, Collections.reverseOrder());

Ora, i colori sono stati ordinati al contrario sul posto in modo che se li stampassi, otterresti il ​​seguente output:

[Red, Orange, Green, Blue]

Come utilizzare le raccolte per ordinare i tipi di dati non primitivi in ​​Java

Finora, hai visto che ordinare ArrayList di stringhe o interi in Java utilizzando il metodo Collections.sort() è facile come una riga di codice. Ma spesso, i tuoi ArrayList memorizzeranno tipi di dati non primitivi. Quando lavori con dati che hanno attributi più complessi, vorrai scrivere classi per rappresentare questi oggetti e come verranno confrontati tra loro usando i loro attributi. Per esplorare un esempio di ciò, rivisitiamo l'esempio dell'ordinamento di un elenco di colori, ma questa volta, invece di ordinare le stringhe, ordineremo gli oggetti Color. La nostra classe Color di base potrebbe essere simile a questa:

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

Per rendere la nostra classe Color compatibile con Collections.sort(), in modo che Collections possa capire come confrontare e ordinare gli oggetti Color, dobbiamo apportare due piccole modifiche:

1. rendere Color un oggetto comparabile (aggiungere implementa Comparable<Object>)
2. sovrascrivere il metodo compareTo nella classe (sovrascrivere public int compareTo(Object o))

Con queste modifiche, la nostra classe ora si presenta così:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

Si noti che il metodo compareTo di Color chiama semplicemente il metodo compareTo di String; l'ordinamento sarà effettuato in ordine alfabetico. Se volessimo ordinare per valore rosso in ordine crescente, ad esempio, potremmo sostituire l'istruzione return con return this.r - cr; (se volessimo ordinare per valore verde in ordine decrescente, sarebbe return cg - this.g;). Ora, se chiamiamo

Collections.sort(colors);

su un ArrayList of Colors anziché solo su Strings, funzionerebbe perché Collections comprende come confrontare gli oggetti Color. Se non vuoi che il tuo oggetto implementi Comparable<Object>, puoi in alternativa scrivere un comparatore per la tua classe e passarlo nel metodo Collections.sort() a 2 parametri. Un comparatore esegue l'override di un metodo public int compare(Object one, Object two) e il metodo Collections.sort() lo utilizza per confrontare gli oggetti durante l'ordinamento. Un esempio di comparatori SortByName e SortByRed è implementato di seguito:

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

Con questo, ora puoi chiamare

Collections.sort(colors, new SortByName());

senza che la classe Color implementi effettivamente Comparable e funzionerà comunque. A volte, vedrai che questo viene fatto in linea, usando le funzioni lambda. Una funzione lambda è essenzialmente una funzione senza nome che puoi definire all'interno della riga di codice, che la chiama. Sono utili quando hai solo bisogno di chiamare una funzione per un'istanza specifica e non vuoi definire un'intera funzione separata altrove. Il comparatore SortByName potrebbe essere definito in linea, utilizzando una funzione lambda, come questa:

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

Come avrai intuito, (a, b) rappresenta i parametri delle funzioni lambda (i due oggetti da confrontare). Il -> significa che ciò che segue è una definizione di funzione lambda. Questo è tutto! Ora hai visto i metodi più popolari per ordinare ArrayList in Java usando il pacchetto Collections.