What is the equivalent of the C++ Pair<L,R> in Java?

Question

Is there a good reason why there is no Pair in Java? What would be the equivalent of this C++ construct? I would rather avoid reimplementing my own.

It seems that 1.6 is providing something similar (AbstractMap.SimpleEntry), but this looks quite convoluted.

Answer 1

It depends on what you want to use it for. The typical reason to do so is to iterate over maps, for which you simply do this (Java 5+):

Map<String, Object> map = ... ; // just an example
for (Map.Entry<String, Object> entry : map.entrySet()) {
  System.out.printf("%s -> %s\n", entry.getKey(), entry.getValue());
}

Answer 2

Here's a Java Pair<> class I just now stole from Wikipedia here (so I can't vouch for how good it is):

public class Pair<T, S>
{
  public Pair(T f, S s)
  { 
    first = f;
    second = s;   
  }

  public T getFirst()
  {
    return first;
  }

  public S getSecond() 
  {
    return second;
  }

  public String toString()
  { 
    return "(" + first.toString() + ", " + second.toString() + ")"; 
  }

  private T first;
  private S second;
}

Answer 3

The problem is that "pair" usually does not indicate very well what exactly the relationship between the two objects is.

For instance, in a map in c++ you insert a pair to add a value, but you really are just saying you want to put a value in the map, which you later want to retrieve using a particular key. This key may or may not already exist in that map.

Is there any particular reason you need a pair type?

Answer 4

In this thread on comp.lang.java.help, Hunter Gratzner gives some arguments against the presence of a Pair construct in Java. The main argument is that a class Pair doesn't convey any semantics about the relationship between the two values (how do you know what "first" and "second" mean ?).

A better practice is to write a very simple class, like the one Mike proposed, for each application you would have made of the Pair class. Map.Entry is an example of a pair that carry its meaning in its name.

To sum up, in my opinion it is better to have a class Position(x,y), a class Range(begin,end) and a class Entry(key,value) rather than a generic Pair(first,second) that doesn't tell me anything about what it's supposed to do.

Answer 5

HashMap compatible Pair class:

public class Pair<A, B> {
    private A first;
    private B second;

    public Pair(A first, B second) {
     super();
     this.first = first;
     this.second = second;
    }

    public int hashCode() {
     int hashFirst = first != null ? first.hashCode() : 0;
     int hashSecond = second != null ? second.hashCode() : 0;

     return (hashFirst + hashSecond) * hashSecond + hashFirst;
    }

    public boolean equals(Object other) {
     if (other instanceof Pair) {
      Pair otherPair = (Pair) other;
      return 
      ((  this.first == otherPair.first ||
       ( this.first != null && otherPair.first != null &&
         this.first.equals(otherPair.first))) &&
       ( this.second == otherPair.second ||
       ( this.second != null && otherPair.second != null &&
         this.second.equals(otherPair.second))) );
     }

     return false;
    }

    public String toString()
    { 
           return "(" + first + ", " + second + ")"; 
    }

    public A getFirst() {
     return first;
    }

    public void setFirst(A first) {
     this.first = first;
    }

    public B getSecond() {
     return second;
    }

    public void setSecond(B second) {
     this.second = second;
    }
}

Answer 6

Pair would be a good stuff, to be a basic construction unit for a complex generics, for instance, this is from my code:

WeakHashMap<Pair<String, String>, String> map = ...

It is just the same as Haskell's Tuple

Answer 7

This is Java. You have to make your own tailored Pair class with descriptive class and field names, and not to mind that you will reinvent the wheel by writing hashCode()/equals() or implementing Comparable again and again.

Answer 8

Another way to implement Pair with.

• Public immutable fields, i.e. simple data structure.
• Comparable.
• Simple hash and equals.

• Simple factory so you don't have to provide the types. e.g. Pair.of("hello", 1);

  public class Pair<FIRST, SECOND> implements Comparable<Pair<FIRST, SECOND>> {
  public final FIRST first;
  public final SECOND second;
  
  
  private Pair(FIRST first, SECOND second) {
      this.first = first;
      this.second = second;
  }
  
  
  public static <FIRST, SECOND> Pair<FIRST, SECOND> of(FIRST first, SECOND second) {
      return new Pair<FIRST, SECOND>(first, second);
  }
  
  
  @Override
  public int compareTo(Pair<FIRST, SECOND> o) {
      int cmp = compare(first, o.first);
      return cmp == 0 ? compare(second, o.second) : cmp;
  }
  // todo move this to a helper class.
  private static int compare(Object o1, Object o2) {
      return o1 == null ? o2 == null ? 0 : -1 : o2 == null ? +1 : ((Comparable) o1).compareTo(o2);
  }
  
  
  @Override
  public int hashCode() {
      return 31 * hashcode(first) + hashcode(second);
  }
  
  
  // todo move this to a helper class.
  private static int hashcode(Object o) {
      return o == null ? 0 : o.hashCode();
  }
  
  
  @Override
  public boolean equals(Object obj) {
      if (!(obj instanceof Pair)) return false;
      if (this == obj) return true;
      return equal(first, ((Pair) obj).first) && equal(second, ((Pair) obj).second);
  }
  
  
  // todo move this to a helper class.
  private boolean equal(Object o1, Object o2) {
      return o1 == null ? o2 == null : (o1 == o2 || o1.equals(o2));
  }
  
  
  @Override
  public String toString() {
      return "(" + first + ", " + second + ')';
  }
  }
  

Answer 9

Simple way Object [] - can be use as anу dimention tuple

Answer 10

"The main argument is that a class Pair doesn't convey any semantics about the relationship between the two values"

You could say the same about a basic type such as an 'int'. "Int" doesn't convey any semantics about what kind of integer it is - is it money, or temperature, number of people in the bus? But it would be silly to make everyone write a special int class (e.g. NumberOfPeople) every time they need to use a number in their program. For really simple things, such as ints, doubles and pairs there is no need to be so extreme.