Quel est l'équivalent de la paire C ++ <L,R> en Java?

Question

Y at-il une bonne raison pour laquelle il n'y a pas de paire en Java? Quel serait l'équivalent de cette construction C ++? Je préfère éviter de réimplémenter le mien.

Il semble que 1.6 fournit quelque chose de similaire (AbstractMap.SimpleEntry), mais cela semble assez compliqué.

Answer 1

Dans ce fil sur comp.lang.java.help, Chasseur Gratzner donne quelques arguments contre la présence d'un Pair construire en Java. Le principal argument est qu'une classe Pair ne rend pas toute la sémantique de la relation entre les deux valeurs (comment savez-vous ce que "première" et "deuxième"?).

Une meilleure pratique consiste à écrire une classe très simple, comme celui de Mike proposé, pour chaque application que vous aurait fait de l' Pair classe. Map.Entry est un exemple de paire que son sens en son nom.

Pour résumer, à mon avis, il est préférable d'avoir une classe Position(x,y), une classe Range(begin,end) , et une classe Entry(key,value) plutôt qu'un générique Pair(first,second) qui ne me dit rien sur ce qu'il est censé faire.

Answer 2

C'est Java. Vous devez créer votre propre classe de paires avec des noms de classes et de champs descriptifs, et ne pas oublier que vous allez réinventer la roue en écrivant hashCode () / equals () ou en implémentant de façon répétitive.

Answer 3

HashMap compatible classe de paire:

 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 4

La paire la plus courte que je pourrais trouver est la suivante, en utilisant Lombok :

 @Data
@AllArgsConstructor(staticName = "of")
public class Pair<F, S> {
    private F first;
    private S second;
}
 

Il a tous les avantages de la réponse de @arturh (sauf la comparabilité), il a hashCode , equals , toString et un "constructeur" statique.

Answer 5

Une autre façon d'implémenter Pair avec.

• Champs publics immuables, c'est-à-dire structure de données simple.
• Comparable.
• Hash simple et égal.

• Usine simple donc vous n'avez pas à fournir les types. par exemple Pair.of ("bonjour", 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 + ')';
      }
  }