TechCodeview

A tupla es una estructura de datos que puede contener objetos de diferentes tipos. Estos objetos no están conectados entre sí pero tienen significado cuando los consideramos colectivamente. En esta sección, discutimos que es tupla , características, tamaño, y operaciones de tuplas. Además, discutiremos el implementación de tupla en Java .

¿Qué es una tupla?

En general, un tupla es una colección ordenada de objetos. En una tupla, los datos se almacenan como un objeto en una matriz de bytes separada. Tiene valores separados por comas encerrados entre un par de corchetes []. Las tuplas son inmutable, a diferencia de la estructura de datos de Listas. Una tupla puede contener varias tuplas. También puede considerarse un objeto anónimo.

Características de tupla

Tupla tiene las siguientes características:

• Es seguro para tipos, iterable, inmutable, y serializable .
• Implementa el toString(), es igual a(), y el código hash()
• También implementa la Comparable (Tupla implementa comparable)

Ejemplo de tupla

Consideremos el siguiente ejemplo.

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

La tupla anterior es una cuarteto tupla porque tiene cuatro elementos (objetos). Observamos que cada objeto es de un tipo diferente. Pero cuando lo consideramos colectivamente, tiene un significado específico. La tupla anterior representa los datos de un empleado, como nombre, sexo, edad y designación.

Veamos algunos otros ejemplos de tuplas.

mysql muestra todos los usuarios

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

Tupla en Java

En Java, una tupla es una estructura de datos genérica que trata cada elemento como un objeto y estos objetos se almacenan en una matriz de bytes separada. En otras palabras, también podemos decir que la tupla es una ordenado colección de objetos de diferentes tipos.

La funcionalidad de una tupla se puede implementar utilizando la estructura de datos Lista y Matriz, pero estas estructuras de datos no contienen diferentes tipos de datos por diseño. Por lo tanto, es claro que heterogéneo tupla usando una estructura de datos estándar (Lista/Matriz) no es posible en Java. ya que requerimos tupla estructura de datos para cumplir con el requisito de mantener homogéneo estructura de datos.

Tenga en cuenta que La estructura de datos de tupla no está presente en la programación Java. , por defecto. Pero podemos implementar la estructura de datos de tupla usando la biblioteca de terceros llamada javatuplas .

Antes de pasar a la implementación, primero descargaremos el javatuples.jar archivo. Y agregue este archivo a la ruta del proyecto.

También podemos usar la siguiente dependencia en pom.xml archivo para implementar la estructura de datos de tuplas en Java.

 org.javatuples javatuples 1.2 

Implementemos una tupla y creemos un programa de tupla Java simple.

Biblioteca Javatuples

El javatuplas La biblioteca tiene las clases de tupla que corresponden al tamaño de una tupla. Las tuplas pueden tener diferentes tamaños. Una tupla puede contener un máximo de 10 elementos. La implementación de cada tupla es diferente. La jerarquía de clases es la siguiente.

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

Clase de tupla de Java

El tupla es una clase base abstracta para todas las clases de tuplas que pertenecen a org.javatuples paquete. Todos los métodos de la clase tupla son públicos y finales. La siguiente tabla resume los métodos de la clase tupla. Implementa interfaces iterables y serializables.

Subclases conocidas directas

Además de las clases anteriores, hay dos clases adicionales proporcionadas por la biblioteca javatuples, es decir. Valor clave y Valor de etiqueta . Estas dos clases son similares a las Par clase y proporciona la misma funcionalidad pero en diferente semántica.

Cada clase de tupla implementa las siguientes tres interfaces:

• iterable
• Comparable
• Serializable

Implementación de tupla

La implementación de una tupla en Java es muy sencilla. Tenemos que crear una instancia de clase tupla que corresponda al tamaño.

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); } } 

Producción:

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

Operaciones de tupla

Se pueden realizar las siguientes operaciones en una tupla:

• Creando una tupla
• Obtener valores
• Valores de configuración
• Agregar elementos
• Iterar sobre tupla
• Convertir tupla en lista
• Buscando en tupla

Creando tupla

Hay tres formas de crear una tupla:

• Usando el método with()
• Usando constructor
• Mediante el uso de la colección

