Implementare la classe Pair in Java

In questo post, vedremo come implementare la nostra Classe Pair in Java.

Una coppia è un contenitore per memorizzare una tupla di due oggetti. Il JDK non fornisce alcuna implementazione della classe Pair. Ciò potrebbe essere dovuto al fatto che la classe Pair non specifica la relazione tra i valori specificati. Prendiamo un esempio di std:: pair in C++, dove il suo primo e secondo campo possono essere qualsiasi cosa. C++ non indica cosa memorizza la classe della coppia di dati. In Java, Map.Entry è un esempio eccellente che ha un nome significativo che rappresenta una coppia chiave-valore.

Pur non avendo alcuna relazione significativa tra i dati memorizzati nella coppia, i programmatori spesso mancano questa funzionalità in Java. Ci sono soluzioni alternative, come discusso qui in dettaglio, per colmare il divario. Ma non sarebbe bello implementare la nostra classe Pair in Java che possiamo personalizzare secondo il nostro stile.

Scrivere bene una classe Pair è in realtà molto semplice in Java. Di seguito è riportata una semplice implementazione personalizzata della classe Pair in Java che ha

  1. Due campi pubblici – first e second, proprio come in C++.
  2. Un costruttore privato.
  3. Un metodo di fabbrica statico of() per creare un’istanza immutabile, digitata Pair (che chiama internamente il costruttore privato).
  4. Metodi hashcode() ed equals() sovrascritti per garantire il comportamento desiderato nelle raccolte basate su hash.
  5. Sovrascritto toString() metodo per stampare facilmente l’oggetto Pair.
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

importa java.util.ArrayList;
importa java.util.HashSet;
importa java.util.Elenco;
importa java.util.Set;
// Coppia di classe
classe Coppia<U, V>
{
public final U primo; // primo campo di una Coppia
public final V secondo; // secondo campo di una Coppia
// Costruisce una nuova Coppia con valori specificati
privato Coppia(U primo, V seconda)
{
questo.primo = primo;
questo.secondo = secondo;
}
@Override
/ / Controlla che l’oggetto specificato sia “uguale a” oggetto corrente o meno
public boolean equals(Object o)
{
se (questo == o)
restituisce true;
se (o == null || getClass ()!= o. getClass())
restituisce false;
Coppia<?, ?> coppia = (Coppia<?, ?>) o;
// call equals() metodo degli oggetti sottostanti
if (!prima.uguale (coppia.in primo luogo))
ritorno falso;
ritorno secondo.uguale (coppia.secondo);
}
@Override
/ / Calcola il codice hash per un oggetto per supportare le tabelle hash
public int hashCode()
{
// utilizzare i codici hash degli oggetti sottostanti
restituire 31 * prima.hashCode () + secondo.hashCode();
}
@Override
Stringa pubblica toString()
{
ritorno “(” + primo + “, ” + secondo + “)”;
}
// metodo Factory per la creazione di un Digitato Coppia immutabile istanza
public static <U, V> Coppia <U, V> di(U, V b)
{
// chiamate costruttore privato
return new Coppia<>(a, b);
}
}
// Programma per implementare Paio di Classe in Java
classe Principale
{
public static void main(String args)
{
Coppia<String, Integer> p1 = Coppia.di (“Giovanni”, 26);
Coppia < Stringa, Intero > p2 = Coppia.di (“Tom”, 30);
Coppia < Stringa, Intero > p3 = Coppia.di (“Giovanni”, 26);
List < Pair < String, Integer> > pairs = new ArrayList<>();
coppie.aggiungi (p1);
coppie.aggiungi (p2);
coppie.aggiungi (p3);
Sistema.fuori.println(pairs);
Set<Pair<String, Integer>> distinctPairs = new HashSet<>(pairs);
System.fuori.println (distinctPairs);
}
}

Scarica Codice di esecuzione

Uscita:

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.