Implement Quintet Class with Quartet Class in Java using JavaTuples

The JavaTuples library introduces a powerful mechanism for managing structured data using tuples-ordered collections of elements in Java programming. Among its notable components are the Quartet and Quintet classes, each designed to handle tuples with four and five elements, respectively. These generic classes allow developers to store and retrieve values of various types in a structured manner.

Let's start by exploring the characteristics of the Quartet class. The tuple, with its capacity to encapsulate four elements, inherits all the essential traits of JavaTuples:

Typesafe: Ensures that data types are handled safely and effectively.
Immutable: Once created, a quartet remains unaltered, promoting data integrity.
Iterable: Allows for easy iteration over its elements.
Serializable: Enables seamless storage and retrieval of quartets.
Comparable: Implements the Comparable interface, facilitating comparisons between quartets.
Implements equals() and hashCode(): Provides methods for equality checks and hash code generation.
Implements toString(): Offers a string representation of the quartet.

Building on this foundation, we extend our exploration to the Quintet class, which deals with five elements. Like its quartet counterpart, the Quintet class inherits the same characteristics, making it a versatile and dependable tool for handling structured data in Java applications. As we delve into implementing the Quintet class alongside the Quartet class, we aim to showcase how JavaTuples simplifies organizing and managing complex data structures in Java.

Approach: Using direct values

Using direct values briefly describes initializing objects by assigning specific, predetermined values during creation.

Filename: TupleExample.java

import org.javatuples.Quartet;
import org.javatuples.Quintet;

public class TupleExample {
    public static void main(String[] args) {
        // Using Quartet with direct values
        Quartet<String, Integer, Double, Boolean> quartet = Quartet.with("John", 25, 6.2, true);
        System.out.println("Quartet: " + quartet);

        // Using Quintet with direct values
        Quintet<String, Integer, Double, Boolean, Character> quintet = Quintet.with("Alice", 30, 5.8, false, 'A');
        System.out.println("Quintet: " + quintet);
        
        // Accessing individual elements
        String name = quintet.getValue0();
        int age = quintet.getValue1();
        double height = quintet.getValue2();
        boolean isStudent = quintet.getValue3();
        char grade = quintet.getValue4();
        
        // Printing individual elements
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Height: " + height);
        System.out.println("Is Student? " + isStudent);
        System.out.println("Grade: " + grade);
    }
}

Output:

Quartet: (John, 25, 6.2, true)
Quintet: (Alice, 30, 5.8, false, A)
Name: Alice
Age: 30
Height: 5.8
Is Student? false
Grade: A

Approach: Using Quartet.add() method

The add() method in the JavaTuples library is a convenient way to create a new Quartet by appending an additional element to an existing Quartet. The method allows us to extend the size of the Quartet dynamically. The add() method is available for Quartet and other Tuple classes in the JavaTuples library.

Filename: AddToQuartetExample.java

import org.javatuples.Quartet;
import org.javatuples.Quintet;

public class FruitTupleExample {
    public static void main(String[] args) {
        // Create a Quartet with different fruit names
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "Apple", "Banana", "Orange", "Grapes");

        // Print the original Quartet
        System.out.println("Original Quartet (Fruits): " + originalTuple);

        // Create a Quintet by extending the original Quartet with an additional fruit ("Mango")
        Quintet<String, String, String, String, String> extendedTuple = new Quintet<>(
                originalTuple.getValue0(), originalTuple.getValue1(),
                originalTuple.getValue2(), originalTuple.getValue3(),
                "Mango");

        // Print the extended Quintet
        System.out.println("Extended Quintet (Fruits with an added Mango): " + extendedTuple);
    }
}

Output:

Original Quartet (Fruits): [Apple, Banana, Orange, Grapes]
Extended Quintet (Fruits with an added Mango): [Apple, Banana, Orange, Grapes, Mango]

Approach: Using Quartet.addAtX() method

The Quartet.addAtX() method in JavaTuples allows adding an element at a specified position (X) in a Quartet. It returns a new Quintet with the added element, maintaining the original Quartet's immutability.

