KeyValue Class in JavaTuples

The KeyValue class in the JavaTuples library is a specialized Tuple with two elements: a key and a value. It provides a more meaningful and self-explanatory way to represent key-value pairs than generic Tuples with indices.

As a tuple, the `KeyValue` class possesses all the traits and features inherent to JavaTuples.

Immutability: Once created, KeyValue objects cannot be modified. It ensures data consistency and simplifies reasoning about the code.
Type safety: KeyValue is generic and can hold any type of value for both key and value, but it enforces type safety by ensuring correct access to each element.
Iterable: KeyValue objects can be iterated over, making them convenient for loops and other processing tasks.
Serializable: KeyValue objects can be serialized and deserialized, allowing us to store and transmit them between different processes or machines.
Comparable: KeyValue objects implement the Comparable interface, enabling us to compare them based on their key-value pairs. It is particularly useful for sorting and searching operations.
Equality and hashing: KeyValue objects provide equals() and hashCode() methods for comparing objects based on their content, ensuring consistent behaviour in collections and other data structures.
toString(): KeyValue offers a meaningful toString() representation that displays the key and value, making debugging and code readability easier.

Class Declaration

public final class KeyValue<A, B> extends Tuple implements IValueKey<A>, IValueValue<B>

IValueKey<A>: The KeyValue class implements the IValueKey interface with the generic type A. It suggests that the class provides implementations for methods related to key operations.
IValueValue<B>: Similarly, the class implements the IValueValue interface with the generic type B, indicating that it provides implementations for methods related to value operations.

Class hierarchy

Object
  ↳ org.javatuples.Tuple
      ↳ org.javatuples.KeyValue<A, B>

Object: The root class for all classes in Java.
org.javatuples.Tuple: A class in the javatuples library representing a generic tuple. It serves as the base class for more specific tuple types.
org.javatuples.KeyValue<A, B>: A class in the javatuples library representing a key-value pair. It extends the Tuple class and introduces generic types A and B for the key and value. This class is specifically designed for key-value scenarios.

Creating KeyValue Tuple

A `KeyValue` tuple is a specialized tuple in the JavaTuples library designed to represent a key-value pair, providing a convenient way to store and manipulate associated data with distinct key and value components.

Approach: Using Constructor:

When working with JavaTuples, we can use a constructor to create a KeyValue instance with specific key and value values. The KeyValue class typically provides constructors that take the key and value as parameters.

Syntax:

Filename: ConstructorExampleClass.java

class ConstructorExample<A, B> {
    private A key;
    private B value;

    public ConstructorExample(A key, B value) {
        this.key = key;
        this.value = value;
    }

    public A getKey() {
        return key;
    }

    public B getValue() {
        return value;
    }
}

public class ConstructorExampleClass {
    public static void main(String[] args) {
        // Creating key-value pairs using the constructor
        ConstructorExample<String, Integer> keyValue1 = new ConstructorExample<>("Name", 25);
        ConstructorExample<Integer, Double> keyValue2 = new ConstructorExample<>(42, 3.14);

        // Accessing the key and value of the first pair
        String key1 = keyValue1.getKey();
        Integer value1 = keyValue1.getValue();

        // Accessing the key and value of the second pair
        Integer key2 = keyValue2.getKey();
        Double value2 = keyValue2.getValue();

        // Printing the key and value of the first pair
        System.out.println("Key 1: " + key1);
        System.out.println("Value 1: " + value1);

        // Printing the key and value of the second pair
        System.out.println("Key 2: " + key2);
        System.out.println("Value 2: " + value2);
    }
}

Output:

Key 1: Name
Value 1: 25
Key 2: 42
Value 2: 3.14

Approach: Using with() method:

The `with()` method, offered by the JavaTuples library, serves as a function for creating object instances with specific values.

Syntax:

Filename: WithExample.java

import org.javatuples.Pair;

public class WithExample {
    public static void main(String[] args) {
        // Creating key-value pairs using the with method
        Pair<String, Integer> person1 = Pair.with("Alice", 28);
        Pair<String, Integer> person2 = Pair.with("Bob", 35);

        // Accessing and printing the key and value of the first pair
        String name1 = person1.getValue0();
        Integer age1 = person1.getValue1();
        System.out.println("Person 1 - Name: " + name1 + ", Age: " + age1);

        // Accessing and printing the key and value of the second pair
        String name2 = person2.getValue0();
        Integer age2 = person2.getValue1();
        System.out.println("Person 2 - Name: " + name2 + ", Age: " + age2);
    }
}

Output:

Person 1 - Name: Alice, Age: 28
Person 2 - Name: Bob, Age: 35

From other collections