Veamos las tres formas anteriores de crear una tupla.

Usando el método with()

La biblioteca javatuples proporciona la con() Método que crea una tupla con los valores especificados. El método pertenece al org.javatuples.Par paquete. Se utiliza para crear instancias de objetos con valores.

Sintaxis:

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

Ejemplo:

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

El objeto de clase Pair anterior crea una tupla con dos valores. Creemos un programa Java para lo mismo.

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); } } 

Producción:

 [9086651, Dell Laptop] 

Usando el constructor

En este caso, creamos un constructor de la clase, según requerimiento.

Sintaxis:

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

Ejemplo:

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

Creemos un programa Java para crear una tupla usando el constructor.

CreateTupleExample2.java

la cadena está vacía

 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); } } 

Producción:

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

Mediante el uso de la colección

La biblioteca javatuples nos permite crear una tupla a partir de la colección usando el deColección() método. También nos permite crear una tupla a partir de una matriz usando el desdeArray() método. Tenga en cuenta que la colección/matriz debe tener el mismo tipo y valores que la tupla.

La colección/matriz debe tener el mismo tipo que la Tupla y el número de valores en la colección/matriz debe coincidir con la clase Tupla.

Sintaxis:

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

Ejemplo:

 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); } } 

Producción:

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

Obtener valores

La biblioteca javatuples también nos permite recuperar valores de la tupla en el índice especificado usando el obtenerValorX() método. Donde X denota el valor del índice del objeto. La indexación comienza desde 0.

Ejemplo:

 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()); } } 

Producción:

 [Andrew] 

Establecer valores

Como comentamos anteriormente, las tuplas son inmutables. Por tanto, no se pueden modificar una vez creados. Para superar el problema, la biblioteca javatuples proporciona la establecerValorX() método. Donde X es el valor del índice en el que queremos establecer el valor específico. El método crea una copia de la tupla con el valor recién agregado en el índice especificado y devuelve la misma tupla.

Ejemplo:

 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); } } 

Producción:

 [67, 68] 

Agregar un valor

Hay dos formas de sumar valores en una tupla:

fecha y hora mecanografiadas

• Al final de la tupla
• En un índice específico

Al final de la tupla

La biblioteca javatuples proporciona la agregar() Método para agregar objetos a la tupla. Agrega el objeto al final de la tupla y devuelve una nueva tupla haciendo coincidir el número de elementos.

Supongamos que tenemos una tupla que tiene dos elementos y queremos agregar otro elemento a la tupla. En tal caso, la tupla Par no admitirá el tercer elemento. Por lo tanto, cuando agregamos un elemento a una tupla de Par, se convierte en una tupla de Triplete. Veamos un ejemplo.

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); } } 

Producción:

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

También podemos sumar una tupla a otra tupla. Aumenta la cantidad de elementos en la tupla recién generada. Por lo tanto, devuelve el tipo de tupla según la cantidad de elementos presentes después de la suma.

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); } } 

Producción:

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

En el índice especificado

De forma predeterminada, los nuevos elementos se agregan al final de la tupla. Pero podemos agregar elementos en el índice especificado usando el agregarX() 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); } } 

Producción:

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

Buscando un elemento

También podemos buscar un elemento que resida en la tupla. Para buscar en la biblioteca javatuples se proporciona la contiene() método de la clase Tupla. Devuelve un valor booleano verdadero si un elemento está presente, de lo contrario regresa FALSO . Veamos un ejemplo.

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); } } 

Producción:

 true false 

Convertir tupla en colección o matriz

Cada clase tupla tiene métodos asList() y toArray() que devuelven List y Array, respectivamente. Veamos un ejemplo.

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)); } } 

Producción:

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

Tenga en cuenta que la tupla puede contener tipos heterogéneos, por lo que el tipo resultante será de Lista o Objeto[] respectivamente.

Iteración sobre tupla

Todas las clases de tuplas implementan el iterable interfaz. Entonces, podemos iterar una tupla de la misma manera que las colecciones o las matrices.

IterateTuple.java

alfabeto a numero

 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); } } } 

Producción:

 Dell 5600.0 34 Digital Solutions 

Tupla vs. Lista/matriz