Cinq Alternatives à la classe Pair en Java
Une paire est un conteneur pour stocker un tuple de deux objets. Java ne fournit pas vraiment d’implémentation de la classe Pair. Dans cet article, nous discuterons de diverses alternatives à la classe de paire en Java.La paire
est souvent utile pour suivre deux objets ensemble. Il contient deux champs, généralement appelés premier et deuxième, qui sont capables de stocker n’importe quoi. En dépit de l’absence de relation significative entre le premier et le deuxième champ, les programmeurs manquent souvent cette fonctionnalité en Java.
Dans le post précédent, nous avons discuté de la façon d’implémenter notre propre classe de paires en Java. Dans cet article, nous discuterons des solutions de contournement disponibles en Java pour combler l’écart souhaité, comme indiqué ci-dessous:
Map.Entrée < K, V > Interface
Nous pouvons utiliser Map.Entrée < K, V > interface en Java qui est similaire à std::pair en C++. C’est un excellent exemple d’avoir un nom significatif qui représente une paire clé-valeur.
Pour créer une entrée représentant un mappage de la clé spécifiée à la valeur spécifiée, Java fournit deux implémentations concrètes de la Carte.Interface d’entrée, à savoir AbstractMap.SimpleEntry et AbstractMap.Entrée simple et immuable.
|
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;
importer java.util.HashSet;
importer java.util.Carte;
importer java.util.Ensemble;
paire de classes
{
// Renvoie une entrée de carte (paire clé-valeur) à partir des valeurs spécifiées
public static < T, U > Map.Entrée < T, U > de (T premier, U deuxième)
{
renvoie une nouvelle carte abstraite.SimpleEntry < > (premier, deuxième);
}
}
Tuple de classe
{
// Implémentez une classe de paires en Java à l’aide de Map.Entrée
main vide statique publique (arguments de chaîne)
{
Définir la carte <.Entrée < Chaîne, Entier > > entrées = nouveau jeu de hachages<>();
entrées.ajouter (Paire.de (« Java », 50));
entrées.ajouter (Paire.de (« C++ », 30));
Système.hors.println (entrées);
// s’exécute en Java 8 et au-dessus uniquement des entrées
.forEach (entrée -> {
si (entrée.La clé().égal à (« Java »))
Système.hors.println (entrée.La valeur());
});
}
}
|
Télécharger le code d’exécution
Sortie:
50
Java 8 – javafx.util.Pair
Enfin après une longue attente, une classe Pair <K, V> est ajoutée en Java 8 dans javafx.paquet d’util. La classe représente des paires clé-valeur et prend en charge des opérations très basiques comme getKey(), getValue(), hashCode(), equals(java.lang.Object o) et toString() et a peu de méthodes héritées de java.lang.Classe d’objet. Eh bien quelque chose vaut mieux que rien, hein?.
|
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;
Tuple de classe
{
// Démontrer javafx.util.Classe de paires introduite en Java 8 et au-dessus
main vide statique publique (arguments de chaîne)
{
Liste < Paire < Chaîne, Entier > > entrées = new ArrayList<>();
entrées.ajouter (nouvelle paire < > (« C », 20));
entrées.ajouter (nouvelle paire < > (« C++ », 30));
// imprimez la première paire en utilisant le système getKey() et getValue() méthode
.hors.println(« { » + entrées.obtenir (0).Mot de passe() + « , » +
entrées.obtenir (0).La valeur () + « } »);
// imprime la deuxième paire en utilisant la méthode getKey() et la méthode getValue()
System.hors.println(« { » + entrées.obtenez (1).Mot de passe() + « , » +
entrées.obtenez (1).La valeur() + « } »);
}
}
|
Code de téléchargement
Sortie:
{C, 20}
{C++, 30}
Bibliothèque Apache Commons Lang
La bibliothèque Apache Commons Lang fournit également une paire de classes d’utilitaires < L, R > dont les éléments sont à gauche et à droite. Il est défini comme abstrait et implémente la carte.Interface d’entrée où la clé est à gauche et la valeur à droite.
Il a une paire.méthode de () qui peut être utilisée pour obtenir une paire immuable de la paire d’objets spécifiée. Sa sous-classe MutablePair est mutable alors que ImmutablePair est immuable. Cependant, le type de l’objet stocké dans ImmutablePair peut lui-même être mutable.
|
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
|
organisation d’importation.Apache.commun.lang3.tuple.ImmutablePair;
organisation d’importation.Apache.commun.lang3.tuple.MutablePair;
organisation d’importation.Apache.commun.lang3.tuple.Paire;
importer java.util.ArrayList;
importer java.util.Liste;
Tuple de classe
{
// Démontrer la bibliothèque Apache Commons fournie par la classe de paires en Java
main vide statique publique (arguments de chaîne)
{
Liste < Paire < Chaîne, Entier > > entrées = new ArrayList<>();
entrées.add(new MutablePair< >(« C », 20)); // en utilisant les entrées MutablePair
.add(new ImmutablePair< >(« C++ », 30)); // en utilisant les entrées ImmutablePair
.ajouter (Paire.de (« Java », 50)); // en utilisant la paire.du système ()
.hors.println (entrées);
// 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 »);
}
// paire d’impression utilisant le système getLeft() et getRight() méthode
.hors.println (paire.getLeft() + », » + paire.Obtenir());
// 3. la troisième paire est également immuable
pair=entrées.obtenir(2);
essayez la paire {
.setValue(100); // erreur d’exécution
}
catch(UnsupportedOperationException ex) {
Système.hors.println(« UnsupportedOperationException lancée »);
}
Système.hors.println (paire.getLeft() + », » + paire.getRight());
}
}
|
Code de téléchargement
Sortie:
C, 100
Exception d’opération non prise en charge
C++, 30
Exception d’opération non prise en charge
Java, 50
Bibliothèque JavaTuples
Javatuples est une autre bibliothèque java célèbre et simple qui traite des tuples. Il fournit un ensemble de classes java tuple allant de un à dix éléments. Pour servir notre objectif, nous pouvons utiliser 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
|
organisation d’importation.javatuples.Paire;
importer java.util.ArrayList;
importer java.util.Liste;
Tuple de classe
{
// Démontrer la bibliothèque JavaTuples fournie par la classe de paires en Java
main vide statique publique (arguments de chaîne)
{
Liste < Paire < Chaîne, Entier > > paires = new ArrayList<>();
paires.ajouter (Paire.avec (« Java », 50)); // en utilisant la paire.avec ()
paires.add(nouvelle paire < >(« C++ », 30)); // en utilisant les constructeurs
// imprimez la première paire en utilisant la méthode getValue0() et la méthode getValue1()
Système.hors.println(« { » + paires.obtenir (0).Value0() + « , » +
paires.obtenir (0).Value1() + « } »);
// imprimez la deuxième paire en utilisant le système getValue0() et getValue1() méthode
.hors.println(« { » + paires.obtenez (1).Value0() + « , » +
paires.obtenez (1).Value1() + « } »);
}
}
|
Code de téléchargement
Sortie:
{Java, 50}
{C++, 30}
Collections.singletonMap()
Une autre approche consiste à utiliser des collections.singletonMap() en Java qui est similaire à Map.Entrée < K, V > discutée précédemment. Il renvoie une carte singleton immuable contenant uniquement le mappage de paires clé-valeur spécifié, qui peut être traité comme une paire.
|
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;
importer java.util.Ensemble;
paire de classes
{
// Renvoie une carte singleton immuable contenant uniquement la
// mappage de paires clé-valeur
statique publique < T, U > Map <T, U > of (T first, U second)
{
collections de retour.singletonMap (premier, deuxième);
}
}
Tuple de classe
{
// Implémentez la classe Pair en Java à l’aide de Collections.singletonMap()
main vide statique publique (arguments de chaîne)
{
Set < Map < Chaîne, Entier > > entrées = nouveau jeu de hachages<>();
entrées.ajouter (Paire.de (« Java », 50));
entrées.ajouter (Paire.de (« C++ », 30));
Système.hors.println (entrées);
}
}
|
Télécharger le code d’exécution
Sortie:
Enfin, dans les projets Android, nous pouvons utiliser Android.util.Classe de paire fournie par le SDK Android.