What is the equivalent of the C Pair L R in Java

Question

Is there a good reason why there is no Pair lt L R gt  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 lt K V gt    but this looks quite convoluted

User · Answer

JavaFX  which comes bundled with Java 8  has the Pair lt  A B   class

User · Answer

If anyone wants a dead-simple and easy to use version I made my available at https   github com lfac-pt Java-Pair  Also  improvements are very much welcome

User · Answer

Spring data has a Pair and can be used like below  Pair lt S  T gt  pair   Pair of S type data  T type data

User · Answer

com sun tools javac util Pair is an simple implementation of a pair   It can be found in jdk1 7 0 51 lib tools jar   Other than the org apache commons lang3 tuple Pair  it s not just an interface

User · Answer

public class Pair lt K  V gt         private final K element0      private final V element1       public static  lt K  V gt  Pair lt K  V gt  createPair K key  V value            return new Pair lt K  V gt  key  value              public Pair K element0  V element1            this element0   element0          this element1   element1             public K getElement0             return element0             public V getElement1             return element1             usage    Pair lt Integer  String gt  pair   Pair createPair 1   test    pair getElement0    pair getElement1      Immutable  only a pair

User · Answer

As many others have already stated  it really depends on the use case if a Pair class is useful or not   I think for a private helper function it is totally legitimate to use a Pair class if that makes your code more readable and is not worth the effort of creating yet another value class with all its boiler plate code   On the other hand  if your abstraction level requires you to clearly document the semantics of the class that contains two objects or values  then you should write a class for it  Usually that s the case if the data is a business object   As always  it requires skilled judgement   For your second question I recommend the Pair class from the Apache Commons libraries  Those might be considered as extended standard libraries for Java   https   commons apache org proper commons-lang apidocs org apache commons lang3 tuple Pair html  You might also want to have a look at Apache Commons  EqualsBuilder  HashCodeBuilder and ToStringBuilder which simplify writing value classes for your business objects

User · Answer

Try VAVR Tuples  Not only does vavr have a good set of tuple types  it has great support for functional programming  too

User · Answer

The biggest problem is probably that one can t ensure immutability on A and B  see How to ensure that type parameters are immutable  so hashCode   may give inconsistent results for the same Pair after is inserted in a collection for instance  this would give undefined behavior  see Defining equals in terms of mutable fields   For a particular  non generic  Pair class the programmer may ensure immutability by carefully choosing A and B to be immutable   Anyway  clearing generic s warnings from  PeterLawrey s answer  java 1 7     public class Pair lt A extends Comparable lt   super A gt                       B extends Comparable lt   super B gt  gt          implements Comparable lt Pair lt A  B gt  gt         public final A first      public final B second       private Pair A first  B second            this first   first          this second   second             public static  lt A extends Comparable lt   super A gt                       B extends Comparable lt   super B gt  gt              Pair lt A  B gt  of A first  B second            return new Pair lt A  B gt  first  second               Override     public int compareTo Pair lt A  B gt  o            int cmp   o    null   1    this first  compareTo o first           return cmp    0    this second  compareTo o second    cmp              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 lt      gt   obj  first                   amp  amp  equal second    Pair lt      gt   obj  second                 TODO   move this to a helper class      private boolean equal Object o1  Object o2            return o1    o2     o1    null  amp  amp  o1 equals o2                Override     public String toString             return       first          second                  Additions corrections much welcome    In particular I am not quite sure about my use of Pair lt      gt    For more info on why this syntax see Ensure that objects implement Comparable and for a detailed explanation How to implement a generic max Comparable a  Comparable b  function in Java

User · Answer

