cinco alternativas à classe de pares em Java
um par é um recipiente para armazenar uma tupla de dois objetos. Java realmente não fornece nenhuma implementação da classe Pair. Neste post, vamos discutir sobre várias alternativas para a aula de pares em Java.
Pair é muitas vezes útil para rastrear dois objetos juntos. Contém dois campos, geralmente chamados de primeiro e segundo, que são capazes de armazenar qualquer coisa. Apesar de não ter qualquer relação significativa entre o primeiro e o segundo campo, os programadores muitas vezes perdem esta funcionalidade em Java.
no post anterior, discutimos como implementar a nossa própria classe de pares em Java. Neste post, vamos discutir os workarounds disponíveis em Java para preencher a lacuna desejada, como discutido abaixo:
Map.Entrada < K, V > Interface
podemos usar o mapa.Entry<K, V> interface in Java which is similar to std:: pair in C++. É um excelente exemplo de ter um nome significativo que representa um par de valores-chave.
para criar uma entrada representando um mapeamento da chave especificada para o valor especificado, Java fornece duas implementações concretas do mapa.Interface de entrada, nomeadamente, AbstractMap.SimpleEntry and AbstractMap.Uma entrada simples e imutável.
|
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.util.HashSet;
importar java.util.Mapa;
importar java.util.Conjunto;
par de classes
{
// Devolve um item do mapa (par do valor-chave) a partir dos valores especificados
estática pública <T, U> Mapa.Entrada < T, U> de (T primeiro, U segundo)
{
devolver um novo mapa de AbstractMap.SimpleEntry<>(primeiro, segundo);
}
}
classe Tupla
{
// Implementar Par de classe em Java usando o Mapa.Entrada
public static void main (String args))
{
definir <Mapa.Entry<String, Integer> > entries = new HashSet<>();
entradas.adicionar (par.de (“Java”, 50));
entradas.adicionar (par.de (“C++”, 30));
sistema.as.println (itens);
// executa em Java 8 e acima apenas
entradas.forEach(entrada -> {
Sim (Entrada.getKey ().igual a (“Java”))
System.as.println (entrada.getValue());
});
}
}
|
Download Código
Saída:
50
Java 8 – javafx.util.Par
finalmente após uma longa espera, um par<K, V > classe é adicionado em Java 8 em javafx.pacote util. A classe representa pares de valores-chave e suporta operações muito básicas como getKey (), getValue (), hashCode (), equals(java.idioma.Object O) and toString () and has few methods inherited from java.idioma.Classe de objectos. Bem, algo é melhor do que nada, não é?.
|
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 {
// Demonstrar javafx.util.Par de classe introduzidos no Java 8 e acima de
public static void main(String args)
{
Lista<Par<String, Integer>> entradas = new ArrayList<>();
entradas.Adicionar (novo par< >(“C”, 20));
entradas.Adicionar (novo par< >(“C++”, 30));
// print first pair using getKey() and getValue () method
System.as.println (“{“+entradas.get (0).getKey() + “, ” +
entradas.get (0).getValue ()+”}”);
// print second pair using getKey() and getValue() method
System.as.println (“{“+entradas.get (1).getKey() + “, ” +
entradas.get (1).getValue() + “}”);
}
}
|
Download Código
> Saída:
{C, 20}
{C++, 30}
Apache Commons Lang Biblioteca
Apache Commons Lang Biblioteca também oferece um Par<L,R> utilitário de classe cujos elementos são a esquerda e para a direita. É definido como abstrato e implementa o mapa.Interface de entrada onde a chave fica à esquerda e o valor à direita.
tem par.of () method that can be used to obtain an imutable pair of from specified pair of objects. A sua subclasse mutable Pair é mutável, enquanto a Imutable Pair é imutável. No entanto,o tipo de objeto armazenado no Imutablepair pode ser mutável.
|
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.comuns.lang3.cadeia.Imutablepair;
import org.Apache.comuns.lang3.cadeia.MutablePair;
import org.Apache.comuns.lang3.cadeia.Par;
importar java.util.ArrayList;
importar java.util.Lista;
Tupla {
// Demonstrar Par de classe fornecido Apache Commons Biblioteca em Java
public static void main(String args)
{
Lista<Par<String, Integer>> entradas = new ArrayList<>();
entradas.add (new MutablePair<>(“C”, 20)); // using MutablePair
entries.add (new ImmutablePair<>(“C++”, 30)); // using ImmutablePair
entries.adicionar (par.of (“Java”, 50)); / / using Pair.de ()
sistema.as.println (itens);
// 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 impressão usando o método getLeft() e getRight ()
sistema.as.println (par.getLeft ()+”, ” + pair.fica bem.());
// 3. o terceiro par também é imutável
pair = entradas.obter(2);
tente {
par.setValue (100); / / runtime error
}
capturas (excepção de exploração não apoiada ex) (
sistema.as.processo de co-decisão”);
}
sistema.as.println (par.getLeft ()+”, ” + pair.getRight ();
}
}
|
Download Código
> Saída:
C, 100
UnsupportedOperationException jogado
C++, 30
UnsupportedOperationException jogado
Java, 50
JavaTuples Biblioteca
Javatuples é outra famosa e simples de java biblioteca que lida com tuplas. Ele fornece um conjunto de classes java tuplas que variam de um a dez elementos. Para servir o nosso propósito, podemos usar Pair<A, B> classe.
|
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.Par;
importar java.util.ArrayList;
importar java.util.Lista;
Tupla {
// Demonstrar Par de classe fornecido JavaTuples Biblioteca em Java
public static void main(String args)
{
Lista<Par<String, Integer>> pares = new ArrayList<>();
pares.adicionar (par.with (“Java”, 50); // using Pair.com ()
pares.add (new Pair<>(“C++”, 30)); // using constructors
/ print first pair using getValue0 () and getValue1 () method
System.as.println (“{“+pairs.get (0).getValue0() + “, ” +
pares.get (0).getValue1() + “}”);
// print second pair using getValue0() and getValue1 () method
System.as.println (“{“+pairs.get (1).getValue0() + “, ” +
pares.get (1).getValue1() + “}”);
}
}
|
Download Código
> Saída:
{Java, 50}
{C++, 30}
Coleções.singletonMap ()
outra abordagem é usar coleções.singletonMap () in Java which is similar to Map.Entrada<K,V > discutida anteriormente. Ele retorna um mapa singleton imutável contendo apenas o mapeamento de pares de valores de chave especificados, que pode ser tratado como um 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.util.Conjunto;
classe Par
{
// Retorno de uma imutável singleton mapa contendo apenas o especificado
// par de valores-chave de mapeamento
public static <T, U> Mapa<T, U> de(T, U segundo)
{
retorno de Coleções.singletonMap(primeiro, segundo);
}
}
classe Tupla
{
// Implementar Par de classe em Java, usando Coleções.singletonMap()
public static void main(String args)
{
Set<Mapa<String, Integer>> entradas = new HashSet<>();
entradas.adicionar (par.de (“Java”, 50));
entradas.adicionar (par.de (“C++”, 30));
sistema.as.println(entradas);
}
}
|
Download Código
Saída:
Finalmente, no Android projetos, podemos usar o android.util.Classe de pares fornecida pelo Android SDK.