pět alternativ k Pair Class v Javě
pár je kontejner pro uložení n-tice dvou objektů. Java ve skutečnosti neposkytuje žádnou implementaci třídy Pair. V tomto příspěvku, budeme diskutovat o různých alternativách párových tříd v Javě.
pár je často užitečný pro sledování dvou objektů dohromady. Obsahuje dvě pole, obvykle označovaná jako první a druhá, která jsou schopna uložit cokoli. Navzdory tomu, že nemají žádný smysluplný vztah mezi prvním a druhým polem, programátorům tato funkce v Javě často chybí.
v předchozím příspěvku jsme diskutovali o tom, jak implementovat naši vlastní třídu párů v Javě. V tomto příspěvku budeme diskutovat o řešeních dostupných v Javě k vyplnění požadované mezery, jak je popsáno níže:
mapa.Vstup< K, V> rozhraní
můžeme použít mapu.Vstup< K, V> rozhraní v Javě, které je podobné STD:: pair v C++. Je to vynikající příklad smysluplného jména, které představuje pár klíč-hodnota.
Chcete-li vytvořit položku představující mapování ze zadaného klíče na zadanou hodnotu, Java poskytuje dvě konkrétní implementace mapy.Vstupní rozhraní, jmenovitě AbstractMap.SimpleEntry a AbstractMap.Jednoduše neměnný vstup.
|
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;
import java.util.HashSet;
import java.util.Mapa;
import java.util.Set;
class Pair
{
// Vrátit položku mapy (klíč-hodnota pár) od zadané hodnoty
public static <T, U> Mapa.Záznam<T, U> z (T první, U druhý)
{
návrat nové AbstractMap.SimpleEntry<>(první, druhý);
}
}
třída n-Tice
{
// Provedení Dvojice třídy v jazyce Java pomocí Mapy.Vstup
public static void main (String args)
{
nastavit <mapa.Vstup<String, Integer>> entries = new HashSet<>();
položky.přidat (pár.z („Jáva“, 50));
zápisy.přidat (pár.z („C++“, 30));
systém.mimo.println(zápisy);
// běží v Javě 8 a výše pouze
položky.forEach(vstup -> {
pokud (vstup.getKey().rovná se („Java“))
systém.mimo.println (vstup.getValue());
});
}
}
|
ke Stažení Spuštění Kódu
Výstup:
50
Java 8 – javafx.util.Pár
konečně po dlouhém čekání je v Javě 8 v javafx přidána třída Pair<K,V>.util balíček. Třída představuje páry klíčových hodnot a podporuje velmi základní operace jako getKey (), getValue (), hashCode (), equals (java).lang.Objekt o) a toString() a má několik metod zděděných z Javy.lang.Třída objektu. Něco je lepší než 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;
třída n-tice
{
// prokázat javafx.util.Dvojice třídy představil v Java 8 a výše
public static void main(String args)
{
Seznam<Pair<String, Integer>> entries = new ArrayList<>();
položky.Přidat (nový pár<>(„C“, 20));
zápisy.Přidat (nový pár<>(„C++“, 30));
// vytiskněte první pár pomocí metody getKey() a getValue ()
systém.mimo.println („{„+záznamy.získat (0).getKey() + „, “ +
zápisy.získat (0).()+“}“);
/ / vypíše druhý pár pomocí metody getKey() a getValue ()
System.mimo.println („{„+záznamy.získat (1).getKey() + „, “ +
zápisy.získat (1).getValue() + „}“);
}
}
|
Kód ke Stažení
Výstup:
{C, 20}
{C++, 30}
Apache Commons Lang Knihovna
Apache Commons Lang Knihovna také poskytuje Dvojice<L,R> utility třída, jejíž prvky jsou vlevo a vpravo. Je definován jako abstraktní a implementuje mapu.Vstupní rozhraní, kde je klíč vlevo a hodnota je správná.
má pár.z () metody, která může být použita k získání neměnného páru z určeného páru objektů. Jeho podtřída MutablePair je proměnlivá, zatímco ImmutablePair je neměnná. Typ objektu uloženého v ImmutablePair však může být sám o sobě proměnlivý.
|
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.Apač.sněmovna.lang3.dvojice.ImmutablePair;
import org.Apač.sněmovna.lang3.dvojice.MutablePair;
import org.Apač.sněmovna.lang3.dvojice.Pair;
import java.util.ArrayList;
import java.util.Seznam;
třída n-Tice
{
// Prokázat Pár třídy za předpokladu, Apache Commons Knihovny v jazyce Java
public static void main(String args)
{
Seznam<Pair<String, Integer>> entries = new ArrayList<>();
položky.Přidat(nový MutablePair<>(„C“, 20)); / / pomocí záznamů MutablePair
.Přidat(nový ImmutablePair<>(„C++“, 30)); / / pomocí položek ImmutablePair
.přidat (pár.z („Java“, 50)); / / pomocí páru.z ()
systému.mimo.println(zápisy);
// 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“);
}
// tisk páru pomocí metody getLeft() a getRight ()
systém.mimo.println (pár.getLeft ()+“, “ + pár.getRight());
// 3. třetí pár je také neměnný
pair = entries.získat(2);
zkuste {
pár.setValue(100); // runtime error
}
catch (UnsupportedOperationException ex) {
Systém.mimo.println („UnsupportedOperationException“);
}
systém.mimo.println (pár.getLeft ()+“, “ + pár.getRight());
}
}
|
Kód ke Stažení
Výstup:
C, 100
UnsupportedOperationException hozen
C++, 30
UnsupportedOperationException hozen
Java, 50
Knihovna JavaTuples
Javatuples je další slavné a jednoduché java knihovna, která se zabývá n-tic. Poskytuje sadu n-tice tříd java v rozmezí od jednoho do deseti prvků. Abychom sloužili našemu účelu, můžeme použít pár<a, B> třídy.
|
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.Pair;
import java.util.ArrayList;
import java.util.Seznam;
třída n-Tice
{
// Prokázat, Pár tříd, pokud JavaTuples Knihovna v jazyce Java
public static void main(String args)
{
Seznam<Pair<String, Integer>> párů = new ArrayList<>();
páry.přidat (pár.s („Java“, 50)); / / pomocí páru.s ()
páry.add(new Pair<>(„C++“, 30)); // pomocí konstruktory
// tisk první dvojice pomocí getValue0() a getValue1() metoda
Systém.mimo.println („{„+páry.získat (0).getValue0() + „, “ +
páry.získat (0).getValue1() + „}“);
// vytiskněte druhý pár pomocí metody getValue0() a getValue1 ()
systém.mimo.println („{„+páry.získat (1).getValue0() + „, “ +
páry.získat (1).getValue1() + „}“);
}
}
|
Kód ke Stažení
Výstup:
{Java, 50}
{C++, 30}
Sbírky.singletonMap ()
dalším přístupem je použití kolekcí.singletonMap () v Javě, která je podobná mapě.Záznam< K, V> diskutováno dříve. Vrací neměnnou singletonovou mapu obsahující pouze zadané mapování párů klíč-hodnota, které lze považovat za pár.
|
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;
import java.util.Set;
class Pair
{
// Návrat neměnný singleton mapa obsahuje pouze zadaný
// pár klíč-hodnota mapování
public static <T, U> Mapa<T, U> z(T první, U druhé)
{
návrat Sbírky.singletonMap(první, druhý);
}
}
třída n-Tice
{
// Provedení Dvojice třídy v jazyce Java pomocí Sbírky.singletonMap()
public static void main(String args)
{
Set<Mapa<String, Integer>> entries = new HashSet<>();
položky.přidat (pár.z („Jáva“, 50));
zápisy.přidat (pár.z („C++“, 30));
systém.mimo.println(položky);
}
}
|
ke Stažení Spuštění Kódu
Výstup:
Konečně v Android projekty, můžeme použít android.util.Třída Pair poskytuje Android SDK.