The answer by  Andreas Krey is actually good   Anything Java makes difficult  you probably shouldn t be doing   The most common uses of Pair s in my experience have been multiple return values from a method and as VALUES in a hashmap  often indexed by strings    In the latter case  I recently used a data structure  something like this   class SumHolder MyObject trackedObject  double sum     There is your entire  Pair  class  pretty much the same amount of code as a generic  Pair  but with the advantage of descriptive names   It can be defined in-line right in the method it s used which will eliminate typical problems with public variables and the like   In other words  it s absolutely better than a pair for this usage  due to the named members  and no worse     If you actually want a  Pair  for the key of a hashmap you are essentially creating a double-key index  I think this may be the one case where a  Pair  is significantly less code   It s not really easier because you could have eclipse generate equals hash on your little data class  but it would be a good deal more code  Here a Pair would be a quick fix  but if you need a double-indexed hash who s to say you don t need an n-indexed hash   The data class solution will scale up  the Pair will not unless you nest them   So the second case  returning from a method  is a bit harder   Your class needs more visibility  the caller needs to see it too    You can define it outside the method but inside the class exactly as above   At that point your method should be able to return a MyClass SumHolder object   The caller gets to see the names of the returned objects  not just a  Pair    Note again that the  Default  security of package level is pretty good--it s restrictive enough that you shouldn t get yourself into too much trouble   Better than a  Pair  object anyway   The other case I can see a use for Pairs is a public api with return values for callers outside your current package   For this I d just create a true object--preferably immutable  Eventually a caller will share this return value and having it mutable could be problematic  This is another case of the Pair object being worse--most pairs cannot be made immutable   Another advantage to all these cases--the java class expands  my sum class needed a second sum and a  Created  flag by the time I was done  I would have had to throw away the Pair and gone with something else  but if the pair made sense  my class with 4 values still makes at least as much sense

User · Answer

Apache Commons Lang 3 0  has a few Pair classes   http   commons apache org proper commons-lang apidocs org apache commons lang3 tuple package-summary html

User · Answer

The shortest pair that I could come up with is the following  using Lombok    Data  AllArgsConstructor staticName    of   public class Pair lt F  S gt        private F first      private S second      It has all the benefits of the answer from  arturh  except the comparability   it has hashCode  equals  toString and a static    constructor

User · Answer

Brian Goetz  Paul Sandoz and Stuart Marks explain why during QA session at Devoxx 14   Having generic pair class in standard library will turn into technical debt once value types introduced   See also  Does Java SE 8 have Pairs or Tuples

User · Answer

Pair would be a good stuff  to be a basic construction unit for a complex generics  for instance  this is from my code   WeakHashMap lt Pair lt String  String gt   String gt  map         It is just the same as Haskell s Tuple

User · Answer

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 lt String  Object gt  map            just an example for  Map Entry lt String  Object gt  entry   map entrySet        System out printf   s - gt   s n   entry getKey    entry getValue

User · Answer

Map Entry interface come pretty close to c   pair  Look at the concrete implementation  like AbstractMap SimpleEntry and AbstractMap SimpleImmutableEntry First item is getKey   and second is getValue

User · Answer

You can use Google s AutoValue library - https   github com google auto tree master value   You create a very small abstract class and annotate it with  AutoValue and the annotation processor generates a concrete class for you that has a value semantic

User · Answer

You can use javafx utility class  Pair which serves the same purpose as pair  lt   in c    https   docs oracle com javafx 2 api javafx util Pair html

User · Answer

Good News JavaFX has a key value Pair    just add javafx as a dependency and import javafx util Pair   and use simply as in c      Pair  lt Key  Value gt     e g    Pair  lt Integer  Integer gt  pr   new Pair lt Integer  Integer gt     pr get key     will return corresponding value

User · Answer

