Les paires sont un moyen de stocker des données appariées, composée de deux champs - l'un pour la clé et l'autre pour la valeur. En Java, les paires sont un excellent moyen de renvoyer plusieurs valeurs à partir d'une méthode. Il existe de nombreux moyens d'utiliser les paires en Java. Ce laboratoire fournira des instructions étape par étape sur la manière d'utiliser les paires en Java avec des exemples de code.
Créez une nouvelle classe Java en utilisant la commande suivante :
cd ~/projet && touch PairsInJava.javaJavaFX fournit une classe Pair intégrée, qui peut être utilisée pour travailler avec des paires. Dans cette étape, nous allons apprendre à utiliser la classe Pair pour créer et manipuler des paires. Ajoutez le code suivant à votre fichier PairsInJava.java :
import javafx.util.Pair;
public class PairsInJava {
public static void main(String[] args) {
Pair<String, Integer> p1 = new Pair<>("pomme", 1);
Pair<String, Integer> p2 = new Pair<>("banane", 2);
System.out.println("p1=" + p1.toString());
System.out.println("p2=" + p2.toString());
System.out.println("clé de p1=" + p1.getKey());
System.out.println("valeur de p1=" + p1.getValue());
}
}Dans le code ci-dessus, nous utilisons la classe Pair pour créer deux paires puis imprimons leur clé et leur valeur pour chaque paire.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac PairsInJava.java && java PairsInJavaDans cette étape, nous allons apprendre à implémenter des tableaux d'objets pour créer des paires en Java. Ajoutez le code suivant à votre fichier PairsInJava.java :
public class PairsInJava {
public static void main(String[] args) {
Object[] p1 = {"pomme", 1};
Object[] p2 = {"banane", 2};
System.out.println("p1=" + p1[0] + "," + p1[1]);
System.out.println("p2=" + p2[0] + "," + p2[1]);
}
}Dans le code ci-dessus, nous utilisons un tableau d'objets pour créer deux paires puis imprimons leur clé et leur valeur pour chaque paire.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac PairsInJava.java && java PairsInJavaDans cette étape, nous allons apprendre à implémenter une classe de paire définie par l'utilisateur pour créer des paires en Java. Ajoutez le code suivant à votre fichier PairsInJava.java :
class MyPair<T1, T2> {
private T1 key;
private T2 value;
public MyPair(T1 key, T2 value) {
this.key = key;
this.value = value;
}
public T1 getKey() {
return key;
}
public T2 getValue() {
return value;
}
public void setKey(T1 key) {
this.key = key;
}
public void setValue(T2 value) {
this.value = value;
}
}
public class PairsInJava {
public static void main(String[] args) {
MyPair<String, Integer> p1 = new MyPair<>("pomme", 1);
MyPair<String, Integer> p2 = new MyPair<>("banane", 2);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
System.out.println("p2=" + p2.getKey() + "," + p2.getValue());
}
}Dans le code ci-dessus, nous définissons une classe personnalisée MyPair pour créer des paires puis imprimons leur clé et leur valeur pour chaque paire.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac PairsInJava.java && java PairsInJavaDans cette étape, nous allons apprendre à créer une paire à l'aide de la classe AbstractMap.SimpleEntry. Ajoutez le code suivant à votre fichier PairsInJava.java :
import java.util.AbstractMap;
public class PairsInJava {
public static void main(String[] args) {
AbstractMap.SimpleEntry<String, Integer> p1 = new AbstractMap.SimpleEntry<>("pomme", 1);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
p1.setValue(2);
System.out.println("new p1=" + p1.getKey() + "," + p1.getValue());
}
}Dans le code ci-dessus, nous utilisons la classe AbstractMap.SimpleEntry pour créer une paire puis modifier sa valeur.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac PairsInJava.java && java PairsInJavaDans cette étape, nous allons apprendre à créer une paire immuable à l'aide de la classe AbstractMap.SimpleImmutableEntry. Ajoutez le code suivant à votre fichier PairsInJava.java :
import java.util.AbstractMap;
public class PairsInJava {
public static void main(String[] args) {
AbstractMap.SimpleImmutableEntry<String, Integer> p1 = new AbstractMap.SimpleImmutableEntry<>("pomme", 1);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
// impossible de définir la valeur
// p1.setValue(2);
}
}Dans le code ci-dessus, nous utilisons la classe AbstractMap.SimpleImmutableEntry pour créer une paire immuable. Nous ne pouvons pas modifier sa clé et sa valeur une fois qu'elles ont été initialisées.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac PairsInJava.java && java PairsInJavaDans cette étape, nous allons apprendre à utiliser la classe Pair de la bibliothèque javatuples pour créer des paires. Ajoutez le code suivant à votre fichier PairsInJava.java :
import org.javatuples.Pair;
public class PairsInJava {
public static void main(String[] args) {
Pair<String, Integer> p1 = Pair.with("pomme", 1);
Pair<String, Integer> p2 = Pair.with("banane", 2);
System.out.println("p1=" + p1.getValue0() + "," + p1.getValue1());
System.out.println("p2=" + p2.getValue0() + "," + p2.getValue1());
}
}Dans le code ci-dessus, nous utilisons la classe Pair de la bibliothèque javatuples pour créer et imprimer la clé et la valeur de chaque paire.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac -cp.:javatuples-1.2.jar PairsInJava.java && java -cp.:javatuples-1.2.jar PairsInJavaDans cette étape, nous allons apprendre à utiliser la classe Tuple2 de la bibliothèque Vavr pour créer des paires. Ajoutez le code suivant à votre fichier PairsInJava.java :
import io.vavr.Tuple2;
public class PairsInJava {
public static void main(String[] args) {
Tuple2<String, Integer> p1 = new Tuple2<>("pomme", 1);
System.out.println("p1=" + p1._1() + "," + p1._2());
}
}Dans le code ci-dessus, nous utilisons la classe Tuple2 de la bibliothèque Vavr pour créer et imprimer la clé et la valeur d'une paire.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac -cp.:vavr-0.10.3.jar PairsInJava.java && java -cp.:vavr-0.10.3.jar PairsInJavaDans cette étape, nous allons apprendre à utiliser les classes MutablePair et ImmutablePair de la bibliothèque Apache Commons pour créer et manipuler des paires. Ajoutez le code suivant à votre fichier PairsInJava.java :
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.MutablePair;
public class PairsInJava {
public static void main(String[] args) {
MutablePair<String, Integer> p1 = new MutablePair<>("pomme", 1);
ImmutablePair<String, Integer> p2 = new ImmutablePair<>("banane", 2);
System.out.println("p1=" + p1.getLeft() + "," + p1.getRight());
System.out.println("p2=" + p2.getLeft() + "," + p2.getRight());
p1.setLeft("orange");
p1.setRight(3);
System.out.println("new p1=" + p1.getLeft() + "," + p1.getRight());
// impossible de définir des valeurs pour une paire immuable
// p2.setLeft("kiwi");
p2 = p2.withLeft("kiwi");
System.out.println("new p2=" + p2.getLeft() + "," + p2.getRight());
}
}Dans le code ci-dessus, nous utilisons les classes MutablePair et ImmutablePair de la bibliothèque Apache commons pour créer des paires puis modifier leur clé et leur valeur.
Pour compiler et exécuter le code, exécutez la commande suivante :
javac -cp.:commons-lang3-3.13.0.jar PairsInJava.java && java -cp.:commons-lang3-3.13.0.jar PairsInJavaLes paires sont un moyen simple de stocker deux éléments de données qui ont une relation de correspondance entre eux. Dans ce laboratoire, nous avons utilisé différentes classes et méthodes pour implémenter des paires en Java. Certaines des méthodes les plus populaires sont l'utilisation de bibliothèques externes telles que la bibliothèque Apache Commons ou la bibliothèque Vavr, l'utilisation de la classe Pair intégrée à JavaFX, la création d'une classe de paire personnalisée et l'utilisation de tableaux d'objets.
