Pares são uma forma de armazenar dados emparelhados, consistindo em dois campos - um para a chave (key) e outro para o valor (value). Em Java, pares são uma ótima maneira de retornar múltiplos valores de um método. Existem muitas maneiras de usar pares em Java. Este laboratório fornecerá orientação passo a passo sobre como usar pares em Java com exemplos de código.
Crie uma nova classe Java usando o seguinte comando:
cd ~/project && touch PairsInJava.javaJavaFX fornece uma classe Pair integrada, que pode ser usada para trabalhar com pares. Nesta etapa, aprenderemos como usar a classe Pair para criar e manipular pares. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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());
}
}No código acima, usamos a classe Pair para criar dois pares e, em seguida, imprimimos sua key e value para cada par.
Para compilar e executar o código, execute o seguinte comando:
javac PairsInJava.java && java PairsInJavaNesta etapa, aprenderemos como implementar arrays de objetos para criar pares em Java. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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]);
}
}No código acima, usamos um array de objetos para criar dois pares e, em seguida, imprimimos sua key e value para cada par.
Para compilar e executar o código, execute o seguinte comando:
javac PairsInJava.java && java PairsInJavaNesta etapa, aprenderemos como implementar uma classe pair definida pelo usuário para criar pares em Java. Adicione o seguinte código ao seu arquivo 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<>("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());
}
}No código acima, definimos uma classe customizada MyPair para criar pares e, em seguida, imprimimos sua key e value para cada par.
Para compilar e executar o código, execute o seguinte comando:
javac PairsInJava.java && java PairsInJavaNesta etapa, aprenderemos como criar um par usando a classe AbstractMap.SimpleEntry. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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());
}
}No código acima, usamos a classe AbstractMap.SimpleEntry para criar um par e, em seguida, modificar seu valor.
Para compilar e executar o código, execute o seguinte comando:
javac PairsInJava.java && java PairsInJavaNesta etapa, aprenderemos como criar um par imutável usando a classe AbstractMap.SimpleImmutableEntry. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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());
// cannot set the value
// p1.setValue(2);
}
}No código acima, usamos a classe AbstractMap.SimpleImmutableEntry para criar um par imutável. Não podemos modificar sua key e value depois que foram inicializados.
Para compilar e executar o código, execute o seguinte comando:
javac PairsInJava.java && java PairsInJavaNesta etapa, aprenderemos como usar a classe Pair da biblioteca javatuples para criar pares. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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());
}
}No código acima, usamos a classe Pair da biblioteca javatuples para criar e imprimir a key e o value para cada par.
Para compilar e executar o código, execute o seguinte comando:
javac -cp .:javatuples-1.2.jar PairsInJava.java && java -cp .:javatuples-1.2.jar PairsInJavaNesta etapa, aprenderemos como usar a classe Tuple2 da biblioteca Vavr para criar pares. Adicione o seguinte código ao seu arquivo PairsInJava.java:
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());
}
}No código acima, usamos a classe Tuple2 da biblioteca Vavr para criar e imprimir a key e o value de um par.
Para compilar e executar o código, execute o seguinte comando:
javac -cp .:vavr-0.10.3.jar PairsInJava.java && java -cp .:vavr-0.10.3.jar PairsInJavaNesta etapa, aprenderemos como usar as classes MutablePair e ImmutablePair da biblioteca Apache Commons para criar e manipular pares. Adicione o seguinte código ao seu arquivo 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<>("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());
// cannot set values for immutable pair
// p2.setLeft("kiwi");
p2 = p2.withLeft("kiwi");
System.out.println("new p2=" + p2.getLeft() + "," + p2.getRight());
}
}No código acima, usamos as classes MutablePair e ImmutablePair da biblioteca Apache Commons para criar pares e, em seguida, modificar sua key e value.
Para compilar e executar o código, execute o seguinte comando:
javac -cp .:commons-lang3-3.13.0.jar PairsInJava.java && java -cp .:commons-lang3-3.13.0.jar PairsInJavaPares são uma maneira simples de armazenar dois itens de dados que possuem um mapeamento entre eles. Neste laboratório, usamos diferentes classes e métodos para implementar pares em Java. Algumas das formas populares são usar bibliotecas externas como Apache Commons ou a biblioteca Vavr, usar a classe JavaFX Pair integrada, criar uma classe de par personalizada e usar arrays de objetos.