The `fromCollection()` method is designed to construct a Tuple from a collection, and the `fromArray()` method is used for creating a Tuple from an array. It is essential that both the Collection and the Array share the same data type as the Tuple, and the count of values within the Collection or Array must exactly correspond to the arity of the Tuple class.

Syntax:

KeyValue<type1, type2> kvFromCollection = KeyValue.fromCollection(collectionWith_2_value);
KeyValue<type1, type2> kvFromArray = KeyValue.fromArray(arrayWith_2_value);

Filename: KeyValueExample.java

import org.javatuples.KeyValue;

import java.util.ArrayList;
import java.util.List;

public class KeyValueExample {
    public static void main(String[] args) {
        // Creating a list with two values
        List<String> stringList = new ArrayList<>();
        stringList.add("Key");
        stringList.add("Value");

        // Creating KeyValue from List
        KeyValue<String, String> kvFromList = KeyValue.fromCollection(stringList);

        // Displaying KeyValue
        System.out.println("KeyValue from List: " + kvFromList);

        // Accessing individual elements
        String key = kvFromList.getKey();
        String value = kvFromList.getValue();

        // Printing individual elements
        System.out.println("Key: " + key);
        System.out.println("Value: " + value);
    }
}

Output:

KeyValue from List: [Key, Value]
Key: Key
Value: Value

Getting Value

The getValue() and getKey() methods within a KeyValue Tuple are pivotal for accessing the encapsulated value and key, respectively. These methods provide a straightforward means to retrieve the associated value and key from a KeyValue Tuple instance.

getKey():

The getKey() method in the org.javatuples library is designed for use with the KeyValue class. It retrieves the key from a KeyValue object and ensures type safety. Specifically, it returns the element at index 0 within the KeyValue object. This method is exclusive to KeyValue objects in the javatuples library.

Syntax:

KeyValue<type1, type2> kv = new KeyValue<type1, type2>(value1, value2);type2 val1 = kv.getKey();

Filename: GetKeyExampleClass.java

class GetKeyExample<type1, type2> {
    private type1 key;
    private type2 value;

    public GetKeyExample(type1 key, type2 value) {
        this.key = key;
        this.value = value;
    }

    public type2 getKey() {
        return value;
    }
}   
public class GetKeyExampleClass {
    public static void main(String[] args) {
        // Example usage
        GetKeyExample<String, Integer> kv = new GetKeyExample<>("exampleKey", 42);
        Integer val1 = kv.getKey();
        System.out.println("Value: " + val1);
    }
}

Output:

Value: 42

getValue():

The `getValue()` method in the `org.javatuples` library retrieves the value at a specified index within a Tuple object. It returns an `Object` value, potentially compromising type-safety, as the data type of the returned value is not explicitly specified.

Syntax:

KeyValue<type1, type2> kv = 
    new KeyValue<type1, type2>(value1, value2);

type2 val1 = kv.getValue();

Filename: GetValueExampleClass.java

class GetValueExample<type1, type2> {
    private type1 key;
    private type2 value;

    public GetValueExample(type1 key, type2 value) {
        this.key = key;
        this.value = value;
    }

    public type1 getKey() {
        return key;
    }

    public type2 getValue() {
        return value;
    }
}
public class GetValueExampleClass {
    public static void main(String[] args) {
        // Example usage
        GetValueExample<String, Integer> kv = new GetValueExample<>("exampleKey", 42);
        String key = kv.getKey();
        Integer value = kv.getValue();

        System.out.println("Key: " + key);
        System.out.println("Value: " + value);
    }
}

Output:

Key: exampleKey
Value: 42

Setting KeyValue Value

In Java programming, immutability ensures that its elements cannot be modified directly once a tuple is created. JavaTuples provides methods like setKey() and setValue() to create new instances with updated values, maintaining the immutability of the original KeyValue object.

setKey()

The setKey() method in JavaTuples allows the creation of a new KeyValue instance with an updated key while keeping the original Tuple immutable. The method ensures type safety and consistency and aligns with functional programming principles by returning a modified copy of the KeyValue object.

Syntax:

KeyValue<type1, type2> originalKeyValue = KeyValue.with(originalKey, originalValue);
KeyValue<type1, type2> modifiedKeyValue = originalKeyValue.setKey(newKey);

Filename: SetKeyExample.java

import org.javatuples.KeyValue;

public class SetKeyExample {
    public static void main(String[] args) {
        // Creating a KeyValue instance using JavaTuples
        KeyValue<Integer, String> originalKeyValue = KeyValue.with(1, "OriginalValue");

        // Displaying the original key-value pair
        System.out.println("Original KeyValue: " + originalKeyValue.getKey() + " - " + originalKeyValue.getValue());

        // Using setKey() to create a new KeyValue with an updated key
        KeyValue<Integer, String> modifiedKeyValue = originalKeyValue.setKey(2);

        // Displaying the modified key-value pair
        System.out.println("Modified KeyValue: " + modifiedKeyValue.getKey() + " - " + modifiedKeyValue.getValue());
    }
}

