Cinco Alternativas a la Clase de pares en Java
Un par es un contenedor para almacenar una tupla de dos objetos. Java realmente no proporciona ninguna implementación de la clase Pair. En este post, discutiremos sobre varias alternativas para Emparejar clases en Java.
El par a menudo es útil para rastrear dos objetos juntos. Contiene dos campos, generalmente denominados como primero y segundo, que son capaces de almacenar cualquier cosa. A pesar de no tener ninguna relación significativa entre el primer y el segundo campo, los programadores a menudo pierden esta funcionalidad en Java.
En el post anterior, hemos discutido cómo implementar nuestra propia clase de Pares en Java. En esta publicación, discutiremos soluciones alternativas disponibles en Java para llenar el vacío deseado, como se explica a continuación:
Map.Entrada< K, V> Interfaz
Podemos usar el mapa.Entrada< K, V> interfaz en Java que es similar a std:: pair en C++. Es un excelente ejemplo de tener un nombre significativo que representa un par clave-valor.
Para crear una entrada que represente una asignación de la clave especificada al valor especificado, Java proporciona dos implementaciones concretas del mapa.Interfaz de entrada, a saber, AbstractMap.SimpleEntry y AbstractMap.Entrada sencilla.
|
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;
importar java.útil.HashSet;
importar java.útil.Map;
importar java.útil.Conjunto;
Par de clase
{
// Devolver una entrada de mapa (par clave-valor) de los valores especificados
public static <T, U> Mapa.Entrada< T, U> de (T primero, U segundo)
{
devuelve un mapa abstracto nuevo.SimpleEntry< >(primero, segundo);
}
}
tupla de clase
{
// Implementar clases de pares en Java usando Map.Entrada
public static void main(String args)
{
Set<Mapa.Entrada< Cadena, Entero> > entradas = nuevo HashSet<>();
entradas.añadir (Par.de («Java», 50));
entradas.añadir (Par.de («C++», 30));
Sistema.fuera.println (entradas);
// se ejecuta en Java 8 y superior solo en entradas
.forEach (entrada -> {
if (entrada.getKey ().equals («Java»))
del sistema.fuera.println (entrada.getValue());
});
}
}
|
Descargar Ejecutar Código
Salida:
50
Java 8 – javafx.útil.Pair
Finalmente, después de una larga espera, se agrega una clase Pair<K,V> en Java 8 en javafx.util paquete. La clase representa pares clave-valor y soporta operaciones muy básicas como getKey (), getValue (), hashCode (), equals(java.lang.Object o) y toString () y tiene pocos métodos heredados de java.lang.Clase de objeto. Bueno algo es mejor que nada, ¿eh?.
|
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;
Tupla {
// Demostrar javafx.útil.Clase de pares introducida en Java 8 y superior
public static void main (String args)
{
Lista< Par< Cadena, Entero>> entradas = nueva ArrayList<>();
entradas.añadir (nuevo par< >(«C», 20));
entradas.añadir (nuevo par< >(«C++», 30));
// imprime el primer par usando el método getKey() y getValue ()
del sistema.fuera.println(«{» + entradas.obtener (0).getKey() + «, » +
entradas.obtener (0).getValue ()+»}»);
/ / imprime el segundo par usando el método getKey() y getValue ()
del sistema.fuera.println(«{» + entradas.obtener (1).getKey() + «, » +
entradas.obtener (1).getValue() + «}»);
}
}
|
Código de descarga
Salida:
{C, 20}
{C++, 30}
Biblioteca Apache Commons Lang
La biblioteca Apache Commons Lang también proporciona un par de clases de utilidad<L,R> cuyos elementos son izquierda y derecha. Se define como abstracto e implementa el Mapa.Interfaz de entrada donde la clave está a la izquierda y el valor a la derecha.
tiene Par.método of () que se puede usar para obtener un par inmutable de un par de objetos especificado. Su subclase MutablePair es mutable, mientras que InmutablePair es inmutable. Sin embargo, el tipo de objeto almacenado en InmutablePair puede en sí mismo ser 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
|
import org.apache.común.lang3.tupla.InmutablePair;
organización de importación.apache.común.lang3.tupla.MutablePair;
organización de importación.apache.común.lang3.tupla.Pair;
importar java.útil.ArrayList;
importar java.útil.Lista;
tupla de clase
{
// Demostrar la biblioteca Apache Commons provista de clases de pares en Java
public static void main (String args)
{
Lista< Par< Cadena, Entero>> entradas = nueva ArrayList<>();
entradas.add(new MutablePair<>(«C», 20)); / / usando entradas MutablePair
.add(new ImmutablePair<>(«C++», 30)); / / usando entradas ImmutablePair
.añadir (Par.of («Java», 50)); / / usando Par.de()
Sistema.fuera.println (entradas);
// 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»);
}
// par de impresión utilizando el método getLeft() y GetRight ()
del sistema.fuera.println(par.getLeft() + «, » + par.Derecho());
// 3. el tercer par también es inmutable
par = entradas.obtener(2);
try {
par.setValue(100); // error en tiempo de ejecución
}
catch (UnsupportedOperationException ex) {
Sistema.fuera.println(«UnsupportedOperationException lanzado»);
}
Sistema.fuera.println(par.getLeft() + «, » + par.GetRight ());
}
}
|
Código de Descarga
Salida:
C, 100
UnsupportedOperationException lanzada
C++, 30
UnsupportedOperationException lanzada
Java, 50
JavaTuples Biblioteca
Javatuples es otro de los famosos y simple de la biblioteca de java que se ocupa de tuplas. Proporciona un conjunto de clases de tupla java que van de uno a diez elementos. Para servir a nuestro propósito, podemos usar la clase 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
|
import org.javatuples.Pair;
importar java.útil.ArrayList;
importar java.útil.Lista;
tupla de clase
{
// Demostrar la biblioteca de JavaTuples proporcionada por clases de pares en Java
public static void main (Argumentos de cadena)
{
List< Pair< String, Integer> > pairs = nueva ArrayList<>();
pares.añadir (Par.with («Java», 50)); / / usando Pair.con pares ()
.add (new Pair< >(«C++», 30)); / / usando constructores
/ / imprime el primer par usando el método getValue0 () y getValue1 ()
Sistema.fuera.println(«{» + pares.obtener (0).Valor de get0() + «, » +
pares.obtener (0).Valor de get1() + «}»);
// imprime el segundo par usando el método getValue0() y getValue1 ()
del sistema.fuera.println(«{» + pares.obtener (1).Valor de get0() + «, » +
pares.obtener (1).getValue1() + «}»);
}
}
|
Código de Descarga
Salida:
{Java, 50}
{C++, 30}
las Colecciones.singletonMap ()
Otro enfoque es usar Colecciones.singletonMap () en Java que es similar a Map.Entrada< K, V> discutida anteriormente. Devuelve un mapa único inmutable que contiene solo la asignación de pares clave-valor especificada, que se puede tratar como un Par.
|
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;
importar java.útil.Conjunto;
par de clases
{
// Devuelve un mapa único inmutable que contiene solo la asignación de pares clave-valor
// especificada
estática pública < T, U>Mapa< T, U> de(T primero, U segundo)
{
devolver Colecciones.singletonMap (primero, segundo);
}
}
tupla de clase
{
// Implementar clases de pares en Java usando Colecciones.singletonMap ()
principal vacío estático público (Argumentos de cadena)
{
Establecer< Map< Cadena, Entero>> entradas = nuevo HashSet<>();
entradas.añadir (Par.de («Java», 50));
entradas.añadir (Par.de («C++», 30));
Sistema.fuera.println(entradas);
}
}
|
Descargar Ejecutar Código
Salida:
Finalmente, en proyectos Android, podemos usar android.útil.Clase de pares proporcionada por el SDK de Android.