Använda par i Java

1. Översikt

I den här snabba artikeln diskuterar vi det mycket användbara programmeringskonceptet som kallas ett par . Par ger ett bekvämt sätt att hantera enkel nyckel till värdeförening och är särskilt användbara när vi vill returnera två värden från en metod.

En enkel implementering av ett par är tillgänglig i Java-biblioteken. Utöver det har vissa tredjepartsbibliotek som Apache Commons och Vavr exponerat denna funktionalitet i sina respektive API: er.

2. Core Java Implementation

2.1. Den Pair Class

Den Pair klass kan hittas i javafx.util paketet. Konstruktören för denna klass tar två argument, en nyckel och dess motsvarande värde:

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

Detta exempel illustrerar ett enkelt kartläggning av heltal till sträng med hjälp av Pair-konceptet.

Såsom visas, nyckeln i paret är föremålet hämtas genom att åberopa en getKey () metoden medan värdet hämtas genom att anropa getValue ().

2.2. AbstractMap.SimpleEntry och AbstractMap.SimpleImmutableEntry

SimpleEntry definieras som en kapslad klass i klassen AbstractMap . För att skapa ett objekt av denna typ kan vi ge en nyckel och ett värde till konstruktören:

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

Nyckeln och värdet kan nås via standardmetoder för getter och setter.

Dessutom innehåller klassen AbstractMap också en kapslad klass som representerar ett oföränderligt par: klassen SimpleImmutableEntry :

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

Detta fungerar på samma sätt som den mutabla parklassen, förutom att värdet på paret inte kan ändras. Försök att göra detta kommer att resultera i ett stöd som inte stöds .

3. Apache Commons

I Apache Commons-biblioteket kan vi hitta Pair- klassen i paketet org.apache.commons.lang3.tuple . Detta är en abstrakt klass, så den kan inte instantieras direkt.

Vi hittar här två underklasser - som representerar oföränderliga och föränderliga par: Imm utablePair och MutablePair.

Båda implementeringarna har åtkomst till nyckel- / värde-getter / setter-metoder:

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

Inte överraskande, ett försök att åberopa setValue ()ImmutablePair resulterar i ett StödOperationException som inte stöds.

Men operationen är helt giltig för en muterbar implementering:

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

4. Vavr

I Vavr-biblioteket tillhandahålls parfunktionaliteten av den oföränderliga Tuple2- klassen:

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

I den här implementeringen kan vi inte ändra objektet efter skapandet, så muteringsmetoder returnerar en ny instans som innehåller den angivna ändringen:

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

5. Alternativ I - Enkel behållarklass

Antingen genom användarpreferens eller i frånvaro av något av de ovan nämnda biblioteken, skapar en standardlösning för parfunktionaliteten en enkel behållarklass som slår in önskade returvärden.

Den största fördelen här är förmågan att tillhandahålla vårt namn som hjälper till att undvika att ha samma klass som representerar olika domänobjekt:

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

6. Alternativ II - Arrayer

En annan vanlig lösning är att använda en enkel matris med två element för att uppnå liknande resultat:

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

Vanligtvis är nyckeln placerad vid index noll i matrisen medan dess motsvarande värde ligger vid index ett.

7. Slutsats

I den här handledningen har vi diskuterat begreppet Pairs in Java och de olika implementeringarna som finns i core Java såväl som andra tredjepartsbibliotek.

Som alltid kan du hitta koden som stöder den här guiden på GitHub.