I noticed all the Pair implementations being strewn around here attribute meaning to the order of the two values  When I think of a pair  I think of a combination of two items in which the order of the two is of no importance  Here s my implementation of an unordered pair  with hashCode and equals overrides to ensure the desired behaviour in collections  Also cloneable          The class  lt code gt Pair lt  code gt  models a container for two objects wherein the    object order is of no consequence for equality and hashing  An example of    using Pair would be as the return type for a method that needs to return two    related objects  Another good use is as entries in a Set or keys in a Map    when only the unordered combination of two objects is of interest  lt p gt     The term  object  as being a one of a Pair can be loosely interpreted  A    Pair may have one or two  lt code gt null lt  code gt  entries as values  Both values    may also be the same object  lt p gt     Mind that the order of the type parameters T and U is of no importance  A    Pair amp lt T  U gt  can still return  lt code gt true lt  code gt  for method  lt code gt equals lt  code gt     called with a Pair amp lt U  T gt  argument  lt p gt     Instances of this class are immutable  but the provided values might not be     This means the consistency of equality checks and the hash code is only as    strong as that of the value types  lt p gt      public class Pair lt T  U gt  implements Cloneable                   One of the two values  for the declared type T              private final T object1                 One of the two values  for the declared type U              private final U object2      private final boolean object1Null      private final boolean object2Null      private final boolean dualNull                  Constructs a new  lt code gt Pair amp lt T  U amp gt  lt  code gt  with T object1 and U object2 as        its values  The order of the arguments is of no consequence  One or both of        the values may be  lt code gt null lt  code gt  and both values may be the same object                 param object1 T to serve as one value          param object2 U to serve as the other value              public Pair T object1  U object2             this object1   object1          this object2   object2          object1Null   object1    null          object2Null   object2    null          dualNull   object1Null  amp  amp  object2Null                         Gets the value of this Pair provided as the first argument in the constructor                 return a value of this Pair              public T getObject1              return object1                         Gets the value of this Pair provided as the second argument in the constructor                 return a value of this Pair              public U getObject2              return object2                         Returns a shallow copy of this Pair  The returned Pair is a new instance        created with the same values as this Pair  The values themselves are not        cloned                 return a clone of this Pair               Override     public Pair lt T  U gt  clone              return new Pair lt T  U gt  object1  object2                          Indicates whether some other object is  equal  to this one         This Pair is considered equal to the object if and only if         lt ul gt          lt li gt the Object argument is not null          lt li gt the Object argument has a runtime type Pair or a subclass          lt  ul gt         AND         lt ul gt          lt li gt the Object argument refers to this pair         lt li gt OR this pair s values are both null and the other pair s values are both null         lt li gt OR this pair has one null value and the other pair has one null value and        the remaining non-null values of both pairs are equal         lt li gt OR both pairs have no null values and have value tuples  amp lt v1  v2 gt  of        this pair and  amp lt o1  o2 gt  of the other pair so that at least one of the        following statements is true          lt ul gt          lt li gt v1 equals o1 and v2 equals o2         lt li gt v1 equals o2 and v2 equals o1         lt  ul gt          lt  ul gt         In any other case  such as when this pair has two null parts but the other        only one  this method returns false  lt p gt         The type parameters that were used for the other pair are of no importance         A Pair amp lt T  U gt  can return  lt code gt true lt  code gt  for equality testing with        a Pair amp lt T  V gt  even if V is neither a super- nor subtype of U  should        the the value equality checks be positive or the U and V type values        are both  lt code gt null lt  code gt   Type erasure for parameter types at compile        time means that type checks are delegated to calls of the  lt code gt equals lt  code gt         methods on the values themselves                 param obj the reference object with which to compare          return true if the object is a Pair equal to this one               Override     public boolean equals Object obj             if obj    null              return false           if this    obj              return true           if   obj instanceof Pair lt      gt                return false           final Pair lt      gt  otherPair    Pair lt      gt  obj           if dualNull              return otherPair dualNull             After this we re sure at least one part in this is not null          if otherPair dualNull              return false             After this we re sure at least one part in obj is not null          if object1Null                if otherPair object1Null    Yes  this and other both have non-null part2                 return object2 equals otherPair object2               else if otherPair object2Null    Yes  this has non-null part2  other has non-null part1                 return object2 equals otherPair object1               else   Remaining case  other has no non-null parts                 return false            else if object2Null                if otherPair object2Null    Yes  this and other both have non-null part1                 return object1 equals otherPair object1               else if otherPair object1Null    Yes  this has non-null part1  other has non-null part2                 return object1 equals otherPair object2               else   Remaining case  other has no non-null parts                 return false            else                 Transitive and symmetric requirements of equals will make sure               checking the following cases are sufficient             if object1 equals otherPair object1                   return object2 equals otherPair object2               else if object1 equals otherPair object2                   return object2 equals otherPair object1               else                 return false                                   Returns a hash code value for the pair  This is calculated as the sum        of the hash codes for the two values  wherein a value that is  lt code gt null lt  code gt         contributes 0 to the sum  This implementation adheres to the contract for         lt code gt hashCode   lt  code gt  as specified for  lt code gt Object   lt  code gt   The returned        value hash code consistently remain the same for multiple invocations        during an execution of a Java application  unless at least one of the pair        values has its hash code changed  That would imply information used for         equals in the changed value s  has also changed  which would carry that        change onto this class   lt code gt equals lt  code gt  implementation                 return a hash code for this Pair               Override     public int hashCode              int hashCode   object1Null   0   object1 hashCode            hashCode     object2Null   0   object2 hashCode             return hashCode              This implementation has been properly unit tested and the use in a Set and Map has been tried out     Notice I m not claiming to release this in the public domain  This is code I ve just written for use in an application  so if you re going to use it  please refrain from making a direct copy and mess about with the comments and names a bit  Catch my drift

