vijf alternatieven voor Pair Class in Java
een Pair is een container om een tupel van twee objecten op te slaan. Java biedt niet echt een implementatie van de Pair klasse. In deze post, we zullen bespreken over verschillende alternatieven voor Paar klasse in Java.
paar is vaak nuttig om twee objecten samen te volgen. Het bevat twee velden, meestal aangeduid als eerste en tweede, die in staat zijn om alles op te slaan. Ondanks het feit dat er geen betekenisvolle relatie is tussen het eerste en tweede veld, missen programmeurs deze functionaliteit in Java vaak.
in het vorige bericht hebben we besproken hoe we onze eigen Pair Class in Java kunnen implementeren. In dit bericht zullen we workarounds bespreken die beschikbaar zijn in Java om de gewenste leemte op te vullen, zoals hieronder wordt besproken:
Map.Entry<K, V> Interface
we kunnen Map gebruiken.Entry<K, V> interface in Java die vergelijkbaar is met STD::pair in C++. Het is een uitstekend voorbeeld van het hebben van een betekenisvolle naam die een sleutel-waarde paar vertegenwoordigen.
om een regel te maken die een afbeelding van de opgegeven sleutel naar de opgegeven waarde weergeeft, biedt Java twee concrete implementaties van de afbeelding.Entry interface, namelijk, AbstractMap.SimpleEntry en 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 importeren.util.HashSet;
java importeren.util.Map;
java importeren.util.Set;
klasse paar
{
// retourneer een kaartingang (sleutelwaarde-paar) van de opgegeven waarden
openbaar statisch <T, U> kaart.Vermelding<T, u> van (T eerste, u Tweede)
{
retourneer nieuwe AbstractMap.SimpleEntry<>(eerste, tweede);
}
}
klasse tupel
{
// implementeer Pair class in Java met behulp van Map.Entry
public static void main (String args)
{
kaart< instellen.Entry<String, Integer>> entries = nieuwe HashSet<>();
inzendingen.toevoegen (paar.van (“Java”, 50));
inzendingen.toevoegen (paar.van(“C++”, 30));
systeem.uit.println (vermeldingen));
// draait in Java 8 en hoger alleen
ingangen.forEach (vermelding -> {
if (vermelding.getKey ().is gelijk aan (“Java”))
systeem.uit.println (entry.getValue());
});
}
}
|
Download Run Code
uitvoer:
50
Java 8-javafx.util.Pair
tenslotte wordt na een lange wachttijd een Pair< K, V> klasse toegevoegd in Java 8 in javafx.util pakket. De klasse vertegenwoordigt sleutel-waarde paren en ondersteunt zeer fundamentele operaties zoals getKey (), getValue (), hashCode (), is gelijk aan(java.lang.Object o) en toString () en heeft weinig methoden overgenomen van java.lang.Objectklasse. Iets is beter dan niets, hè?.
|
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;
Klasse tupel
{
// JavaFX demonstreren.util.Pair class geà ntroduceerd in Java 8 en hoger
public static void main (String args)
{
List<Pair<String, Integer>> entries = new ArrayList<>();
inzendingen.toevoegen(nieuw paar<>(“C”, 20));
inzendingen.toevoegen(nieuw paar<>(“C++”, 30));
// print het eerste paar met behulp van getKey() en getValue () methode
systeem.uit.println (“{“+entries.get (0).getKey() + “, ” +
inzendingen.get (0).getValue ()+”}”);
/ / druk het tweede paar af met behulp van getKey() en getValue () methode
systeem.uit.println (“{“+entries.get (1).getKey() + “, ” +
inzendingen.get (1).getValue() + “}”);
}
}
|
downloadcode
uitvoer:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library biedt ook een paar<L, R> utility class waarvan de elementen links en rechts zijn. Het wordt gedefinieerd als abstract en implementeert de kaart.Invoer interface waar de sleutel is links en de waarde is rechts.
het heeft een paar.van () methode die kan worden gebruikt om een onveranderlijk paar van gespecificeerde paar objecten te verkrijgen. De subklasse MutablePair is veranderlijk terwijl ImmutablePair onveranderlijk is. Echter, het type van het object opgeslagen in ImmutablePair kan zelf veranderlijk zijn.
|
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 importeren.Apache.Commons.lang3.tuple.ImmutablePair;
import org.Apache.Commons.lang3.tuple.MutablePair;
import org.Apache.Commons.lang3.tuple.Pair;
java importeren.util.ArrayList;
java importeren.util.Lijst;
Klasse tupel
{
// demonstreren paar klasse geleverd Apache Commons bibliotheek in Java
public static void main (String args)
{
List<Pair<String, Integer>> entries = new ArrayList<>();
inzendingen.toevoegen(new MutablePair<>(“C”, 20)); // met behulp van MutablePair
entries.toevoegen(new ImmutablePair<>(“C++”, 30)); // gebruik makend van ImmutablePair
entries.toevoegen (paar.of (“Java”, 50)); / / met behulp van paar.of ()
systeem.uit.println (vermeldingen));
// 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”);
}
// printen paar met behulp van getLeft() en getRight () methode
systeem.uit.println (paar.getLeft ()+”, ” + paar.getRight());
// 3. het derde paar is ook onveranderlijk
pair = entries.ophalen(2);
probeer {
paar.setValue (100); / / runtime-fout
}
catch (UnsupportedOperationException ex) {
systeem.uit.println (“Unsupportedoperationuitzondering gegooid”);
}
systeem.uit.println (paar.getLeft ()+”, ” + paar.getRight ());
}
}
|
Download Code
Output:
C, 100
UnsupportedOperationException gegooid
C++, 30
UnsupportedOperationException gegooid
Java, 50
JavaTuples Bibliotheek
Javatuples is een andere beroemde en eenvoudige java-bibliotheek die zich bezighoudt met tupels. Het biedt een set van tuple java klassen variërend van een tot tien elementen. Om ons doel te dienen,kunnen we Pair<a, b> Klasse gebruiken.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
importeren org.javatuples.Pair;
java importeren.util.ArrayList;
java importeren.util.Lijst;
Klasse tupel
{
// demonstreren paar klasse geleverd JavaTuples bibliotheek in Java
public static void main (String args)
{
List<Pair<String, Integer>> pairs = new ArrayList<>();
paren.toevoegen (paar.met (“Java”, 50)); / / Pair gebruiken.met ()
paar.toevoegen(nieuw paar<>(“C++”, 30)); // met behulp van constructors
// druk het eerste paar af met behulp van getValue0() en getValue1() methode
systeem.uit.println (“{“+paren.get (0).getwaarde 0() + “, ” +
paren.get (0).getwaarde1() + “}”);
// print het tweede paar met behulp van getValue0() en getValue1 () methode
systeem.uit.println (“{“+paren.get (1).getwaarde 0() + “, ” +
paren.get (1).getwaarde1() + “}”);
}
}
|
downloadcode
uitvoer:
{Java, 50}
{C++, 30}
collecties.singletonMap ()
een andere benadering is het gebruik van collecties.singletonMap () in Java die vergelijkbaar is met Map.Entry<K, V> eerder besproken. Het retourneert een onveranderlijke singleton kaart die alleen de opgegeven sleutel-waarde pair mapping, die kan worden behandeld als een paar.
|
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 importeren.util.Set;
klasse paar
{
// retourneer een onveranderlijke Singleton map die alleen de opgegeven
// sleutelwaarde pair mapping
public static <T, U> Map<T, u> of (T first, u second)
{
retourneer collecties.singletonMap (eerste, tweede);
}
}
klasse tupel
{
// implementeer Pair class in Java met behulp van collecties.singletonMap ()
public static void main (String args)
{
Set<Map<String, Integer>> entries = nieuwe HashSet<>();
inzendingen.toevoegen (paar.van (“Java”, 50));
inzendingen.toevoegen (paar.van(“C++”, 30));
systeem.uit.println (vermeldingen));
}
}
|
Download Run Code
uitvoer:
tot slot in Android-projecten, kunnen we android gebruiken.util.Paar klasse geleverd door de Android SDK.