De Java Pair-klasse slaat waarde op in de sleutel-waardepaarcombinatie. Het is handig om twee waarden te verkrijgen. Deze sleutel-waardecombinatie staat bekend als tupels.

De paren zijn handig als we willen dat twee waarden uit een methode worden geretourneerd. Als we bijvoorbeeld een methode hebben die de vierkantswortel van een getal berekent en we het getal met de vierkantswortel willen afdrukken. We kunnen de uitvoer dus afdrukken in een combinatie van getallen en de vierkantswortel (bijvoorbeeld (5, 25)) met behulp van de paarklasse.

Java biedt een ingebouwde Pair-klasse uit Java 8.

In deze sectie zullen we zien hoe u de klasse Pair in Java kunt gebruiken. Verder zullen we onze aangepaste paarklasse creëren.

Paarklasse in Java

Sinds Java 8 biedt Java een klasse Pair om de waarden in sleutelpaarcombinaties op te slaan. Om de waarde in een paarcombinatie op te slaan, moeten we de geparametriseerde constructor gebruiken die wordt geleverd door de javafx.util.Pair klas.

De klasse Pair is handig bij het opslaan van de waarde in een boomgegevensstructuur. Tijdens het uitvoeren van de recursiebewerking op een boomgegevensstructuur is het eenvoudig om waarde van het ene knooppunt naar het andere knooppunt door te geven met behulp van de klasse Pair. Deze waarden kunnen minimale en maximale knooppuntwaarden zijn tot aan dat knooppunt. Dit zou voorkomen dat de aanwijzer bepaalde codes herhaaldelijk opnieuw bezoekt.

In Java worden de kaarten gebruikt om de waarde op te slaan in de vorm van een sleutelpaarcombinatie. Ze slaan de waarde op als tupels en gebruiken ze als één enkel object.

Om de klasse Pair te implementeren, moeten we het bovenliggende pakket importeren:

 import javafx.util.Pair; 

De ingebouwde paarklasse gebruikt de volgende notatie van Sleutel en Waarde, net als de Kaart op Java een paar opslaan:

Verklaring:

Het klasseobject Pair wordt als volgt gedeclareerd:

 Pair p = new Pair(5 ,'Five'); 

De bovenstaande syntaxis maakt een object van het type en de bouwer neemt de waarde 5 en 'Vijf' en slaat deze op in de klasse Pair.

Koppelklassemethoden

De klasse Java Pair biedt de volgende methoden:

getKey()

Het haalt de sleutel voor het gegeven paar op en retourneert de sleutel voor het opgegeven paar. Het wordt als volgt verklaard:

CSS-overgangsdekking

 public K getKey() 

getWaarde()

Het krijgt de waarde voor het gegeven paar en retourneert de waarde van het paar. Het wordt als volgt verklaard:

 public V getValue() 

hashCode()

Het genereert de hashcode voor het paar; deze hashcode wordt berekend op basis van zowel de naam als de waarde van het paar. Het overschrijft de klasse HashCode en retourneert de hashcode voor het paar. Het wordt als volgt verklaard:

 public int hashCode() 

is gelijk aan()

Het wordt gebruikt om het paar te testen op gelijkheid met het andere paar. Als het object niet is opgegeven voor het testen of null is, retourneert het false. De gegeven twee paren worden als gelijk beschouwd als en slechts als hun namen en waarden hetzelfde zijn. Het wordt als volgt verklaard:

 public boolean equals(Object o) 

Er zijn de '-o'-argumenten nodig om de gelijkheid met het paar te testen. Het overschrijft de gelijken in de klasse Objects en retourneert waar als het gegeven paar gelijk is; anders zal het false retourneren.

toString()

eenvoudig Python-programma

Het wordt gebruikt om het paar als String weer te geven. In de methode toString() wordt altijd de standaardnaam/waarde delimiter=' gebruikt. Het overschrijft de toString in de klasse Object en retourneert de String-waarde van het paar. Het wordt als volgt verklaard:

 public String toString() 

Paarklasseconstructeur

De klasseconstructor Pair maakt een nieuw paar. Het neemt de sleutel- en paarwaarden als argument. Het wordt als volgt verklaard:

 public Pair(K key, V value) 

Soorten paarklassen

Er zijn twee soorten Pair-klassen in Java, die als volgt zijn:

