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 →

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

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Java Date Class

Java ListIterator Class

Java NIO Tutorial

HttpURLConnection

Java Deque

Java HttpCookie Class

Java URL class

Java List Methods

Java Vector class

Java Collection Methods

Java Socket Class

Java Executors

KeyValue Class in JavaTuples

Class Declaration

Class hierarchy

Creating KeyValue Tuple

Approach: Using Constructor:

Approach: Using with() method:

From other collections

Getting Value

getKey():