cinci alternative la clasa pereche în Java
o pereche este un container pentru a stoca un tuplu de două obiecte. Java nu oferă într-adevăr nici o implementare a clasei pereche. În acest post, vom discuta despre diverse alternative la clasa pereche în Java.
perechea este adesea utilă pentru a urmări două obiecte împreună. Conține două câmpuri, denumite de obicei primul și al doilea, care sunt capabile să stocheze orice. În ciuda faptului că nu au nicio relație semnificativă între primul și al doilea domeniu, programatorii ratează adesea această funcționalitate în Java.
în postarea anterioară, am discutat cum să implementăm propria noastră clasă de perechi în Java. În acest post, vom discuta soluții disponibile în Java pentru a umple golul dorit, așa cum sa discutat mai jos:
Map.Intrare< K, V > interfață
putem folosi harta.Intrare <k, v > interfață în Java, care este similar cu std:: pereche în c++. Este un exemplu excelent de a avea un nume semnificativ care reprezintă o pereche cheie-valoare.
pentru a crea o intrare reprezentând o mapare de la cheia specificată la valoarea specificată, Java oferă două implementări concrete ale hărții.Interfață de intrare, și anume, AbstractMap.SimpleEntry și AbstractMap.Intrare simplă imutabilă.
|
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.Scurt;
import java.util.Set;
pereche de clasă
{
// returnați o intrare hartă (pereche cheie-valoare) din valorile specificate
static public <T, U> hartă.Intrare< T, U > din (T primul, U al doilea)
{
întoarcere nou AbstractMap.SimpleEntry< > (primul, al doilea);
}
}
clasa tuplu
{
// punerea în aplicare a clasei pereche în Java folosind harta.Intrare
public static void main (string args)
{
Set < scurt.Intrare < șir, număr întreg>> intrări = HashSet nou<>();
intrări.adăugați (pereche.din („Java”, 50));
intrări.adăugați (pereche.din („C++”, 30));
sistem.afară.println(intrări);
// rulează în Java 8 și peste numai
intrări.forEach (intrare -> {
dacă (intrare.getKey ().egal („Java”))
sistem.afară.println (intrare.getValue());
});
}
}
|
Descarca Run Cod
ieșire:
50
Java 8-javafx.util.Pereche
în cele din urmă, după o lungă așteptare,o pereche< K, v> clasa se adaugă în Java 8 în javafx.pachet util. Clasa reprezintă perechi cheie-valoare și suportă operațiuni foarte de bază, cum ar fi getKey (), getValue (), hashCode (), este egal cu(java.lang.Obiect o) și toString () și are puține metode moștenite de la java.lang.Clasa de obiecte. Ceva e mai bun decât nimic, nu?.
|
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;
clasa tuplu
{
// demonstrați javafx.util.Clasa pereche introdusă în Java 8 și mai sus
public static void main (string args)
{
listă <pereche <șir, număr întreg>> intrări = nou ArrayList<>();
intrări.adăugați (pereche nouă< > („C”, 20));
intrări.adăugați (pereche nouă< > („C++”, 30));
// print prima pereche folosind getKey() și getValue () metoda
sistem.afară.println („{„+intrări.obține (0).getKey() + „, ” +
intrări.obține (0).getValue ()+”}”);
/ / imprimare a doua pereche folosind getKey() și getValue() metoda
sistem.afară.println („{„+intrări.obține(1).getKey() + „, ” +
intrări.obține(1).getValue() + „}”);
}
}
|
Descărcați codul
ieșire:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library oferă,de asemenea, o pereche< L, R> clasa de utilitate ale cărei elemente sunt la stânga și la dreapta. Este definit ca abstract și implementează harta.Interfață de intrare unde cheia este lăsată și valoarea este corectă.
are pereche.de () metodă care poate fi utilizată pentru a obține o pereche imuabilă de la perechea specificată de obiecte. Subclasa sa MutablePair este mutabil, în timp ce ImmutablePair este imuabil. Cu toate acestea, tipul obiectului stocat în Imutabilpair poate fi în sine mutabil.
|
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.apache.commons.lang3.tuplu.ImmutablePair;
import org.apache.commons.lang3.tuplu.MutablePair;
import org.apache.commons.lang3.tuplu.Pereche;
import java.util.ArrayList;
import java.util.Listă;
clasa tuplu
{
// demonstrați clasa pereche furnizată Apache Commons Library în Java
public static void main(string args)
{
listă <pereche <șir, număr întreg>> intrări = nou ArrayList<>();
intrări.adăugați (noi MutablePair<> („C”, 20)); // folosind intrări MutablePair
.adăugați (noi ImmutablePair<>(„C++”, 30)); // folosind immutablepair
intrări.adăugați (pereche.de(„Java”, 50)); // folosind pereche.din ()
sistem.afară.println(intrări);
// 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”);
}
// imprimarea pereche folosind getLeft () și GetRight () metoda
sistem.afară.println(pereche.getLeft ()+”, ” + pereche.getRight());
// 3. a treia pereche este, de asemenea, imuabilă
pair = intrări.obține(2);
încercați {
pereche.setValue (100); / / eroare de rulare
}
captură (UnsupportedOperationException ex) {
sistem.afară.println („UnsupportedOperationException aruncat”);
}
sistem.afară.println(pereche.getLeft ()+”, ” + pereche.getRight());
}
}
|
Descarca Cod
ieșire:
C, 100
UnsupportedOperationException aruncat
C++, 30
UnsupportedOperationException aruncat
Java, 50
Biblioteca JavaTuples
Javatuples este o altă bibliotecă java faimoasă și simplă care se ocupă de tupluri. Acesta oferă un set de clase java tuple variind de la unu la zece elemente. Pentru a servi scopului nostru, putem folosi pereche< A,B> clasă.
|
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.Pereche;
import java.util.ArrayList;
import java.util.Listă;
clasa tuplu
{
// demonstrați clasa pereche furnizată Biblioteca JavaTuples în Java
public static void main (string args)
{
listă <pereche <șir, număr întreg>> perechi = nou ArrayList<>();
perechi.adăugați (pereche.cu („Java”, 50)); / / folosind pereche.cu ()
perechi.adăugați (pereche nouă<> („C++”, 30)); // folosind Constructori
/ / imprimați prima pereche folosind getValue0() și getValue1() metoda
sistem.afară.println („{„+perechi.obține (0).getValue0() + „, ” +
perechi.obține (0).getValue1() + „}”);
// imprimare a doua pereche folosind getValue0() și getValue1() metoda
sistem.afară.println („{„+perechi.obține(1).getValue0() + „, ” +
perechi.obține(1).getValue1() + „}”);
}
}
|
Descărcați codul
ieșire:
{Java, 50}
{C++, 30}
colecții.singletonMap()
o altă abordare este utilizarea colecțiilor.singletonMap () în Java, care este similar cu harta.Intrare<K,V > discutat mai devreme. Returnează o hartă singleton imuabilă care conține doar maparea perechii cheie-valoare specificată, care poate fi tratată ca o pereche.
|
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;
pereche de clasă
{
// returnați o hartă singleton imuabilă care conține doar maparea perechii
// cheie-valoare specificată
static public <T, U> hartă<T, U> din (T primul, U al doilea)
{
colecții de returnare.singletonMap(primul, al doilea);
}
}
clasa tuplu
{
// implementați clasa pereche în Java folosind colecții.singletonMap()
publice statice void principal (șir args)
{
Set < hartă<șir, întreg >> intrări = HashSet nou<>();
intrări.adăugați (pereche.din („Java”, 50));
intrări.adăugați (pereche.din („C++”, 30));
sistem.afară.println(intrări);
}
}
|
Descarca Run Cod
ieșire:
în cele din urmă, în proiectele Android, putem folosi android.util.Clasa pereche furnizată de SDK-ul Android.