User · Answer

another terse lombok implementation  import lombok Value    Value staticConstructor    of   public class Pair lt F  S gt        private final F first      private final S second

User · Answer

Here are some libraries that have multiple degrees of tuples for your convenience    JavaTuples  Tuples from degree 1-10 is all it has   JavaSlang  Tuples from degree 0-8 and lots of other functional goodies   jOO   Tuples from degree 0-16 and some other functional goodies   Disclaimer  I work for the maintainer company   Functional Java  Tuples from degree 0-8 and lots of other functional goodies     Other libraries have been mentioned to contain at least the Pair tuple   Specifically  in the context of functional programming which makes use of a lot of structural typing  rather than nominal typing  as advocated in the accepted answer   those libraries and their tuples come in very handy

User · Answer

android provides Pairclass  http   developer android com reference android util Pair html    here the implementation   public class Pair lt F  S gt        public final F first      public final S second       public Pair F first  S second            this first   first          this second   second              Override     public boolean equals Object o            if    o instanceof Pair                 return false                    Pair lt      gt  p    Pair lt      gt   o          return Objects equal p first  first   amp  amp  Objects equal p second  second               Override     public int hashCode             return  first    null   0   first hashCode       second    null   0   second hashCode                public static  lt A  B gt  Pair  lt A  B gt  create A a  B b            return new Pair lt A  B gt  a  b

User · Answer

According to the nature of Java language  I suppose people do not actually require a Pair  an interface is usually what they need  Here is an example   interface Pair lt L  R gt        public L getL        public R getR        So  when people want to return two values they can do the following         Calcuate the return value final Integer v1   result1  final String v2   result2  return new Pair lt Integer  String gt         Integer getL    return v1        String getR    return v2        This is a pretty lightweight solution  and it answers the question  What is the semantic of a Pair lt L R gt     The answer is  this is an interface build with two  may be different  types  and it has methods to return each of them  It is up to you to add further semantic to it  For example  if you are using Position and REALLY want to indicate it in you code  you can define PositionX and PositionY that contains Integer  to make up a Pair lt PositionX PositionY gt   If JSR 308 is available  you may also use Pair lt  PositionX Integer   PositionY Ingeger gt  to simplify that   EDIT  One thing I should indicate here is that the above definition explicitly relates the type parameter name and the method name  This is an answer to those argues that a Pair is lack of semantic information  Actually  the method getL means  give me the element that correspond to the type of type parameter L   which do means something   EDIT  Here is a simple utility class that can make life easier   class Pairs       static  lt L R gt  Pair lt L R gt  makePair final L l  final R r           return new Pair lt L R gt                 public L getL     return l                public R getR     return r                            usage   return Pairs makePair new Integer 100    123

User · Answer

With new version of Lombok you can compile that cute class    Value staticConstructor    of   public class Pair  lt E gt      E first  second      and use it like  Pair lt Value gt  pairOfValues   Pair of value1  value2

User · Answer

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

User · Answer

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 lt FIRST  SECOND gt  implements Comparable lt Pair lt FIRST  SECOND gt  gt         public final FIRST first      public final SECOND second       private Pair FIRST first  SECOND second            this first   first          this second   second             public static  lt FIRST  SECOND gt  Pair lt FIRST  SECOND gt  of FIRST first              SECOND second            return new Pair lt FIRST  SECOND gt  first  second               Override     public int compareTo Pair lt FIRST  SECOND gt  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                   amp  amp  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

User · Answer

