Utilizzo delle coppie in Java

1. Panoramica

In questo rapido articolo, discutiamo dell'utilissimo concetto di programmazione noto come coppia . Le coppie forniscono un modo conveniente per gestire una semplice associazione chiave-valore e sono particolarmente utili quando vogliamo restituire due valori da un metodo.

Una semplice implementazione di una coppia è disponibile nelle librerie Java principali. Oltre a ciò, alcune librerie di terze parti come Apache Commons e Vavr hanno esposto questa funzionalità nelle rispettive API.

2. Implementazione Java di base

2.1. La classe di coppia

La classe Pair può essere trovata nel pacchetto javafx.util . Il costruttore di questa classe accetta due argomenti, una chiave e il suo valore corrispondente:

Pair pair = new Pair(1, "One"); Integer key = pair.getKey(); String value = pair.getValue(); 

Questo esempio illustra una semplice mappatura da intero a stringa utilizzando il concetto di coppia.

Come mostrato, la chiave nell'oggetto coppia viene recuperata invocando un metodo getKey () mentre il valore viene recuperato chiamando getValue ().

2.2. AbstractMap.SimpleEntry e AbstractMap.SimpleImmutableEntry

SimpleEntry è definita come una classe nidificata all'interno della classe AbstractMap . Per creare un oggetto di questo tipo possiamo fornire una chiave e un valore al costruttore:

AbstractMap.SimpleEntry entry = new AbstractMap.SimpleEntry(1, "one"); Integer key = entry.getKey(); String value = entry.getValue();

È possibile accedere alla chiave e al valore tramite i metodi standard getter e setter.

Inoltre, la classe AbstractMap contiene anche una classe nidificata che rappresenta una coppia immutabile: la classe SimpleImmutableEntry :

AbstractMap.SimpleImmutableEntry entry = new AbstractMap.SimpleImmutableEntry(1, "one");

Funziona in modo simile alla classe coppia mutevole, tranne per il fatto che il valore della coppia non può essere modificato. Il tentativo di eseguire questa operazione risulterà in un'eccezione UnsupportedOperationException .

3. Apache Commons

Nella libreria Apache Commons, possiamo trovare la classe Pair nel pacchetto org.apache.commons.lang3.tuple . Questa è una classe astratta, quindi non può essere istanziata direttamente.

Possiamo trovare qui, due sottoclassi che rappresentano coppie immutabili e mutabili: Imm utablePair e MutablePair.

Entrambe le implementazioni hanno accesso ai metodi key / value getter / setter:

ImmutablePair pair = new ImmutablePair(2, "Two"); Integer key = pair.getKey(); String value = pair.getValue();

Non sorprende, un tentativo per richiamare setValue () sui ImmutablePair risultati in un UnsupportedOperationException.

Ma l'operazione è del tutto valida per un'implementazione mutabile:

Pair pair = new MutablePair(3, "Three"); pair.setValue("New Three"); 

4. Vavr

Nella libreria Vavr, la funzionalità di coppia è fornita dalla classe immutabile Tuple2 :

Tuple2 pair = new Tuple2(4, "Four"); Integer key = pair._1(); String value = pair._2(); 

In questa implementazione, non possiamo modificare l'oggetto dopo la creazione, quindi i metodi di mutazione restituiscono una nuova istanza che include la modifica fornita:

tuplePair = pair.update2("New Four"); 

5. Alternativa I - Classe contenitore semplice

In base alle preferenze dell'utente o in assenza di una qualsiasi delle librerie di cui sopra, una soluzione alternativa standard per la funzionalità di coppia è la creazione di una semplice classe contenitore che racchiude i valori restituiti desiderati.

Il più grande vantaggio qui è la capacità di fornire il nostro nome che aiuta a evitare di avere la stessa classe che rappresenta diversi oggetti di dominio:

public class CustomPair { private String key; private String value; // standard getters and setters }

6. Alternativa II - Array

Un'altra soluzione alternativa comune consiste nell'usare un semplice array con due elementi per ottenere risultati simili:

private Object[] getPair() { // ... return new Object[] {key, value}; }

In genere, la chiave si trova all'indice zero dell'array mentre il valore corrispondente si trova all'indice uno.

7. Conclusione

In questo tutorial, abbiamo discusso il concetto di coppie in Java e le diverse implementazioni disponibili nel core Java e in altre librerie di terze parti.

Come sempre, puoi trovare il codice che supporta questo tutorial su GitHub.