fem alternativ till Pair Class i Java
ett par är en behållare för att lagra en tupel av två objekt. Java ger inte riktigt någon implementering av Pair-klassen. I det här inlägget kommer vi att diskutera om olika alternativ till Parklass i Java.
par är ofta användbart för att spåra två objekt tillsammans. Den innehåller två fält, vanligtvis benämnda som första och andra, som kan lagra vad som helst. Trots att det inte finns någon meningsfull relation mellan det första och det andra fältet saknar programmerare ofta denna funktionalitet i Java.
i föregående inlägg har vi diskuterat hur vi implementerar vår egen Parklass i Java. I det här inlägget kommer vi att diskutera lösningar som finns i Java för att fylla önskat gap, som diskuteras nedan:
karta.Entry< K, V> gränssnitt
vi kan använda karta.Inträde< K,V> gränssnitt i Java som liknar std::pair i C++. Det är ett utmärkt exempel på att ha ett meningsfullt namn som representerar ett nyckelvärdespar.
för att skapa en post som representerar en mappning från den angivna nyckeln till det angivna värdet tillhandahåller Java två konkreta implementeringar av kartan.Ingångsgränssnitt, nämligen AbstractMap.SimpleEntry och 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;
importera java.util.HashSet;
importera java.util.Karta;
importera java.util.Set;
klasspar
{
// returnera en kartpost (nyckelvärdespar) från de angivna värdena
offentlig statisk <T, U> karta.Post< T, U> av (T första, U andra)
{
returnera nya AbstractMap.SimpleEntry<>(första, andra);
}
}
klass Tuple
{
// implementera Parklass i Java med Map.Post
offentlig statisk tomrum Huvud (String args)
{
Ställ< kort.Post< sträng, heltal>> poster = ny HashSet<>();
inlägg.Lägg till (par.av (”Java”, 50));
inlägg.Lägg till (par.av (”C++”, 30));
systemet.ut.println (poster);
// körs i Java 8 och senare endast
poster.forEach (inträde -> {
om (inträde.getKey ().lika (”Java”))
systemet.ut.println (inträde.getValue());
});
}
}
|
ladda ner kör kod
utgång:
50
Java 8-javafx.util.Par
slutligen efter en lång väntan läggs ett par<K, V> klass i Java 8 i javafx.util paket. Klassen representerar nyckelvärdespar och stöder mycket grundläggande operationer som getKey(), getValue(), hashCode(), equals(java.lang.Objekt o) och toString () och har få metoder ärvda från java.lang.Objektklass. Tja, något är bättre än ingenting, va?.
|
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;
klass tupel
{
// demonstrera javafx.util.Parklass introducerad i Java 8 och senare
public static void main (String args)
{
lista< par< sträng, heltal>> poster = ny ArrayList<>();
inlägg.Lägg till (nytt par<> (”C”, 20));
inlägg.Lägg till (nytt par<> (”C++”, 30));
// Skriv ut första paret med getKey() och getValue () metod
systemet.ut.println (”{”+poster.få (0).getKey() + ”, ” +
inlägg.få (0).getValue ()+”}”);
// Skriv ut andra paret med getKey() och getValue() metod
systemet.ut.println (”{”+poster.få (1).getKey() + ”, ” +
inlägg.få (1).getValue() + ”}”);
}
}
|
ladda ner kod
utgång:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library ger också ett par<L,R> verktygsklass vars element är vänster och höger. Det definieras som abstrakt och implementerar kartan.Ingångsgränssnitt där nyckeln är kvar och värdet är rätt.
det har Par.av () metod som kan användas för att erhålla en oföränderlig par från specificerade par av objekt. Dess underklass MutablePair är mutable medan ImmutablePair är oföränderlig. Emellertid kan typen av objektet som lagras i Oföränderligtpar kan i sig vara muterbart.
|
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
|
importera org.Apache.gemensam.lang3.tuple.ImmutablePair;
importera org.Apache.gemensam.lang3.tuple.MutablePair;
importera org.Apache.gemensam.lang3.tuple.Par;
importera java.util.ArrayList;
importera java.util.Förteckning;
klass tupel
{
// demonstrera par klass tillhandahålls Apache Commons bibliotek i Java
public static void main (String args)
{
lista< par< sträng, heltal>> poster = ny ArrayList<>();
inlägg.Lägg till (nya MutablePair<>(”C”, 20)); // använda mutablepair
poster.Lägg till (nya ImmutablePair<>(”C++”, 30)); // använda ImmutablePair
poster.Lägg till (par.av (”Java”, 50)); // med användning av par.av ()
systemet.ut.println (poster);
// 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”);
}
// utskrift par med getLeft() och getRight () metod
systemet.ut.println (par.getLeft ()+”, ” + par.getRight());
// 3. tredje paret är också oföränderligt
par = poster.få(2);
försök {
par.setValue (100); / / runtime error
}
fånga (UnsupportedOperationException ex) {
systemet.ut.println (”UnsupportedOperationException kastas”);
}
systemet.ut.println (par.getLeft ()+”, ” + par.getRight());
}
}
|
Hämta kod
utgång:
C, 100
UnsupportedOperationException kastas
C++, 30
UnsupportedOperationException kastas
Java, 50
JavaTuples Library
Javatuples är ett annat känt och enkelt java-bibliotek som handlar om tuples. Det ger en uppsättning tuple java-klasser som sträcker sig från ett till tio element. För att tjäna vårt syfte kan vi använda Par<A,B > klass.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
importera org.javatuples.Par;
importera java.util.ArrayList;
importera java.util.Förteckning;
klass tupel
{
// demonstrera par klass som JavaTuples bibliotek i Java
public static void main (String args)
{
lista< par< sträng, heltal>> par = ny ArrayList<>();
par.Lägg till (par.med (”Java”, 50)); // använda Par.med ()
par.Lägg till(nytt par<>(”C++”, 30)); // använda konstruktörer
// Skriv ut första paret med getValue0 () och getValue1 () metod
systemet.ut.println (”{”+par.få (0).getValue0() + ”, ” +
par.få (0).getValue1() + ”}”);
// Skriv ut andra paret med getValue0() och getValue1 () metod
systemet.ut.println (”{”+par.få (1).getValue0() + ”, ” +
par.få (1).getValue1() + ”}”);
}
}
|
Hämta kod
utgång:
{Java, 50}
{C++, 30}
Samlingar.singletonMap ()
ett annat tillvägagångssätt är att använda Samlingar.singletonMap () i Java som liknar Map.Inträde< K, V> diskuterades tidigare. Den returnerar en oföränderlig singleton-karta som endast innehåller den angivna nyckelvärdesparmappningen, som kan behandlas som ett par.
|
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;
importera java.util.Set;
klasspar
{
// returnera en oföränderlig singleton karta som innehåller endast den angivna
// nyckel-värde par kartläggning
offentlig statisk <T, U> karta<T, U > av (T första, U andra)
{
återvänd Samlingar.singletonMap (första, andra);
}
}
klass Tuple
{
// implementera Parklass i Java med Samlingar.singletonMap ()
offentlig statisk tomrum Huvud (String args)
{
ange< karta< sträng, heltal>> poster = ny HashSet<>();
inlägg.Lägg till (par.av (”Java”, 50));
inlägg.Lägg till (par.av (”C++”, 30));
systemet.ut.println (poster);
}
}
|
ladda ner kör kod
utgång:
slutligen i Android-projekt kan vi använda android.util.Par klass som tillhandahålls av Android SDK.