Output:

Original KeyValue: 1 - OriginalValue
Modified KeyValue: 2 - OriginalValue

setValue():

The setValue() method in JavaTuples allows us to create a new KeyValue instance with an updated value while maintaining the immutability of the original Tuple. The method is useful when working with different values associated with the same key.

Syntax:

KeyValue<type1, type2> originalKeyValue = KeyValue.with(originalKey, originalValue);
KeyValue<type1, type2> modifiedKeyValue = originalKeyValue.setValue(newValue);

Filename: SetValueExample.java

import org.javatuples.KeyValue;

public class SetValueExample {
    public static void main(String[] args) {
        // Creating a KeyValue instance using JavaTuples
        KeyValue<Integer, String> originalKeyValue = KeyValue.with(1, "OriginalValue");

        // Displaying the original key-value pair
        System.out.println("Original KeyValue: " + originalKeyValue.getKey() + " - " + originalKeyValue.getValue());

        // Using setValue() to create a new KeyValue with an updated value
        KeyValue<Integer, String> modifiedKeyValue = originalKeyValue.setValue("NewValue");

        // Displaying the modified key-value pair
        System.out.println("Modified KeyValue: " + modifiedKeyValue.getKey() + " - " + modifiedKeyValue.getValue());
    }
}

Output:

Original KeyValue: 1 - OriginalValue
Modified KeyValue: 1 - NewValue

Searching in KeyValue

Searching for specific elements within a key-value pair is a common operation in programming, often used to determine the presence or absence of a particular value associated with a given key. In the context of tuples, such as those found in the JavaTuples library, a predefined method called contains() provides a convenient way to perform these searches. This method returns a boolean value, indicating whether the specified value is present in the Tuple.

Syntax:

KeyValue<type1, type2> kv = 
    new KeyValue<type1, type2>(value1, value2);

boolean result = kv.contains(value2);

Filename: KeyValueSearchExample.java

import org.javatuples.KeyValue;

public class KeyValueSearchExample {
    public static void main(String[] args) {
        // Creating a KeyValue instance using JavaTuples
        KeyValue<Integer, String> kv1 = KeyValue.with(1, "JavaTpoint");

        // Using contains for True result
        boolean exist = kv1.contains("JavaTpoint");

        // Using contains for False result
        boolean exist1 = kv1.contains(4);

        // Displaying the results
        System.out.println("Exists: " + exist);
        System.out.println("Exists1: " + exist1);

        // Creating another KeyValue instance
        KeyValue<Integer, String> kv2 = KeyValue.with(2, "JavaTuples");

        // Performing equality comparison between kv1 and kv2
        boolean isEqual = kv1.equals(kv2);

        // Displaying the equality comparison result
        System.out.println("KeyValue 1 is equal to KeyValue 2: " + isEqual);
    }
}

Output:

Exists: true
Exists1: false
KeyValue 1 is equal to KeyValue 2: false

Iterating through KeyValue

Iterating through key-value pairs is a fundamental process in programming, essential for working with data structures that associate values with unique keys. It involves accessing and processing each pair within a data structure, enabling tasks like searching, updating, and performing computations based on the stored information.

Syntax:

KeyValue<type1, type2> kv = new KeyValue<>(value1, value2);

for (Object item : kv) {
    // our code here
}

Filename: KeyValueIterationExample.java

import org.javatuples.Pair;

public class KeyValueIterationExample {
    public static void main(String[] args) {
        // Creating a list of Pair instances using JavaTuples
        Pair<Integer, String> pair1 = Pair.with(1, "JavaTpoint");
        Pair<Integer, String> pair2 = Pair.with(2, "JavaTuples");
        Pair<Integer, String> pair3 = Pair.with(3, "Programming");

        // Creating a list of Pair instances
        Pair<?, ?>[] pairList = {pair1, pair2, pair3};

        // Iterating through Pair instances
        for (Pair<?, ?> pair : pairList) {
            Object key = pair.getValue0();
            Object value = pair.getValue1();

            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Output:

Key: 1, Value: JavaTpoint
Key: 2, Value: JavaTuples
Key: 3, Value: Programming

Next TopicQuantifiers in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

KeyValue Class in JavaTuples

Class Declaration

Class hierarchy

Creating KeyValue Tuple

Approach: Using Constructor:

Approach: Using with() method:

From other collections

Getting Value

getKey():

getValue():

Setting KeyValue Value

setKey()

setValue():

Searching in KeyValue

Iterating through KeyValue

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA