A tupla é uma estrutura de dados que pode conter objetos de diferentes tipos. Esses objetos não estão conectados entre si, mas têm significado quando os consideramos coletivamente. Nesta seção, discutimos o que é tupla , características, tamanho, e operações de tuplas. Além disso, discutiremos o implementação de tupla em Java .

O que é uma tupla?

Em geral, um tupla é uma coleção ordenada de objetos. Na tupla, os dados são armazenados como um objeto em uma matriz de bytes separada. Possui valores separados por vírgula entre colchetes []. Tuplas são imutável, ao contrário da estrutura de dados das listas. Uma tupla pode conter várias tuplas. Também pode ser considerado um objeto anônimo.

Recursos da tupla

Tupla possui os seguintes recursos:

• Isso é typesafe, iterável, imutável, e serializável .
• Ele implementa o toString(), igual(), e o código hash()
• Também implementa o Comparável (Tupla implementa Comparável)

Exemplo de tupla

Vamos considerar o seguinte exemplo.

 ['Sophia', 'Female', 22, 'Marketing Manager'] 

A tupla acima é uma quarteto tupla porque tem quatro elementos (objetos). Observamos que cada objeto é de um tipo diferente. Mas quando consideramos isso coletivamente, tem um significado específico. A tupla acima representa os dados de um funcionário, como nome, sexo, idade e designação.

Vamos ver alguns outros exemplos de tuplas.

 ['Java', 'Object-oriented', 14] ['John', 'Wick' 21, 'USA', false, '[email protected]'] [3, 'Samsung', 'Galaxy S2', 37000.00] 

Tupla em Java

Em Java, uma tupla é uma estrutura de dados genérica que trata cada elemento como um objeto, e esses objetos são armazenados em uma matriz de bytes separada. Em outras palavras, também podemos dizer que tupla é um encomendado coleção de objetos de diferentes tipos.

A funcionalidade de uma tupla pode ser implementada usando a estrutura de dados Lista e Matriz, mas essas estruturas de dados não contêm diferentes tipos de dados por design. Portanto, é claro que heterogêneo tupla usando uma estrutura de dados padrão (Lista/Array) não é possível em Java. Já que exigimos tupla estrutura de dados para cumprir o requisito de manter homogêneo estrutura de dados.

Observe que estrutura de dados tupla não está presente na programação Java , por padrão. Mas podemos implementar a estrutura de dados da tupla usando a biblioteca de terceiros chamada javatuplas .

Antes de prosseguir para a implementação, primeiro faremos o download do javatuples.jar arquivo. E adicione este arquivo ao caminho do projeto.

programas java

Também podemos usar a seguinte dependência em pom.xml arquivo para implementar a estrutura de dados de tuplas em Java.

 org.javatuples javatuples 1.2 

Vamos implementar uma tupla e criar um programa de tupla Java simples.

Biblioteca Javatuplas

O javatuplas biblioteca possui as classes de tupla que correspondem ao tamanho de uma tupla. As tuplas podem ter tamanhos diferentes. Uma tupla pode conter no máximo 10 elementos. A implementação de cada tupla é diferente. A hierarquia de classes é a seguinte.

 Java.lang.Object ↳ org.javatuples.Tuple ↳ org.javatuples.ClassName 

Classe Java Tupla

O Tupla é uma classe base abstrata para todas as classes de tupla que pertencem a org.javatuples pacote. Todos os métodos da classe tupla são públicos e finais. A tabela a seguir resume os métodos da classe tupla. Ele implementa interfaces Iteráveis ​​e Serializaveis.

Subclasses diretas conhecidas

Além das classes acima, existem duas classes adicionais fornecidas pela biblioteca javatuples, ou seja, Valor chave e RótuloValor . Essas duas classes são semelhantes às Par classe e fornecem a mesma funcionalidade, mas em semânticas diferentes.

Cada classe de tupla implementa as três interfaces a seguir:

• Iterável
• Comparável
• Serializável

Implementação de Tupla

A implementação de uma tupla em Java é muito fácil. Temos que criar uma instância da classe tupla que corresponda ao tamanho.

