Class Tuple2<A,​B>

  • Type Parameters:
    A - The type of the first member-field ('a').
    B - The type of the second member-field ('b').
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable
    public class Tuple2<A,​B>
extends TupleN
implements java.io.Serializable, java.lang.Cloneable
    This simple generic-class allows for storing two objects with a single reference.

    Modifiable, Read-Write: Classes which inherit Ancestor-Class TupleN will always contains fields which have been declared without the use of the 'final' modifier. These classes are, therefore, "Mutable Tuples" - meaning their contents may be changed whenever necessary.

    Remember: The classes Ret2 and Tuple2 completely identical, with the sole difference being that Ret2 fields are all declared 'final', but the Tuple2 fields are not!
    See Also:
    Serialized Form


    • Field Summary

       
      Serializable ID
      Modifier and Type Field
      protected static long serialVersionUID
       
      Instance Fields
      Modifier and Type Field
      A a
      B b

    • Constructor Summary

      Constructors 
      Constructor
      Tuple2()
      Tuple2​(A a, B b)

    • Method Summary

       
      Retrieve the Number of Fields in this Class
      Modifier and Type Method
      int n()
       
      Retrieve a Field by Field-Number
      Modifier and Type Method
      Object get​(int i)
       
      Convert this instance to an Immutable RetN instance, of the same size
      Modifier and Type Method
      Ret2<A,​B> toImmutable()
       
      Methods: interface java.lang.Cloneable
      Modifier and Type Method
      Tuple2<A,​B> clone()

      • Methods inherited from class java.lang.Object

        finalize, getClass, notify, notifyAll, wait, wait, wait

    • Field Detail

      • serialVersionUID

        🡇  ⇈  ⮫ 🗕  🗗  🗖 
        protected static final long serialVersionUID
        This fulfils the SerialVersion UID requirement for all classes that implement Java's interface java.io.Serializable. Using the Serializable Implementation offered by java is very easy, and can make saving program state when debugging a lot easier. It can also be used in place of more complicated systems like "hibernate" to store data as well.
        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
         protected static final long serialVersionUID = 1;

      • a

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public A a
        This holds a pointer the first field / instance.
        Code:
        Exact Field Declaration Expression:
         public A a;

      • b

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public B b
        This holds a pointer to the second field / instance.
        Code:
        Exact Field Declaration Expression:
         public B b;

    • Method Detail

      • n

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public int n()
        Returns '2', indicating how many fields are declared by this class.
        Specified by:
        n in class MultiType
        Returns:
        As an instance of Tuple1, this method returns '2';
        Code:
        Exact Method Body:
         return 2;

      • clone

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public Tuple2<A,​B> clone()
        Description copied from class: MultiType
        Clones the contents of 'this' instance of.
        Specified by:
        clone in class MultiType
        Returns:
        A clone copy of 'this' object.
        Code:
        Exact Method Body:
         return new Tuple2<>(this.a, this.b);

      • get

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.Object get​(int i)
        This method will retreive the ith field of this instance. This can be useful when you wish to use the Ancestor / Parent classses: TupleN or MultiType for handling 'this' instance.

        As a reminder, the fields inside this class have all been declared public! Referencing this instance' fields, directly, will always work in place of calling any of the get(...) methods.

        Type Casting:
        This method can make for easier typing. When using either of the super-classes of this class - namely TupleN or MultiType - you simply do not have to type (into your computer's keyboard) all of the Field Generic Types (the stuff between the '<' and '>' less-than & greater-than symbols).

        However, anytime one of these ancestor classes are used instead of the actual Tuple2 instance, you will have to use one of the provided 'get' methods to retrieve a field inside the Tuple2 instance. This is because the parent-ancestor classes do not actually have any fields to retrieve.

        There are three 'get' methods provided in Root-Ancestor Class MultiType. Each of these three 'getters' allows for casting (this) sub-class' returned fields in a slightly different way. When you aren't referencing the actual instance, itself, but rather one of the two Parent-Tuple Classes, you must use one of their getters, and you will have to cast the fields that you wish to use, eventually!

        Example:
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// No Cast Necessary
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

// This line makes for longer typing, but DOES NOT REQUIRE A CAST TO RETRIEVE FIELDS.
// Here the example Multi-Type Identifier is used: Tuple2.

Tuple2<String, Integer> ref2 = some_function_returns_2();
String neededStrField = ref2.a;


// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// Less Keyboard-Typing (Less Eyesores), but Requires a Cast
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

// If the Tuple2 super-class TupleN is used to reference this class data,
// YOU WILL NEED TO CAST THE FIELDS BEFORE YOU CAN THEM, AS IN THE EXAMPLES BELOW:

TupleN refN = some_function_returns2();

// Version #1: (this method) - simple 'get'
@SuppressWarnings("unchecked")
String neededStrField = (String) refN.get(1);

// Version #1: The second Method-Parameter is a 'Class<T>' Type-Parameter
// Note, again, that passing a '1' to the first parameter retrieves Tuple2.a

String neededStrField = refN.get(1, String.class);

// Version #3: "GET" (in all caps) utilizes Java "Type-Inferencing" - the Return-Type
// is specified by the left side of the assignments statement.

String needesStrField = refN.GET(1);
        Specified by:
        get in class MultiType
        Parameters:
        i - This specifies which field of the instance is being requested.

        Important: Unlike a Java array, when a '1' is passed to this parameter, it is requesting the first field in this instance. Passing a value of '0' shall cause an IndexOutOfBoundsException throw.
        Returns:
        This returns the ith field of this class.
        See Also:
        MultiType.get(int, Class), MultiType.GET(int)
        Code:
        Exact Method Body:
         // Throws Exception if i not 1 or 2
 CHECK_GET(i);
 return (i == 1) ? a : b;

      • toImmutable

        🡅  ⇈  ⮫ 🗕  🗗  🗖 
        public Ret2<A,​B> toImmutable()
        Description copied from class: TupleN
        Converts 'this' Modifiable TupleN instance into a Read-Only RetN.
        Specified by:
        toImmutable in class TupleN
        Returns:
        A RetN of the same size, which is an immutable type whose fields have been decorated with the 'final' modifier - and therefore cannot be changed once the instance has been constructed.
        Code:
        Exact Method Body:
         return new Ret2<>(this.a, this.b);