Program 1: Adding at Position 0 using addAt0()

Algorithm:

Step 1: Import the required classes from the JavaTuples library.

Step 2: The algorithm initializes a Quartet with four string elements, setting each element to specific values: "First," "Second," "Third," and "Fourth." It defines the original quartet with the designated string values.

Step 3: Print the original Quartet to the console.

Step 4: Create a new Quintet by adding "NewValue" at position 0 in the original Quartet.

Step 5: The original Quartet remains unchanged; a new Quintet is created with the additional value.

Step 6: Print the extended Quintet to the console.

Implementation:

Filename: AddAtPositionExample.java

import org.javatuples.*;

public class AddAtPositionExample {
    public static void main(String[] args) {
        // Create a Quartet with four String elements
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "First", "Second", "Third", "Fourth");

        // Print the original Quartet
        System.out.println("Original Tuple (Quartet): " + originalTuple);

        // Create a Quintet by adding a new element ("NewValue") at position 0
        // Note: The original Quartet remains unchanged; a new Quintet is created with
        // the additional value
        Quintet<String, String, String, String, String> extendedTuple = originalTuple.addAt0("NewValue");

        // Print the extended Quintet
        System.out.println("Extended Tuple (Quintet with 'NewValue' at position 0): " + extendedTuple);
    }
}

Output:

Original Tuple (Quartet): [First, Second, Third, Fourth]
Extended Tuple (Quintet with 'NewValue' at position 0): [NewValue, First, Second, Third, Fourth]

Program 2: Adding at Position 1 using addAt1()

Algorithm:

Step 1: Import the necessary classes from the JavaTuples library.

Step 2: Instantiate a new Quartet with four String elements. Assign "First" to the first element, "Second" to the second, "Third" to the third, and "Fourth" to the fourth. It forms the initial configuration of the Quartet.

Step 3: Display the content of the original Quartet to the console.

Step 4: Utilize the addAt1("NewValue") method to create a new Quintet by adding the element "NewValue" at position 1 in the original Quartet.

Step 5: The original Quartet remains unchanged; a new Quintet is formed with the additional value.

Step 6: Display the content of the extended Quintet (resulting from adding at position 1) to the console.

Implementation:

Filename: AddAtPosition1.java

import org.javatuples.*;

public class AddAtPosition1 {
    public static void main(String[] args) {
        // Create a Quartet with four String elements
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "First", "Second", "Third", "Fourth");

        // Print the original Quartet
        System.out.println("Original Tuple (Quartet): " + originalTuple);

        // Add a new element ("NewValue") at position 1 in the original Quartet
        // Note: The original Quartet remains unchanged; a new Quintet is created with
        // the additional value
        Quintet<String, String, String, String, String> extendedTuple = originalTuple.addAt1("NewValue");

        // Print the extended Quintet
        System.out.println("Extended Tuple (Quintet with 'NewValue' at position 1): " + extendedTuple);
    }
}

Output:

Original Tuple (Quartet): [First, Second, Third, Fourth]
Extended Tuple (Quintet with 'NewValue' at position 1): [First, NewValue, Second, Third, Fourth]

Program 3: Adding at Position 2 using addAt2()

Algorithm:

Step 1: Import the necessary classes from the JavaTuples library.

Step 2: Instantiate a new Quartet with four String elements, setting each element to "First," "Second," "Third," and "Fourth." It establishes the initial state of the Quartet with specific string values.

Step 3: Display the content of the original Quartet to the console.

Step 4: Utilize the addAt2("NewValue") method to create a new Quintet by adding the element "NewValue" at position 2 in the original Quartet.

Step 5: The original Quartet remains unchanged; a new Quintet is formed with the additional value.

Step 6: Display the content of the updated Quintet (resulting from adding at position 2) to the console.

Implementation:

Filename: AddAtPosition2.java

import org.javatuples.*;

public class AddAtPosition2 {
    public static void main(String[] args) {
        // Create a Quartet with four String elements
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "First", "Second", "Third", "Fourth");