TupleExample.java

 import org.javatuples.Quartet; public class TupleExample { public static void main(String args[]) { //create a pair tuple from the constructor Quartet quartet = new Quartet('Sophia', 'Female', 22, 'Marketing Manager'); //print the tuples objects System.out.println('The details of the employee are: ' + quartet); } } 

Saída:

 The details of the employee are: [Sophia, Female, 22, Marketing Manager] 

Operações de tupla

As seguintes operações podem ser realizadas em uma tupla:

• Criando uma tupla
• Obtendo Valores
• Definir valores
• Adicionando Elementos
• Iterar sobre tupla
• Converter tupla em lista
• Pesquisando em tupla

Criando Tupla

Existem três maneiras de criar uma tupla:

• Usando o método with()
• Usando Construtor
• Usando coleção

Vamos ver as três maneiras acima de criar uma tupla.

Usando o método with()

A biblioteca javatuples fornece o com() método que cria uma tupla com os valores especificados. O método pertence ao org.javatuples.Pair pacote. É usado para instanciar objetos com valores.

Sintaxe:

 ClassName object = ClassName.with(value-1, value-2, ......, value-n); 

Exemplo:

 Pair pair = Pair.with('iPhone 12', 112000.00); 

O objeto da classe Pair acima cria uma tupla com dois valores. Vamos criar um programa Java para o mesmo.

CreateTupleExample1.java

 import org.javatuples.Pair; class CreateTupleExample1 { public static void main(String args[]) { Pair pair = Pair.with(9086651, 'Dell Laptop'); System.out.println(pair); } } 

Saída:

fluxo de filtro java

 [9086651, Dell Laptop] 

Usando Construtor

Neste caso, criamos um construtor da classe, conforme necessidade.

Sintaxe:

 ClassName object = new ClassName (value-1, value-2, ……., value-n); 

Exemplo:

 Quintet quintet = new Quintet (91237, 'Mac Book Air', 88490.00, '8-Core CPU', 4); 

Vamos criar um programa Java para criar uma tupla usando o construtor.

CreateTupleExample2.java

 import org.javatuples.Quintet; class CreateTupleExample1 { public static void main(String args[]) { Quintet quintet = new Quintet (91237, 'Mac Book Air', 88490.00, '8-Core CPU', 4); System.out.println(quintet); } } 

Saída:

 [91237, Mac Book Air, 88490.0, 8-Core CPU, 4] 

Usando coleção

A biblioteca javatuples nos permite criar uma tupla a partir da coleção usando o fromCollection() método. Também nos permite criar uma tupla a partir de um array usando o fromArray() método. Observe que a coleção/matriz deve ter o mesmo tipo e valores da tupla.

A coleção/matriz deve ter o mesmo tipo da Tupla e o número de valores na coleção/matriz deve corresponder à classe Tupla.

Sintaxe:

 ClassName object = ClassName.fromCollection(list); ClassName object = ClassName.fromArray(array); 

Exemplo:

 Octet p1 = Octet.fromCollection(list); Sextet p2 = Sextet.fromArray(arr); 

CreateTupleExample3.java

 import java.util.ArrayList; import java.util.List; import org.javatuples.Sextet; import org.javatuples.Octet; class CreateTupleExample3 { public static void main(String args[]) { //creating a list List list = new ArrayList(); //adding elements to the list list.add('C'); list.add('C++'); list.add('Java'); list.add('Python'); list.add('Scala'); list.add('Ruby'); list.add('PHP'); list.add('COBOL'); //creating an object of Pair class and passing the list Octet p1 = Octet.fromCollection(list); //creating an Array String[] arr = {'One', 'Two', 'Three', 'Four', 'Five', 'Six'}; //creating an object of the Pair class and invoking the fromArray() method Sextet p2 = Sextet.fromArray(arr); //prints the tuple created using list System.out.println(p1); //prints the tuple using Array System.out.println(p2); } } 

Saída:

 [C, C++, Java, Python, Scala, Ruby, PHP, COBOL] [One, Two, Three, Four, Five, Six] 

Obter valores

A biblioteca javatuples também nos permite buscar valores da tupla no índice especificado usando o getValorX() método. Onde X denota o valor do índice do objeto. A indexação começa em 0.

Exemplo:

 Pair pair = new Pair(value-1, value-2); type1 val1 = pair.getValue0(); 

GetValueExample.java

 import org.javatuples.Pair; class GetTupleValue { public static void main(String args[]) { //creating a tuple Pair pair = Pair.with(12, 'Andrew'); //getting values at index 1 System.out.println(pair.getValue1()); } } 

Saída:

 [Andrew] 

Definir valores

Como discutimos acima, as tuplas são imutáveis. Portanto, eles não podem ser modificados depois de criados. Para superar o problema, a biblioteca javatuples fornece o definirValorX() método. Onde X é o valor do índice no qual queremos definir o valor específico. O método cria uma cópia da tupla com o valor recém-adicionado no índice especificado e retorna a mesma tupla.

Exemplo:

 Pair pair = new Pair(value-1, value-2); type1 val1 = pair.getValue0(); 

SetValueExample.java

 import org.javatuples.Pair; class SetTupleValue { public static void main(String args[]) { //creating a tuple Pair p1 = Pair.with(67, 69); //setting tuple value at index 1 Pair p2 = p1.setAt1(68); System.out.println(p2); } } 

Saída:

 [67, 68] 

Adicionando um valor

Existem duas maneiras de adicionar valores em uma tupla:

tipos de loop for

• No final da tupla
• No índice específico

No final da tupla

A biblioteca javatuples fornece o adicionar() método para adicionar objetos à tupla. Ele adiciona o objeto no final da tupla e retorna uma nova tupla combinando o número de elementos.

Suponha que temos uma tupla com dois elementos e queremos adicionar outro elemento à tupla. Nesse caso, a tupla Pair não suportará o terceiro elemento. Portanto, quando adicionamos um elemento a uma tupla Pair, ele é convertido em uma tupla Triplet. Vejamos um exemplo.

AddElementInTuple.java

 import org.javatuples.Pair; import org.javatuples.Triplet; public class AddElementInTuple { public static void main(String args[]) { Pair pair = Pair.with('Jack', 46); Triplet triplet = pair.add('Finance Professional'); System.out.println(pair); System.out.println(triplet); } } 

Saída:

 [Jack, 46] [Jack, 46, Finance Professional] 

Também podemos adicionar uma tupla a outra tupla. Aumenta o número de elementos na tupla recém-gerada. Conseqüentemente, ele retorna o tipo de tupla com base no número de elementos presentes após a adição.

AddTuplesExample.java

 import org.javatuples.Quartet; import org.javatuples.Septet; import org.javatuples.Triplet; public class AddTuplesExample { public static void main(String args[]) { //creating a tuple with three elements Triplet triplet = Triplet.with('Mango', 'Grapes', 'Papaya'); //creating an object of quartet tuple and adding an elements at index-1 in triplet tuple Quartet quartet = triplet.addAt1('Banana'); //adding quartet and triplet tuple we get a septet tuple i.e. 3+4=7 //the following statement can be written as Septet septet = quartet.add(triplet); Septet septet = quartet.add(triplet); System.out.println(triplet); System.out.println(quartet); System.out.println(septet); } } 

Saída:

 [Mango, Grapes, Papaya] [Mango, Banana, Grapes, Papaya] [Mango, Banana, Grapes, Papaya, Mango, Grapes, Papaya] 

No índice especificado

Por padrão, novos elementos são adicionados no final da tupla. Mas podemos adicionar elementos no índice especificado usando o adicionarX() método.

AddAtIndexExample.java

 import org.javatuples.Quartet; import org.javatuples.Triplet; public class AddAtIndexExample { public static void main(String args[]) { //creating a tuple with three elements Triplet triplet = Triplet.with('MCA', 'M.Sc.', 'MBBS'); //creating an object of quartet tuple and adding an element at index-2 in triplet tuple Quartet quartet = triplet.addAt2('M.Tech'); System.out.println(triplet); System.out.println(quartet); } } 

Saída:

 [MCA, M.Sc., MBBS] [MCA, M.Sc., M.Tech, MBBS] 

Procurando um elemento

Também podemos procurar um elemento que resida na tupla. Para pesquisar a biblioteca javatuples fornece o contém() método da classe Tuple. Ele retorna um valor booleano verdadeiro se um elemento estiver presente, senão retorna falso . Vejamos um exemplo.

SearchingElementExample.java

 import org.javatuples.Pair; class SearchingElementExample { public static void main(String args[]) { Pair pair = Pair.with(34, 'Jack'); //returns true because Jack is present in tuple boolean res1 = pair.contains('Jack'); //returns false because Andrew is not present in tuple boolean res2 = pair.contains('Andrew'); System.out.println(res1); System.out.println(res2); } } 

Saída:

 true false 

Converter Tupla em Coleção ou Matriz

Cada classe de tupla possui os métodos asList() e toArray() que retornam List e Array, respectivamente. Vejamos um exemplo.

tigre comparado ao leão

TupleToCollection.java

 import java.util.Arrays; import java.util.List; import org.javatuples.Quartet; public class TupleToCollection { public static void main(String args[]) { //Convert to list Quartet quartet = Quartet.with('Dog', 12,'German Shepherd', 23.89); //converts to list List list = quartet.toList(); //prints list System.out.println(list); //Converts to array Object[] quartletArr = quartet.toArray(); //prints array System.out.println(Arrays.toString(quartletArr)); } } 

Saída:

 [Dog, 12, German Shepherd, 23.89] [Dog, 12, German Shepherd, 23.89] 

Observe que a tupla pode conter tipos heterogêneos, então o tipo resultante será de Lista ou Objeto[] de acordo.

Iteração sobre tupla

Todas as classes de tupla implementam o Iterável interface. Portanto, podemos iterar uma tupla da mesma forma que coleções ou arrays.

IterateTuple.java

 import org.javatuples.Quartet; class IterateTuple { public static void main(String args[]) { //creating a quartet tuple Quartet quartet = Quartet.with('Dell', 5600.00, 34, 'Digital Solutions'); //iterate over tuple for(Object obj : quartet) { //prints elements System.out.println(obj); } } } 

Saída:

 Dell 5600.0 34 Digital Solutions 

Tupla vs. Lista/matriz