In my opinion  there is no Pair in Java because  if you want to add extra functionality directly on the pair  e g  Comparable   you must bound the types  In C    we just don t care  and if types composing a pair do not have operator  lt   the pair  operator  lt  will not compile as well   An example of Comparable with no bounding   public class Pair lt F  S gt  implements Comparable lt Pair lt   extends F    extends S gt  gt        public final F first      public final S second                    public int compareTo Pair lt   extends F    extends S gt  that            int cf   compare first  that first           return cf    0   compare second  that second    cf              Why null is decided to be less than everything      private static int compare Object l  Object r            if  l    null                return r    null   0   -1            else               return r    null   1     Comparable   l   compareTo r                                 Pair lt Thread  HashMap lt String  Integer gt  gt  a              Pair lt Thread  HashMap lt String  Integer gt  gt  b                Runtime error here instead of compile error  System out println a compareTo b      An example of Comparable with compile-time check for whether type arguments are comparable   public class Pair lt          F extends Comparable lt   super F gt            S extends Comparable lt   super S gt   gt  implements Comparable lt Pair lt   extends F    extends S gt  gt        public final F first      public final S second                    public int compareTo Pair lt   extends F    extends S gt  that            int cf   compare first  that first           return cf    0   compare second  that second    cf              Why null is decided to be less than everything      private static  lt              T extends Comparable lt   super T gt       gt  int compare T l  T r            if  l    null                return r    null   0   -1            else               return r    null   1   l compareTo r                                   Will not compile because Thread is not Comparable lt   super Thread gt  Pair lt Thread  HashMap lt String  Integer gt  gt  a              Pair lt Thread  HashMap lt String  Integer gt  gt  b              System out println a compareTo b      This is good  but this time you may not use non-comparable types as type arguments in Pair  One may use lots of Comparators for Pair in some utility class  but C   people may not get it  Another way is to write lots of classes in a type hierarchy with different bounds on type arguments  but there are too many possible bounds and their combinations

User · Answer

HashMap compatible Pair class   public class Pair lt A  B gt        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  amp  amp  otherPair first    null  amp  amp                    this first equals otherPair first     amp  amp                  this second    otherPair second                      this second    null  amp  amp  otherPair second    null  amp  amp                    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

User · Answer

Collections singletonMap left  rigth

User · Answer

Simple way Object    - can be use as an  dimention tuple

User · Answer

Many people are posting Pair code that is usable as a key in a Map   If you re trying to use a pair as a hashing key  a common idiom   be sure to check out Guava s Table lt R C V gt   http   code google com p guava-libraries wiki NewCollectionTypesExplained Table  They give the following example usage  for graph edges   Table lt Vertex  Vertex  Double gt  weightedGraph   HashBasedTable create    weightedGraph put v1  v2  4   weightedGraph put v1  v3  20   weightedGraph put v2  v3  5    weightedGraph row v1      returns a Map mapping v2 to 4  v3 to 20 weightedGraph column v3      returns a Map mapping v1 to 20  v2 to 5   A Table maps two keys to a single value  and provides efficient lookups for both types of keys alone as well  I ve started using this data structure instead of a Map lt Pair lt K1 K2 gt   V gt  in many parts of my code  There are array  tree  and other implementations for both dense and sparse uses  with the option of specifying your own intermediate map classes

User · Answer

In a 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

User · Answer

How about http   www javatuples org index html I have found it very useful   The javatuples offers you tuple classes from one to ten elements   Unit lt A gt   1 element  Pair lt A B gt   2 elements  Triplet lt A B C gt   3 elements  Quartet lt A B C D gt   4 elements  Quintet lt A B C D E gt   5 elements  Sextet lt A B C D E F gt   6 elements  Septet lt A B C D E F G gt   7 elements  Octet lt A B C D E F G H gt   8 elements  Ennead lt A B C D E F G H I gt   9 elements  Decade lt A B C D E F G H I J gt   10 elements

User · Answer

Despite being syntactically similar  Java and C   have very different paradigms  Writing C   like Java is bad C    and writing Java like C   is bad Java   With a reflection based IDE like Eclipse  writing the necessarily functionality of a  pair  class is quick and simple  Create class  define two fields  use the various  Generate XX  menu options to fill out the class in a matter of seconds  Maybe you d have to type a  compareTo  real quick if you wanted the Comparable interface   With separate declaration   definition options in the language C   code generators aren t so good  so hand writing little utility classes is more time consuming tedium  Because the pair is a template  you don t have to pay for functions you don t use  and the typedef facility allows assigning meaningful typenames to the code  so the objections about  no semantics  don t really hold up

User · Answer

For programming languages like Java  the alternate data structure used by most programmers to represent pair like data-structures are two array  and data is accessed via the same index   example  http   www-igm univ-mlv fr  lecroq string node8 html SECTION0080  This isn t ideal as the data should be bound together  but also turn out to be pretty cheap  Also  if your use case demands storing co-ordinates then its better to build your own data structure    I ve something like this in my library  public class Pair lt First Second gt

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

Examples related to java

Examples related to tuples

Examples related to std-pair