Utilizando Pares en la Programación Java

Introducción

Los pares son una forma de almacenar datos emparejados, que constan de dos campos: uno para la clave y otro para el valor. En Java, los pares son una excelente manera de devolver múltiples valores desde un método. Hay muchas maneras de utilizar pares en Java. Esta práctica proporcionará una guía paso a paso sobre cómo utilizar pares en Java con ejemplos de código.

Skills Graph

Crear una clase Java

Crea una nueva clase Java con el siguiente comando:

cd ~/proyecto && touch PairsInJava.java

Implementar la clase Pair del paquete JavaFX.Util

JavaFX proporciona una clase Pair incorporada que se puede utilizar para trabajar con pares. En este paso, aprenderemos cómo utilizar la clase Pair para crear y manipular pares. Agrega el siguiente código a tu archivo 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());
    }
}

En el código anterior, utilizamos la clase Pair para crear dos pares y luego imprimimos su clave y valor para cada par.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac PairsInJava.java && java PairsInJava

Implementar arrays de objetos para crear pares en Java

En este paso, aprenderemos cómo implementar arrays de objetos para crear pares en Java. Agrega el siguiente código a tu archivo 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]);
    }
}

En el código anterior, utilizamos un array de objetos para crear dos pares y luego imprimimos su clave y valor para cada par.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac PairsInJava.java && java PairsInJava

Implementar una clase de par definida por el usuario

En este paso, aprenderemos cómo implementar una clase de par definida por el usuario para crear pares en Java. Agrega el siguiente código a tu archivo 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());
    }
}

En el código anterior, definimos una clase personalizada MyPair para crear pares y luego imprimimos su clave y valor para cada par.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac PairsInJava.java && java PairsInJava

Implementar la clase AbstractMap.SimpleEntry

En este paso, aprenderemos cómo crear un par utilizando la clase AbstractMap.SimpleEntry. Agrega el siguiente código a tu archivo 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());
    }
}

En el código anterior, utilizamos la clase AbstractMap.SimpleEntry para crear un par y luego modificamos su valor.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac PairsInJava.java && java PairsInJava

Implementar la clase AbstractMap.SimpleImmutableEntry

En este paso, aprenderemos cómo crear un par inmutable utilizando la clase AbstractMap.SimpleImmutableEntry. Agrega el siguiente código a tu archivo 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());
        // no se puede establecer el valor
        // p1.setValue(2);
    }
}

En el código anterior, utilizamos la clase AbstractMap.SimpleImmutableEntry para crear un par inmutable. Una vez inicializados, no podemos modificar su clave y valor.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac PairsInJava.java && java PairsInJava

Implementar la clase Pair de javatuples

En este paso, aprenderemos cómo utilizar la clase Pair de la biblioteca javatuples para crear pares. Agrega el siguiente código a tu archivo 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());
    }
}

En el código anterior, utilizamos la clase Pair de la biblioteca javatuples para crear e imprimir la clave y el valor de cada par.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac -cp.:javatuples-1.2.jar PairsInJava.java && java -cp.:javatuples-1.2.jar PairsInJava

Implementar la clase Tuple2 de la biblioteca Vavr

En este paso, aprenderemos cómo utilizar la clase Tuple2 de la biblioteca Vavr para crear pares. Agrega el siguiente código a tu archivo 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());
    }
}

En el código anterior, utilizamos la clase Tuple2 de la biblioteca Vavr para crear e imprimir la clave y el valor de un par.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac -cp.:vavr-0.10.3.jar PairsInJava.java && java -cp.:vavr-0.10.3.jar PairsInJava

Implementar la biblioteca Apache Commons

En este paso, aprenderemos cómo utilizar las clases MutablePair e ImmutablePair de la biblioteca Apache Commons para crear y manipular pares. Agrega el siguiente código a tu archivo 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());

        // no se pueden establecer valores para el par inmutable
        // p2.setLeft("kiwi");

        p2 = p2.withLeft("kiwi");

        System.out.println("new p2=" + p2.getLeft() + "," + p2.getRight());
    }
}

En el código anterior, utilizamos las clases MutablePair e ImmutablePair de la biblioteca Apache commons para crear pares y luego modificar sus clave y valor.

Para compilar y ejecutar el código, ejecuta el siguiente comando:

javac -cp.:commons-lang3-3.13.0.jar PairsInJava.java && java -cp.:commons-lang3-3.13.0.jar PairsInJava

Resumen

Los pares son una forma simple de almacenar dos elementos de datos que tienen una relación de mapeo entre ellos. En este laboratorio, hemos utilizado diferentes clases y métodos para implementar pares en Java. Algunas de las formas más populares son utilizar bibliotecas externas como Apache Commons o la biblioteca Vavr, utilizar la clase Pair de JavaFX integrada, crear una clase de par personalizada y utilizar arrays de objetos.