Fünf Alternativen zur Pair-Klasse in Java
Ein Paar ist ein Container zum Speichern eines Tupels aus zwei Objekten. Java bietet keine Implementierung der Pair-Klasse. In diesem Beitrag werden wir verschiedene Alternativen zur Pair-Klasse in Java diskutieren.
Pair ist oft nützlich, um zwei Objekte zusammen zu verfolgen. Es enthält zwei Felder, die normalerweise als erstes und zweites bezeichnet werden und in der Lage sind, alles zu speichern. Obwohl es keine sinnvolle Beziehung zwischen dem ersten und dem zweiten Feld gibt, vermissen Programmierer diese Funktionalität in Java oft.
Im vorherigen Beitrag haben wir besprochen, wie wir unsere eigene Pair-Klasse in Java implementieren können. In diesem Beitrag werden wir in Java verfügbare Problemumgehungen diskutieren, um die gewünschte Lücke zu füllen, wie unten beschrieben:
Karte.Eintrag<K, V> Schnittstelle
Wir können Karte verwenden.Eintrag< K, V> Schnittstelle in Java, die std ::pair in C ++ ähnelt. Es ist ein hervorragendes Beispiel für einen aussagekräftigen Namen, der ein Schlüssel-Wert-Paar darstellt.
Um einen Eintrag zu erstellen, der eine Zuordnung vom angegebenen Schlüssel zum angegebenen Wert darstellt, bietet Java zwei konkrete Implementierungen der Zuordnung.Entry-Schnittstelle, nämlich AbstractMap.SimpleEntry und AbstractMap.SimpleImmutableEntry.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import java.util.AbstractMap;
Java importieren.util.HashSet;
Java importieren.util.Karte;
Java importieren.util.Set;
Klasse Paar
{
// Gibt einen Map-Eintrag (Schlüssel-Wert-Paar) aus den angegebenen Werten
public static <T, U> Map zurück.Eintrag<T, U> von(T first, U second)
{
gibt new AbstractMap zurück.SimpleEntry<>(erste, zweite);
}
}
klasse Tupel
{
// Implementieren Sie die Pair-Klasse in Java mithilfe von Map .Eintrag
public static void main(String args)
{
Set<Karte.Eintrag<String, Integer>> Einträge = neues HashSet<>();
einträge.hinzufügen(Paar.von(„Java“, 50));
einträge.hinzufügen(Paar.von(„C++“, 30));
System.aus.println(Einträge);
// läuft in Java 8 und höher nur
Einträge.forEach(Eintrag -> {
wenn (Eintrag.getKey().equals(„Java“))
System.aus.println(Eintrag.Getwert());
});
}
}
|
Herunterladen Run Code
Ausgabe:
50
Java 8 – javafx.util.Pair
Schließlich wird nach langem Warten eine Pair<K,V> -Klasse in Java 8 in javafx hinzugefügt.util-Paket. Die Klasse repräsentiert Schlüssel-Wert-Paare und unterstützt sehr grundlegende Operationen wie getKey(), getValue(), hashCode(), equals().lang.Objekt o) und toString () und hat nur wenige Methoden von Java geerbt.lang.Objektklassen. Nun, etwas ist besser als nichts, huh?.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import javafx.util.Pair;
import java.util.ArrayList;
import java.util.List;
Klassen-Tupel
{
// Demonstrieren Sie Javafx.util.Pair-Klasse eingeführt in Java 8 und höher
public static void main(String args)
{
Liste<Paar<Zeichenfolge, Ganzzahl>> Einträge = neue ArrayList<>();
einträge.hinzufügen(neues Paar<>(„C“, 20));
einträge.hinzufügen(neues Paar<>(„C++“, 30));
// drucken Sie das erste Paar mit getKey() und getValue() Methode
System.aus.println(„{“ + Einträge.erhalten(0).getKey() + „, “ +
einträge.erhalten(0).getValue() + „}“);
// Drucken Sie das zweite Paar mit der Methode getKey() und getValue()
System.aus.println(„{“ + Einträge.get(1).getKey() + „, “ +
einträge.get(1).Getwert() + „}“);
}
}
|
Downloadcode
Ausgabe:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library bietet auch ein Paar<L, R> Utility-Klasse, deren Elemente links und rechts sind. Es ist als abstrakt definiert und implementiert die Karte.Eingabeinterface, bei dem der Schlüssel links und der Wert rechts ist.
Es hat Paar.of() -Methode, die verwendet werden kann, um ein unveränderliches Paar von angegebenen Objektpaaren abzurufen. Seine Unterklasse MutablePair ist veränderlich, während ImmutablePair unveränderlich ist. Der Typ des in ImmutablePair gespeicherten Objekts kann jedoch selbst veränderlich sein.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
org importieren.Apache.Commons.13.Tupeln.Unveränderliches Paar;
import org.Apache.Commons.13.Tupeln.MutablePair;
import org.Apache.Commons.13.Tupeln.Paar;
Java importieren.util.ArrayList;
Java importieren.util.Liste;
Klassen-Tupel
{
// Demonstrieren Sie die von der Apache Commons-Bibliothek in Java bereitgestellte Pair-Klasse
public static void main(String args)
{
Liste<Paar<Zeichenfolge, Ganzzahl>> Einträge = neue ArrayList<>();
einträge.add(new MutablePair<>(„C“, 20)); // Verwenden von MutablePair
Einträgen.add(new ImmutablePair<>(„C ++“, 30)); // Verwenden von ImmutablePair
Einträgen.hinzufügen(Paar.of(„Java“, 50)); // Paar verwenden.von()
System.aus.println(Einträge);
// 1. first pair is mutable
Pair<String, Integer> pair = entries.get(0);
pair.setValue(100); // works fine
// printing pair using getKey() and getValue() method
System.out.println(pair.getKey() + „, “ + pair.getValue());
// 2. second pair is immutable
pair = entries.get(1);
try {
pair.setValue(100); // runtime error
}
catch (UnsupportedOperationException ex) {
System.out.println(„UnsupportedOperationException thrown“);
}
// druckpaar mit GetLeft() und GetRight() Methode
System.aus.println(Paar.GetLeft() + „, “ + Paar.GetRight());
// 3. das dritte Paar ist ebenfalls unveränderlich
pair = Einträge.erhalten(2);
versuchen Sie {
}.setValue(100); // Laufzeitfehler
}
catch (UnsupportedOperationException ex) {
System.aus.println(„UnsupportedOperationException ausgelöst“);
}
System.aus.println(Paar.GetLeft() + „, “ + Paar.GetRight());
}
}
|
Download-Code
Ausgabe:
C, 100
Nicht unterstützte Operationsexception ausgelöst
C ++, 30
Nicht unterstützte Operationexception ausgelöst
Java, 50
JavaTuples Library
Javatuples ist eine weitere berühmte und einfache Java-Bibliothek, die sich mit Tupeln befasst. Es bietet eine Reihe von Tupel-Java-Klassen von einem bis zu zehn Elementen. Um unseren Zweck zu erfüllen, können wir die Klasse Pair<A,B> .
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
org importieren.javatuples.Paar;
Java importieren.util.ArrayList;
Java importieren.util.Liste;
Klassen-Tupel
{
// Demonstrieren Sie die von der Pair-Klasse bereitgestellte JavaTuples-Bibliothek in Java
public static void main(String args)
{
Liste< Paar<Zeichenfolge, Ganzzahl>> Paare = neue ArrayList<>();
paare.hinzufügen(Paar.with(„Java“, 50)); // Paar verwenden.mit()
Paaren.add(neues Paar<>(„C ++“, 30)); // Konstruktoren verwenden
// Drucken Sie das erste Paar mit der Methode getValue0() und getValue1()
System.aus.println(„{“ + Paare.erhalten(0).Getwert0() + „, “ +
paare.erhalten(0).getValue1() + „}“);
// drucken Sie das zweite Paar mit der Methode getValue0() und getValue1()
System.aus.println(„{“ + Paare.get(1).Getwert0() + „, “ +
paare.get(1).getValue1() + „}“);
}
}
|
Downloadcode
Ausgabe:
{Java, 50}
{C++, 30}
Sammlungen.singletonMap()
Ein anderer Ansatz besteht darin, Sammlungen zu verwenden.singletonMap() in Java, das Map ähnelt.Eintrag<K,V> zuvor diskutiert. Es gibt eine unveränderliche Singleton-Map zurück, die nur die angegebene Schlüssel-Wert-Paar-Zuordnung enthält, die als Paar behandelt werden kann.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
Java importieren.util.Set;
Klasse Paar
{
// Gibt eine unveränderliche Singleton-Map zurück, die nur das angegebene
// Schlüssel-Wert-Paar-Mapping
public static <T, U> Map<T, U> of(T first, U second)
{
sammlungen zurückgeben.singletonMap (erste, zweite);
}
}
klasse Tupel
{
// Implementieren Sie die Pair-Klasse in Java mithilfe von Sammlungen.singletonMap()
öffentliche statische leere main(String args)
{
Set<Map<String, Integer>> Einträge = neues HashSet<>();
einträge.hinzufügen(Paar.von(„Java“, 50));
einträge.hinzufügen(Paar.von(„C++“, 30));
System.aus.println(Einträge);
}
}
|
Herunterladen Run Code
Ausgabe:
Schließlich können wir in Android-Projekten Android verwenden.util.Pair-Klasse, die vom Android SDK bereitgestellt wird.