pięć alternatyw dla klasy pary w Javie
para jest kontenerem do przechowywania krotki dwóch obiektów. Java tak naprawdę nie zapewnia żadnej implementacji klasy Pair. W tym poście omówimy różne alternatywy dla klasy par w Javie.
para jest często przydatna do śledzenia dwóch obiektów razem. Zawiera dwa pola, zwykle określane jako pierwsze i drugie, które są w stanie przechowywać wszystko. Pomimo braku znaczącej relacji między pierwszym a drugim polem, programiści często tęsknią za tą funkcjonalnością w Javie.
w poprzednim poście omówiliśmy jak zaimplementować naszą własną klasę par w Javie. W tym poście omówimy obejścia dostępne w Javie, aby wypełnić pożądaną lukę, jak omówiono poniżej:
Mapa.Wpis< K, V> interfejs
możemy użyć mapy.Wejście<k,v> interfejs w Javie, który jest podobny do STD:: pair w C++. Jest to doskonały przykład posiadania znaczącej nazwy, która reprezentuje parę klucz-wartość.
aby utworzyć wpis reprezentujący mapowanie z podanego klucza do podanej wartości, Java zapewnia dwie konkretne implementacje Mapy.Interfejs wejściowy, czyli AbstractMap.SimpleEntry i AbstractMap.To proste.
|
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;
Importuj Javę.util.HashSet;
Importuj Javę.util.Map;
Importuj Javę.util.Zestaw;
para klas
{
// zwraca wpis mapy (para klucz-wartość) z podanych wartości
public static <T, U> Map.Wpis< T, U> of(T pierwszy, u drugi)
{
zwraca nową Abstractmapę.Simple < >(pierwszy, drugi);
}
}
krotka klasy
{
// zaimplementuj klasę Pair w Javie za pomocą Map.Wpis
public static void main (String args)
{
Ustaw < mapę.Wpis< String, Integer> > wpisy = new HashSet<>();
pozycji.add (para.of („Java”, 50));
pozycji.add (para.of („C++”, 30));
System.Wynocha.println (wpisy);
// działa w Javie 8 i nowszych tylko wpisy
.forEach (wejście -> {
if (właśc.getKey().equals („Java”))
System.Wynocha.println(właśc.getValue());
});
}
}
|
Pobierz kod
wyjście:
50
Java 8-javafx.util.Para
wreszcie po długim oczekiwaniu, para< k,v> klasa jest dodawana w Java 8 w javafx.pakiet util. Klasa reprezentuje pary klucz-wartość i obsługuje bardzo podstawowe operacje, takie jak getKey (), getValue (), hashCode (), equals(java).lang.Obiekt o) i toString () i posiada kilka metod dziedziczonych z Javy.lang.Klasa obiektu. Coś jest lepsze niż nic, co?.
|
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;
krotka Klasa
{
// zademonstruj javafx.util.Klasa para wprowadzona w Javie 8 i nowszych
public static void main (String args)
{
lista< para < String, Integer>> entries = new ArrayList<>();
pozycji.dodaj (Nowa Para< >(„C”, 20));
pozycji.dodaj (Nowa Para< >(„C++”, 30));
// drukuje pierwszą parę przy użyciu getKey() i getValue() metody
System.Wynocha.println („{„+wpisy.Pobierz (0)getKey() + „, ” +
pozycji.Pobierz (0)getValue() + „}”);
// drukuje drugą parę przy użyciu metody getKey() i getValue ()
.Wynocha.println („{„+wpisy.get(1).getKey() + „, ” +
pozycji.get(1).getValue() + „}”);
}
}
|
Pobierz kod
wyjście:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library dostarcza również parę<L,R> klasy użytkowej, której elementy są lewe i prawe. Jest zdefiniowany jako abstrakcyjny i implementuje mapę.Interfejs wejściowy, w którym klucz jest w lewo, a wartość w prawo.
ma parę.of () metoda, która może być użyta do uzyskania niezmiennej pary z określonej pary obiektów. Jego podklasa MutablePair jest zmienna, podczas gdy ImmutablePair jest niezmienna. Jednak typ obiektu przechowywanego w ImmutablePair może być sam w sobie zmienny.
|
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
|
import org.Apacz.commons.lang3.tuple.ImmutablePair;
import org.Apacz.commons.lang3.tuple.MutablePair;
import org.Apacz.commons.lang3.tuple.Para;
Importuj Javę.util.ArrayList;
Importuj Javę.util.Lista;
krotka Klasa
{
// demonstracja klasy pary dostarczonej biblioteki Apache Commons w Javie
public static void main (String args)
{
lista< para < String, Integer>> entries = new ArrayList<>();
pozycji.add(new MutablePair<>(„C”, 20)); // using MutablePair
entries.add(new immutablepair<>(„C++”, 30)); // using immutablepair
entries.add (para.of („Java”, 50)); / / using Pair.of ()
System.Wynocha.println (wpisy);
// 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”);
}
// drukowanie pary przy użyciu metody getLeft() i getRight ()
.Wynocha.println (par.getLeft ()+”, ” + para.getRight());
// 3. trzecia para jest również niezmienna
pair = entries . Pobierz(2);
try {
para.setValue (100); / / błąd podczas uruchamiania
}
catch (UnsupportedOperationException ex) {
System.Wynocha.println („UnsupportedOperationException”)”);
}
System.Wynocha.println (par.getLeft ()+”, ” + para.getRight());
}
}
|
Pobierz kod
wyjście:
C, 100
UnsupportedOperationException throwed
C++, 30
UnsupportedOperationException throwed
Java, 50
JavaTuples Library
Javatuples to kolejna znana i prosta biblioteka Javy, która zajmuje się krotkami. Dostarcza zestaw krotek klas java, od jednego do dziesięciu elementów. Aby służyć naszym celom, możemy użyć klasy 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
|
import org.javatuples.Para;
Importuj Javę.util.ArrayList;
Importuj Javę.util.Lista;
krotka Klasa
{
// demonstracja klasy pary dostarczonej Bibliotece JavaTuples w Javie
public static void main (String args)
{
lista< para < String, Integer>> pary = new ArrayList<>();
pary.add (para.with („Java”, 50)); / / using Pair.z ()
.add (Nowa Para<>(„C++”, 30)); // używanie konstruktorów
// drukowanie pierwszej pary przy użyciu metody getValue0() i getValue1 ()
.Wynocha.println („{„+par.Pobierz (0)getValue0() + „, ” +
pary.Pobierz (0)getValue1() + „}”);
// drukuje drugą parę przy użyciu metody getValue0() i getValue1 ()
.Wynocha.println („{„+par.get(1).getValue0() + „, ” +
pary.get(1).getValue1() + „}”);
}
}
|
Pobierz kod
wyjście:
{Java, 50}
{C++, 30}
Kolekcje.singletonMap ()
innym podejściem jest użycie kolekcji.singletonMap () w Javie, która jest podobna do Map.Wpis<K,V> omówiony wcześniej. Zwraca niezmienną mapę Singletona zawierającą tylko określone odwzorowanie pary klucz-wartość, które można traktować jako 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;
Importuj Javę.util.Zestaw;
para klas
{
// zwraca niezmienną mapę singletonu zawierającą tylko podaną
// mapowanie pary klucz-wartość
public static <T, U> Map<T, U> of (T first, u second)
{
zwróć Kolekcje.singletonMap (pierwszy, drugi);
}
}
krotka klasy
{
// zaimplementuj klasę Pair w Javie za pomocą Kolekcji.singletonMap ()
public static void main (String args)
{
Set< Map< String, Integer>> entries = new HashSet<>();
pozycji.add (para.of („Java”, 50));
pozycji.add (para.of („C++”, 30));
System.Wynocha.println (wpisy);
}
}
|
Pobierz kod
wyjście:
wreszcie w projektach z Androidem możemy korzystać z Androida.util.Klasa para dostarczana przez Android SDK.