Onveranderlijke paarklasse:De onveranderlijke paarklassen zijn klassen waarin de waarde van het object niet kan worden gewijzigd als het eenmaal is gedefinieerd; dat betekent dat we de setters-methode niet kunnen gebruiken om de gedefinieerde waarden te wijzigen. Over het algemeen blijft de waarde constant als deze is gedefinieerd.Veranderlijke paarklasse:Dankzij de veranderlijke klassen kunnen we de waarde op elk moment in het programma wijzigen. We kunnen getters en setters-methoden gebruiken om toegang te krijgen tot de waarde van een object en deze te wijzigen. We zouden de waarden later in het programma kunnen wijzigen, zelfs als we ze in het begin hadden gedefinieerd. De pair.setValue(a,b) En pair.getValue() Er worden methoden gebruikt om de objectwaarde in te stellen en er toegang toe te krijgen.

Waarom hebben we parenklasse nodig?

De paarklasse wordt gebruikt om de waarde van een sleutelpaarcombinatie te verkrijgen. Met andere woorden kunnen we zeggen dat de paarklasse methoden biedt die twee waarden samen retourneren. Er kunnen veel redenen zijn waarom we de klasse Pair gebruiken.

Hieronder volgen enkele gevallen waarin we de klasse Pair moeten gebruiken:

• Stel dat we meerdere waarden willen retourneren. We kunnen dit echter doen door bepaalde datastructuren te gebruiken, zoals Arrays en HashMap, maar als we te maken hebben met een cluster van variabelen samen, kan het ingewikkeld zijn om ze allebei terug te geven. In dergelijke gevallen zal de Pair-klasse zeer nuttig zijn.
• Als we een wiskundige bewerking willen uitvoeren en het getal samen met de uitvoer ervan willen weergeven, dan kunnen we dat eenvoudig doen door de klasse Pair te gebruiken.
• Als we een bewerking willen uitvoeren op een boomdatastructuur.

Voorbeeld van een paarklasse

Laten we het begrijpen met een eenvoudig voorbeeld:

De paarklasse is een onderdeel van de JavaFX , dus we moeten een JavaFX-project maken en configureren. Zie Hoe te creëren een JavaFX-project in Eclipse .

Maak nu een klassenbestand onder de src map.

We maken een TestPair-klasse.

TestPair.java:

 import javafx.util.Pair; public class TestPair { public static void main(String[] args) { Pair p = new Pair(5,'Five'); System.out.println('The key is :' + p.getKey()); System.out.println('The Pair value is :' + p.getValue()); } } 

In het bovenstaande programma nemen we een paarwaarde die een geheel getalsleutelwaarde en een String-paarwaarde bevat. We declareren een klasse Pair met behulp van de standaardsyntaxis en drukken de waarde ervan af met behulp van de methoden getKey() en getValue() van de klasse paar. Het zal de volgende uitvoer weergeven:

Uitgang:

 The key is :5 The Pair value is :Five 

Aangepaste paarklasse

Als u de ingebouwde Pair-klasse niet wilt gebruiken, kunt u een Pair-klasse aanpassen met behulp van Generics. Beschouw het onderstaande voorbeeld:

CustomPair.java:

 public class CustomizedPair { int key; String value; public CustomizedPair(int key, String value) //Constructor of the class { this.key = key; this.value = value; } public void print(){ System.out.println(''); } public static void main(String[] args){ CustomizedPair a = new CustomizedPair(1,'Hello'); a.print(); } } 

Op basis van de bovenstaande code hebben we een klasse Custom Pair gemaakt en twee waarden in één variabele opgeslagen en afgedrukt.

Uitgang:

Door generieke methoden te gebruiken, kunnen we dus profiteren van de voordelen van een Pair-klasse zonder JavaFX te gebruiken.

Laten we het gedrag ervan begrijpen met functies:

Koppel klasse aan functies

We kunnen een klasse Pair gebruiken om twee waarden terug te geven met behulp van een functie. Om dit proces uit te voeren, moet het retourtype van de functie een paar zijn. Beschouw het onderstaande voorbeeld:

TestPair2.java:

 import java.util.Scanner; public class TestPair2 { public static void main(String[] args) { Scanner s = new Scanner(System.in); CustomizedPair a = func(s); a.print(); } public static CustomizedPair func (Scanner s){ System.out.println('Enter Value'); String key = s.next(); System.out.println('Enter Key'); int value = s.nextInt(); CustomizedPair a = new CustomizedPair(value, key); return a; } } 

Uitgang:

 Enter Value Five Enter Key 5 

Conclusie:

Paarklassen zijn erg handig voor het verbeteren van de code-efficiëntie. Een handig geval van de klasse Pair is het opslaan van de waarde in de boomgegevensstructuur. We kunnen ingebouwde paarklassen gebruiken of onze lessen aanpassen. Als ze op de juiste manier worden gebruikt, zullen ze zeer nuttig zijn.