        // Print the original Quartet
        System.out.println("Original Tuple (Quartet): " + originalTuple);

        // Add a new element ("NewValue") at position 2 in the original Quartet
        // Note: The original Quartet remains unchanged; a new Quintet is created with the additional value
        Quintet<String, String, String, String, String> updatedTuple = originalTuple.addAt2("NewValue");

        // Print the updated Quintet
        System.out.println("Updated Tuple (Quintet with 'NewValue' at position 2): " + updatedTuple);
    }
}

Output:

Original Tuple (Quartet): [First, Second, Third, Fourth]
Updated Tuple (Quintet with 'NewValue' at position 2): [First, Second, NewValue, Third, Fourth]

Program 4: Adding at Position 3 using addAt3()

Algorithm:

Step 1: Import the necessary classes from the JavaTuples library.

Step 2: Instantiate a new Quartet with four String elements: "First," "Second," "Third," and "Fourth." It initializes the Quartet with specific string values, forming the initial configuration.

Step 3: Display the content of the original Quartet to the console.

Step 4: Utilize the addAt3("NewValue") method to create a new Quintet by adding the element "NewValue" at position 3 in the original Quartet.

Step 5: The original Quartet remains unchanged; a new Quintet is formed with the additional value.

Step 6: Display the content of the updated Quintet (resulting from adding at position 3) to the console.

Implementation:

Filename: AddAtPosition3.java

import org.javatuples.*;

public class AddAtPosition3 {
    public static void main(String[] args) {
        // Create a Quartet with four String elements
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "First", "Second", "Third", "Fourth");

        // Print the original Quartet
        System.out.println("Original Tuple (Quartet): " + originalTuple);

        // Add a new element ("NewValue") at position 3 in the original Quartet
        // Note: The original Quartet remains unchanged; a new Quintet is created with
        // the additional value
        Quintet<String, String, String, String, String> updatedTuple = originalTuple.addAt3("NewValue");

        // Print the updated Quintet
        System.out.println("Updated Tuple (Quintet with 'NewValue' at position 3): " + updatedTuple);
    }
}

Output:

Original Tuple (Quartet): [First, Second, Third, Fourth]
Updated Tuple (Quintet with 'NewValue' at position 3): [First, Second, Third, NewValue, Fourth]

Program 5: Adding at Position 4 using addAt4()

Algorithm:

Step 1: Import the necessary classes from the JavaTuples library.

Step 2: Instantiate a new Quartet with four String elements: "First," "Second," "Third," and "Fourth." Each element is explicitly assigned a specific string value, establishing the initial configuration of the Quartet.

Step 3: Display the content of the original Quartet to the console.

Step 4: Utilize the addAt4("NewValue") method to create a new Quintet by adding the element "NewValue" at position 4 in the original Quartet.

Step 5: The original Quartet remains unchanged; a new Quintet is formed with the additional value.

Step 6: Display the content of the updated Quintet (resulting from adding at position 4) to the console.

Implementation:

Filename: AddAtPositionExample.java

import org.javatuples.*;

public class AddAtPosition4 {
    public static void main(String[] args) {
        // Create a Quartet with four String elements
        Quartet<String, String, String, String> originalTuple = new Quartet<>(
                "First", "Second", "Third", "Fourth");

        // Print the original Quartet
        System.out.println("Original Tuple (Quartet): " + originalTuple);

        // Add a new element ("NewValue") at position 4 in the original Quartet
        // Note: The original Quartet remains unchanged; a new Quintet is created with the additional value
        Quintet<String, String, String, String, String> updatedTuple = originalTuple.addAt4("NewValue");

        // Print the updated Quintet
        System.out.println("Updated Tuple (Quintet with 'NewValue' at position 4): " + updatedTuple);
    }
}

Output:

Original Tuple (Quartet): [First, Second, Third, Fourth]
Updated Tuple (Quintet with 'NewValue' at position 4): [First, Second, Third, Fourth, NewValue]

Next TopicJava Best Practices

← prev next →