Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

JavaTuples with() method

  • Last Updated : 23 Aug, 2018

The with() method in org.javatuples is used to instantiate a tuple in a semantically elegant way, with the values given as parameters. This method can be used for any tuple class object of the javatuples library. This method is a static function in each javatuple class and it returns the tuple class object of the called class, with the values initialized by the corresponding values in the arguments.

Syntax:

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

public static <A, B, ..> <em>TupleClass<A, B, ..> with(A a, B b, ..)

Parameters: This method takes n values as parameters where:

  • n– represents the number of values based on the TupleClass (Unit, Pair, etc) used.
  • A a– represents the type for 1st value in A and its corresponding value in a.
  • B b– represents the type for 2nd value in B and its corresponding value in b.

    .
    .
    and so on.

Return Value: This method returns the object of TupleClass, which calls the method, with the values passed as the parameters.



Exceptions: This method throws a RuntimeException in the following cases:

  • When the values passed do not match their expected types in TupleClass
  • When the number of values passed are lesser than expected in TupleClass
  • When the number of values passed are more than expected in TupleClass

Below programs illustrate the various ways to use with() methods:

Program 1: When the with() method is used correctly, here with Unit class:




// Below is a Java program to create
// a Unit tuple from with() method
  
import java.util.*;
import org.javatuples.Unit;
  
class GfG {
    public static void main(String[] args)
    {
        // Using with() method to instantiate unit object
        Unit<String> unit = Unit.with("GeeksforGeeks");
  
        System.out.println(unit);
    }
}

Output:

[GeeksforGeeks]

Program 2: When the values passed do not match their expected types:




// Below is a Java program to create
// a Unit tuple from with() method
  
import java.util.*;
import org.javatuples.Quartet;
  
class GfG {
    public static void main(String[] args)
    {
        // Using with() method to instantiate unit object
        Quartet<Integer, String, String, Double> quartet
            = Quartet.with(Double.valueOf(1),
                           "GeeksforGeeks",
                           "A computer portal",
                           Double.valueOf(20.18));
  
        System.out.println(quartet);
    }
}

Output:

Exception in thread "main" java.lang.RuntimeException: 
Uncompilable source code - incompatible types: inference variable A has incompatible bounds
    equality constraints: java.lang.Integer
    lower bounds: java.lang.Double
    at MainClass.GfG.main]

Program 3: When the number of values passed are lesser than expected:




// Below is a Java program to create
// a Unit tuple from with() method
  
import java.util.*;
import org.javatuples.Quartet;
  
class GfG {
    public static void main(String[] args)
    {
        // Using with() method to instantiate unit object
        Quartet<Integer, String, String, Double> quartet
            = Quartet.with(Integer.valueOf(1),
                           "GeeksforGeeks",
                           "A computer portal");
  
        System.out.println(quartet);
    }
}

Output:

Exception in thread "main" java.lang.RuntimeException: 
Uncompilable source code - Erroneous sym type: org.javatuples.Quartet.with
    at MainClass.GfG.main

Program 4: When the number of values passed are more than expected:




// Below is a Java program to create
// a Unit tuple from with() method
  
import java.util.*;
import org.javatuples.Quartet;
  
class GfG {
    public static void main(String[] args)
    {
        // Using with() method to instantiate unit object
        Quartet<Integer, String, String, Double> quartet
            = Quartet.with(Integer.valueOf(1),
                           "GeeksforGeeks",
                           "A computer portal",
                           Double.valueOf(20.18),
                           Integer.valueOf(1));
  
        System.out.println(quartet);
    }
}

Output:

Exception in thread "main" java.lang.RuntimeException: 
Uncompilable source code - Erroneous sym type: org.javatuples.Quartet.with
    at MainClass.GfG.main


Note: Similarly, it can be used with any other JavaTuple Class.




My Personal Notes arrow_drop_up
Recommended Articles
Page :