öt alternatíva a Páros osztályhoz a Java-ban
a pár egy tároló két objektum tárolására. A Java nem igazán biztosítja a Pair osztály megvalósítását. Ebben a bejegyzésben, megvitatjuk a párosítás különféle alternatíváit osztály Java-ban.
a pár gyakran hasznos két objektum együttes követésére. Két mezőt tartalmaz, általában első és második néven, amelyek bármit képesek tárolni. Annak ellenére, hogy nincs érdemi kapcsolat az első és a második mező között, a programozók gyakran hiányolják ezt a funkciót a Java-ban.
az előző bejegyzésben megvitattuk, hogyan valósítsuk meg saját pár osztályunkat Java-ban. Ebben a bejegyzésben megvitatjuk a Java-ban elérhető megoldásokat a kívánt rés kitöltésére, az alábbiak szerint:
Térkép.Bejegyzés< K,V> interfész
használhatjuk a térképet.Bejegyzés< K, V> interfész Java – ban, amely hasonló az std::pair-hez A C++ – ban. Kiváló példa arra, hogy van egy értelmes név, amely kulcs-érték párot képvisel.
a megadott kulcsról a megadott értékre történő leképezést ábrázoló bejegyzés létrehozásához a Java A térkép két konkrét megvalósítását biztosítja.Belépési felület, nevezetesen AbstractMap.SimpleEntry és AbstractMap.Simpleimutableentry.
|
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 importálása.util.HashSet;
java importálása.util.Térkép;
Java importálása.util.Készlet;
osztálypár
{
// visszaad egy térképbejegyzést (kulcs-érték pár) a megadott értékekből
nyilvános statikus < T, U> Térkép.Bejegyzés<T, U> nak, – nek (T első, U második)
{
vissza új AbstractMap.SimpleEntry<>(első, második);
}
}
osztály Tuple
{
// végre pár osztály Java segítségével Map.Bejegyzés
nyilvános statikus Void main (String args)
{
Set< Térkép.Entry< String, Integer>> entry = új HashSet<>();
bejegyzések.Hozzáadás (pár.vagy (“Java”, 50));
bejegyzések.Hozzáadás (pár.vagy (“C++”, 30));
rendszer.kifelé.println (bejegyzések);
// Java 8 vagy újabb verziókban csak
bejegyzéseket futtat.forEach (bejegyzés -> {
if (bejegyzés.getKey ().egyenlő (“Java”))
rendszer.kifelé.println (bejegyzés.getValue());
});
}
}
|
letöltés futási Kód
kimenet:
50
Java 8-javafx.util.Pair
végül hosszú várakozás után egy Pair< K, V> osztály kerül hozzáadásra a Java 8-ban a javafx-ben.util csomag. Az osztály kulcs-érték párokat képvisel, és olyan alapvető műveleteket támogat, mint a getkey(), getValue(), hashCode (), equals (java.lang.Object o) és toString (), és kevés metódust örökölt java.lang.Objektum osztály. Nos, valami jobb, mint a semmi, nem?.
|
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;
osztály Tuple
{
// mutassa be a javafx-et.util.A Java 8 vagy újabb verziójában bevezetett pár osztály
public static void main (String args)
{
lista<pár< String, Integer>> bejegyzések = új ArrayList<>();
bejegyzések.hozzáad (új pár<>(“C”, 20));
bejegyzések.hozzáad (új pár<>(“C++”, 30));
// az első pár nyomtatása a getkey() és a getvalue () módszerrel
rendszer.kifelé.println (“{“+bejegyzések.kap (0).getKey() + “, ” +
bejegyzések.kap (0).getValue ()+”}”);
/ / nyomtassa ki a második párt a getkey() és a getvalue() módszerrel
rendszer.kifelé.println (“{“+bejegyzések.kap (1).getKey() + “, ” +
bejegyzések.kap (1).getValue() + “}”);
}
}
|
letöltési kód
kimenet:
{C, 20}
{C++, 30}
Apache Commons Lang Library
az Apache Commons Lang Library egy pár<L, R> segédprogram osztályt is tartalmaz, amelynek elemei bal és jobb. Ez határozza meg, mint absztrakt és végrehajtja a térképet.Belépési felület, ahol a kulcs balra van, az érték pedig jobb.
párja van.of () módszer, hogy lehet használni, így egy megváltoztathatatlan pár a megadott pár tárgyak. A MutablePair alosztálya változékony, míg az ImmutablePair változhatatlan. Az ImmutablePair-ben tárolt objektum típusa azonban önmagában is változtatható lehet.
|
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.apacs.commons.lang3.tuple.Megváltoztathatatlanpair;
import org.apacs.commons.lang3.tuple.MutablePair;
import org.apacs.commons.lang3.tuple.Pár;
Java importálása.util.ArrayList;
Java importálása.util.Lista;
osztály Tuple
{
// mutassa pár osztály biztosított Apache Commons könyvtár Java
public static void main (String args)
{
lista<pár< String, Integer>> bejegyzések = új ArrayList<>();
bejegyzések.Hozzáadás (új MutablePair<> (“C”, 20)); // a MutablePair
bejegyzések használatával.Hozzáadás (új ImmutablePair<>(“C++”, 30)); // az ImmutablePair
bejegyzések használata.Hozzáadás (pár.nak, – nek(“Java”, 50)); // pár használata.a ()
rendszer.kifelé.println (bejegyzések);
// 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”);
}
// nyomtatás pár segítségével getLeft() és getRight () módszer
rendszer.kifelé.println (pár.getLeft ()+”, ” + pár.getRight());
// 3. harmadik pár is változhatatlan
pair = bejegyzéseket.kap(2);
próbálja {
pár.setValue(100); // futásidejű hiba
}
catch (UnsupportedOperationException ex) {
rendszer.kifelé.println (“UnsupportedOperationException dobott”);
}
rendszer.kifelé.println (pár.getLeft ()+”, ” + pár.getRight());
}
}
|
letöltési kód
kimenet:
C, 100
nem Támogatottoperationexception dobott
C++, 30
nem Támogatottoperationexception dobott
Java, 50
JavaTuples Library
Javatuples egy másik híres és egyszerű java könyvtár, amely foglalkozik tuples. Ez egy sor tuple java osztályok kezdve egy-tíz elemet. A célunk érdekében használhatjuk a<A,B> osztályt.
|
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.Pár;
Java importálása.util.ArrayList;
Java importálása.util.Lista;
osztály Tuple
{
// mutassa pár osztály biztosított JavaTuples könyvtár Java
nyilvános statikus void main(String args)
{
lista<pár < String, Integer>> pairs = új ArrayList<>();
pár.Hozzáadás (pár.val vel (“Java”, 50)); // pár használatával.val vel ()
Párok.add (új pár<>(“C++”, 30)); // konstruktorok használata
// az első pár nyomtatása getValue0() és getValue1() módszerrel
rendszer.kifelé.println (“{“+Párok.kap (0).getValue0() + “, ” +
pár.kap (0).getValue1() + “}”);
// nyomtassa ki a második párt a getvalue0() és a getvalue1() módszerrel
rendszer.kifelé.println (“{“+Párok.kap (1).getValue0() + “, ” +
pár.kap (1).getValue1() + “}”);
}
}
|
letöltési kód
kimenet:
{Java, 50}
{C++, 30}
gyűjtemények.singletonMap()
egy másik megközelítés a gyűjtemények használata.singletonMap () Java – ban, amely hasonló a Map-hez.Bejegyzés< K, V> korábban tárgyaltuk. Ez egy megváltoztathatatlan singleton térképet ad vissza, amely csak a megadott kulcs-érték pár leképezést tartalmazza, amely párként kezelhető.
|
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 importálása.util.Készlet;
osztálypár
{
// visszaad egy megváltoztathatatlan singleton térképet, amely csak a megadott
// kulcs-érték pár leképezést tartalmazza
nyilvános statikus < T, U> Térkép<T, U>(t első, U második)
{
vissza gyűjtemények.singletonMap (első, második);
}
}
osztály Tuple
{
// végre pár osztály Java segítségével gyűjtemények.singletonMap()
nyilvános statikus Void main (String args)
{
Set< Térkép < String, Integer>> bejegyzés = Új HashSet<>();
bejegyzések.Hozzáadás (pár.vagy (“Java”, 50));
bejegyzések.Hozzáadás (pár.vagy (“C++”, 30));
rendszer.kifelé.println (bejegyzések);
}
}
|
letöltés futási Kód
kimenet:
végül az Android projektekben használhatjuk az Androidot.util.Pár osztály által biztosított Android SDK.