Pregunta ¿Cuál es el equivalente del par C ++ en Java?


¿Hay una buena razón por la cual no hay Pair<L,R> en Java? ¿Cuál sería el equivalente de esta construcción C ++? Preferiría evitar reimplementar el mío.

Parece que 1.6 proporciona algo similar (AbstractMap.SimpleEntry<K,V>), pero esto parece bastante intrincado.


595
2017-10-01 04:48


origen


Respuestas:


En un hilo en comp.lang.java.help, Hunter Gratzner da algunos argumentos en contra de la presencia de un Pair construir en Java. El argumento principal es que una clase Pair no transmite ninguna semántica sobre la relación entre los dos valores (¿cómo se sabe qué significa "primero" y "segundo"?).

Una mejor práctica es escribir una clase muy simple, como la propuesta por Mike, para cada aplicación que habría hecho del Pair clase. Map.Entry es un ejemplo de un par que lleva su significado en su nombre.

En resumen, en mi opinión, es mejor tener una clase Position(x,y), una clase Range(begin,end) y una clase Entry(key,value) en lugar de un genérico Pair(first,second) eso no me dice nada sobre lo que se supone que debe hacer.


359
2017-10-01 08:18



Esto es Java Debes crear tu propia clase de par personalizada con clase descriptiva y nombres de campo, y no te importe que reinventes la rueda escribiendo hashCode () / equals () o implementando Comparable una y otra vez.


137
2018-02-27 10:41



Clase de par compatible con HashMap:

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;
    }
}

99
2018-03-24 12:55



El par más corto que pude encontrar es el siguiente, usando Lombok:

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

Tiene todos los beneficios de la respuesta de @arturh (excepto la comparabilidad), tiene hashCode, equals, toString y un "constructor" estático.


46
2017-12-17 14:39



Apache Commons Lang 3.0+ tiene algunas clases de Pair: http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html


36
2018-03-13 00:21



Otra forma de implementar Pair with.

  • Campos públicos inmutables, es decir, estructura de datos simple.
  • Comparable.
  • Hash simple y es igual.
  • Fábrica simple para que no tenga que proporcionar los tipos. p.ej. Pair.of ("hola", 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 + ')';
        }
    }
    

31
2017-09-05 14:27



Qué tal si http://www.javatuples.org/index.html Lo he encontrado muy útil.

Los javatuples le ofrecen clases de tupla de uno a diez elementos:

Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)
Quartet<A,B,C,D> (4 elements)
Quintet<A,B,C,D,E> (5 elements)
Sextet<A,B,C,D,E,F> (6 elements)
Septet<A,B,C,D,E,F,G> (7 elements)
Octet<A,B,C,D,E,F,G,H> (8 elements)
Ennead<A,B,C,D,E,F,G,H,I> (9 elements)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elements)

26
2018-03-01 19:02



Depende de para qué lo quieras usar. La razón típica para hacerlo es iterar sobre los mapas, para los cuales simplemente hace esto (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());
}

12
2017-10-01 04:53



Android proporciona Pairclase (http://developer.android.com/reference/android/util/Pair.html), aquí la implementación:

public class Pair<F, S> {
    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<?, ?> p = (Pair<?, ?>) o;
        return Objects.equal(p.first, first) && Objects.equal(p.second, second);
    }

    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    public static <A, B> Pair <A, B> create(A a, B b) {
        return new Pair<A, B>(a, b);
    }
}

12
2018-05-05 08:45