💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Pairs sind eine Möglichkeit, gepaarte Daten zu speichern, die aus zwei Feldern bestehen - einem für den Schlüssel und einem für den Wert. In Java sind Pairs eine ausgezeichnete Möglichkeit, mehrere Werte aus einer Methode zurückzugeben. Es gibt zahlreiche Möglichkeiten, Pairs in Java zu verwenden. In diesem Lab werden Schritt-für-Schritt-Anleitungen sowie Codebeispiele zur Verwendung von Pairs in Java bereitgestellt.
Erstellen Sie eine neue Java-Klasse mit dem folgenden Befehl:
cd ~/project && touch PairsInJava.javaJavaFX bietet eine integrierte Pair-Klasse, die verwendet werden kann, um mit Paaren umzugehen. In diesem Schritt werden wir lernen, wie die Pair-Klasse verwendet wird, um Paare zu erstellen und zu manipulieren. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
import javafx.util.Pair;
public class PairsInJava {
public static void main(String[] args) {
Pair<String, Integer> p1 = new Pair<>("apple", 1);
Pair<String, Integer> p2 = new Pair<>("banana", 2);
System.out.println("p1=" + p1.toString());
System.out.println("p2=" + p2.toString());
System.out.println("key of p1=" + p1.getKey());
System.out.println("value of p1=" + p1.getValue());
}
}Im obigen Code verwenden wir die Pair-Klasse, um zwei Paare zu erstellen und geben dann jeweils ihren Schlüssel und Wert aus.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac PairsInJava.java && java PairsInJavaIn diesem Schritt werden wir lernen, wie man Objektarrays implementiert, um in Java Paare zu erstellen. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
public class PairsInJava {
public static void main(String[] args) {
Object[] p1 = {"apple", 1};
Object[] p2 = {"banana", 2};
System.out.println("p1=" + p1[0] + "," + p1[1]);
System.out.println("p2=" + p2[0] + "," + p2[1]);
}
}Im obigen Code verwenden wir ein Objektarray, um zwei Paare zu erstellen und geben dann jeweils ihren Schlüssel und Wert aus.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac PairsInJava.java && java PairsInJavaIn diesem Schritt werden wir lernen, wie man eine benutzerdefinierte Pair-Klasse implementiert, um in Java Paare zu erstellen. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
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<>("apple", 1);
MyPair<String, Integer> p2 = new MyPair<>("banana", 2);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
System.out.println("p2=" + p2.getKey() + "," + p2.getValue());
}
}Im obigen Code definieren wir eine benutzerdefinierte Klasse MyPair, um Paare zu erstellen und geben dann jeweils ihren Schlüssel und Wert aus.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac PairsInJava.java && java PairsInJavaIn diesem Schritt werden wir lernen, wie man ein Paar mit der AbstractMap.SimpleEntry-Klasse erstellt. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
import java.util.AbstractMap;
public class PairsInJava {
public static void main(String[] args) {
AbstractMap.SimpleEntry<String, Integer> p1 = new AbstractMap.SimpleEntry<>("apple", 1);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
p1.setValue(2);
System.out.println("new p1=" + p1.getKey() + "," + p1.getValue());
}
}Im obigen Code verwenden wir die AbstractMap.SimpleEntry-Klasse, um ein Paar zu erstellen und ändern dann seinen Wert.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac PairsInJava.java && java PairsInJavaIn diesem Schritt werden wir lernen, wie man ein unveränderliches Paar mit der AbstractMap.SimpleImmutableEntry-Klasse erstellt. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
import java.util.AbstractMap;
public class PairsInJava {
public static void main(String[] args) {
AbstractMap.SimpleImmutableEntry<String, Integer> p1 = new AbstractMap.SimpleImmutableEntry<>("apple", 1);
System.out.println("p1=" + p1.getKey() + "," + p1.getValue());
// kann den Wert nicht setzen
// p1.setValue(2);
}
}Im obigen Code verwenden wir die AbstractMap.SimpleImmutableEntry-Klasse, um ein unveränderliches Paar zu erstellen. Wir können seinen Schlüssel und Wert nicht mehr ändern, nachdem sie initialisiert wurden.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac PairsInJava.java && java PairsInJavaIn diesem Schritt werden wir lernen, wie man die Pair-Klasse aus der javatuples-Bibliothek verwendet, um Paare zu erstellen. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
import org.javatuples.Pair;
public class PairsInJava {
public static void main(String[] args) {
Pair<String, Integer> p1 = Pair.with("apple", 1);
Pair<String, Integer> p2 = Pair.with("banana", 2);
System.out.println("p1=" + p1.getValue0() + "," + p1.getValue1());
System.out.println("p2=" + p2.getValue0() + "," + p2.getValue1());
}
}Im obigen Code verwenden wir die Pair-Klasse aus der javatuples-Bibliothek, um für jedes Paar Schlüssel und Wert zu erstellen und auszugeben.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac -cp.:javatuples-1.2.jar PairsInJava.java && java -cp.:javatuples-1.2.jar PairsInJavaIn diesem Schritt werden wir lernen, wie man die Tuple2-Klasse aus der Vavr-Bibliothek verwendet, um Paare zu erstellen. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
import io.vavr.Tuple2;
public class PairsInJava {
public static void main(String[] args) {
Tuple2<String, Integer> p1 = new Tuple2<>("apple", 1);
System.out.println("p1=" + p1._1() + "," + p1._2());
}
}Im obigen Code verwenden wir die Tuple2-Klasse aus der Vavr-Bibliothek, um den Schlüssel und den Wert eines Paars zu erstellen und auszugeben.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac -cp.:vavr-0.10.3.jar PairsInJava.java && java -cp.:vavr-0.10.3.jar PairsInJavaIn diesem Schritt werden wir lernen, wie man die Klassen MutablePair und ImmutablePair aus der Apache Commons-Bibliothek verwendet, um Paare zu erstellen und zu manipulieren. Fügen Sie den folgenden Code in Ihre PairsInJava.java-Datei hinzu:
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<>("apple", 1);
ImmutablePair<String, Integer> p2 = new ImmutablePair<>("banana", 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());
// kann keine Werte für das unveränderliche Paar setzen
// p2.setLeft("kiwi");
p2 = p2.withLeft("kiwi");
System.out.println("new p2=" + p2.getLeft() + "," + p2.getRight());
}
}Im obigen Code verwenden wir die Klassen MutablePair und ImmutablePair aus der Apache Commons-Bibliothek, um Paare zu erstellen und dann ihren Schlüssel und Wert zu ändern.
Um den Code zu kompilieren und auszuführen, führen Sie folgenden Befehl aus:
javac -cp.:commons-lang3-3.13.0.jar PairsInJava.java && java -cp.:commons-lang3-3.13.0.jar PairsInJavaPaare sind eine einfache Möglichkeit, zwei Datenobjekte zu speichern, die eine Zuordnung zueinander haben. In diesem Lab haben wir verschiedene Klassen und Methoden verwendet, um Paare in Java zu implementieren. Einige populäre Methoden sind das Verwenden von externen Bibliotheken wie der Apache Commons- oder der Vavr-Bibliothek, das Verwenden der inbauten JavaFX-Pair-Klasse, das Erstellen einer benutzerdefinierten Pair-Klasse und das Verwenden von Objektarrays.
