Cinque alternative alla Classe Pair in Java
Una coppia è un contenitore per memorizzare una tupla di due oggetti. Java in realtà non fornisce alcuna implementazione della classe Pair. In questo post, discuteremo di varie alternative alla classe Pair in Java.
La coppia è spesso utile per tenere traccia di due oggetti insieme. Contiene due campi, solitamente definiti come primo e secondo, che sono in grado di memorizzare qualsiasi cosa. Nonostante non abbia alcuna relazione significativa tra il primo e il secondo campo, i programmatori spesso perdono questa funzionalità in Java.
Nel post precedente, abbiamo discusso come implementare la nostra classe Pair in Java. In questo post, discuteremo soluzioni alternative disponibili in Java per colmare il divario desiderato, come discusso di seguito:
Mappa.Voce < K, V > Interfaccia
Possiamo usare Mappa.Voce< K,V > interfaccia in Java che è simile a std:: pair in C++. È un eccellente esempio di avere un nome significativo che rappresenta una coppia chiave-valore.
Per creare una voce che rappresenta una mappatura dalla chiave specificata al valore specificato, Java fornisce due implementazioni concrete della mappa.Interfaccia di ingresso, vale a dire, AbstractMap.SimpleEntry e AbstractMap.Sempliceimmutableentry.
|
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;
importa java.util.HashSet;
importa java.util.Mappa;
importa java.util.Set;
Coppia di classe
{
// Restituisce una voce mappa (coppia chiave-valore) dai valori specificati
public static <T, U> Map.Voce< T, U > di (T prima, U seconda)
{
restituisce una nuova AbstractMap.SimpleEntry< > (primo, secondo);
}
}
tupla di classe
{
// Implementare la classe Pair in Java utilizzando Map.Voce
public static void main (String args)
{
Imposta < Mappa.Voce < Stringa, Intero> > voci = nuovo HashSet<>();
voci.aggiungi (Coppia.di (“Java”, 50));
voci.aggiungi (Coppia.di (“C++”, 30));
Sistema.fuori.println (voci);
// funziona in Java 8 e versioni successive solo
voci.forEach(voce -> {
se (voce.getKey ().equals (“Java”))
Sistema.fuori.println (voce.Ottieni VALORE());
});
}
}
|
Scarica Codice di esecuzione
Uscita:
50
Java 8-javafx.util.Pair
Infine, dopo una lunga attesa,una coppia<K, V> classe viene aggiunto in Java 8 in javafx.pacchetto util. La classe rappresenta coppie chiave-valore e supporta operazioni di base come getKey (), getValue (), hashCode (), equals(java.lang.Object o) e toString () e ha pochi metodi ereditati da java.lang.Classe oggetto. Beh, qualcosa e ‘ meglio di niente, eh?.
|
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;
tupla di classe
{
// Dimostrare javafx.util.Classe Pair introdotta in Java 8 e versioni successive
public static void main (String args)
{
List < Pair < String, Integer> > entries = new ArrayList<>();
voci.aggiungi (nuova coppia<> (“C”, 20));
voci.aggiungi (nuova coppia<> (“C++”, 30));
// stampa prima coppia utilizzando getKey() e getValue () metodo
Sistema.fuori.println (“{“+voci.ottieni (0).Chiave() + “, ” +
voci.ottieni (0).getValue ()+”}”);
/ / stampa seconda coppia utilizzando getKey() e getValue () metodo
Sistema.fuori.println (“{“+voci.ottieni(1).Chiave() + “, ” +
voci.ottieni(1).getValue() + “}”);
}
}
|
il Codice per il Download
Output:
{C, 20}
{C++, 30}
Apache Commons Lang Libreria
Apache Commons Lang Biblioteca fornisce anche una Coppia<L,R> utilità di classe i cui elementi sono di destra e di sinistra. È definito come astratto e implementa la mappa.Interfaccia di ingresso in cui la chiave è a sinistra e il valore è giusto.
Ha coppia.of () metodo che può essere utilizzato per ottenere una coppia immutabile di da coppia specificata di oggetti. La sua sottoclasse MutablePair è mutabile mentre ImmutablePair è immutabile. Tuttavia, il tipo di oggetto memorizzato in ImmutablePair può essere mutabile.
|
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.comune.lang3.tupla.ImmutablePair;
importa org.Apache.comune.lang3.tupla.MutablePair;
importa org.Apache.comune.lang3.tupla.Pair;
importa java.util.ArrayList;
importa java.util.Elenco;
classe Tupla
{
// Dimostrare Coppia di classe, disponibile Apache Commons Libreria in Java
public static void main(String args)
{
Elenco<Coppia<String, Integer>> voci = new ArrayList<>();
non valide.aggiungi (new MutablePair<> (“C”, 20)); // usando le voci MutablePair
.aggiungi (new ImmutablePair<> (“C++”, 30)); // utilizzando ImmutablePair
voci.aggiungi (Coppia.di (“Java”, 50)); // usando la coppia.di ()
Sistema.fuori.println (voci);
// 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”);
}
// stampa coppia utilizzando getLeft() e getRight () metodo
Sistema.fuori.println (coppia.getLeft ()+”, ” + coppia.getRight());
// 3. anche la terza coppia è immutabile
pair = entries.prendi(2);
prova {
coppia.setValue (100); / / errore di runtime
}
catch (UnsupportedOperationException ex) {
Sistema.fuori.println (“UnsupportedOperationException generata”);
}
Sistema.fuori.println (coppia.getLeft ()+”, ” + coppia.getRight ());
}
}
|
il Codice per il Download
Output:
C, 100
UnsupportedOperationException gettato
C++, 30
UnsupportedOperationException gettato
Java, 50
JavaTuples Libreria
Javatuples è un altro famoso e semplice libreria java che si occupa di tuple. Esso fornisce un insieme di classi tupla java che vanno da uno a dieci elementi. Per servire il nostro scopo, possiamo usare la classe 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.Pair;
importa java.util.ArrayList;
importa java.util.Elenco;
classe Tupla
{
// Dimostrare Coppia di classe, disponibile JavaTuples Libreria in Java
public static void main(String args)
{
Elenco<Coppia<String, Integer>> coppie = new ArrayList<>();
le coppie.aggiungi (Coppia.con (“Java”, 50)); / / usando la coppia.con ()
coppie.add (new Pair<> (“C++”, 30)); // usando i costruttori
/ / stampa la prima coppia usando il metodo getValue0() e getValue1 ()
System.fuori.println (“{“+coppie.ottieni (0).getValue0() + “, ” +
coppie.ottieni (0).getValue1() + “}”);
// stampa seconda coppia utilizzando getValue0() e getValue1 () metodo
Sistema.fuori.println (“{“+coppie.ottieni(1).getValue0() + “, ” +
coppie.ottieni(1).getValue1() + “}”);
}
}
|
Scarica codice
Uscita:
{Java, 50}
{C++, 30}
Collezioni.singletonMap ()
Un altro approccio consiste nell’utilizzare le Raccolte.singletonMap () in Java che è simile a Map.Voce< K,V > discusso in precedenza. Restituisce una mappa singleton immutabile contenente solo la mappatura coppia chiave-valore specificata, che può essere trattata come una coppia.
|
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;
importa java.util.Set;
Coppia di classe
{
// Restituisce una mappa singleton immutabile contenente solo la
// mappatura coppia chiave-valore
statica pubblica < T, U > Mappa < T, U > di (T prima, U seconda)
{
collezioni di ritorno.singletonMap(primo, secondo);
}
}
tupla di classe
{
// Implementare classe Pair in Java utilizzando collezioni.singletonMap()
public static void main (String args)
{
Imposta < Mappa < Stringa, Intero> > voci = nuovo HashSet<>();
voci.aggiungi (Coppia.di (“Java”, 50));
voci.aggiungi (Coppia.di (“C++”, 30));
Sistema.fuori.println (voci);
}
}
|
Scarica Codice di esecuzione
Uscita:
Infine, nei progetti Android, possiamo usare Android.util.Coppia classe fornita dal SDK Android.