Coppia Java <T,N> implementazione classe

Question

È disponibile un'implementazione della classe Pair Java dimostrata?

Intendo prontamente disponibile, ampiamente accettato e testato, forse parte di una libreria più ampia come Apache Commons o Guava.

Answer 1

Sì, dai un'occhiata a Apache Commons Pair.

Utilizzare con parsimonia, se non del tutto; left e right non trasmettono nulla sul contenuto o sulla relazione tra gli elementi.

(La classe Pair è stato volutamente lasciato fuori delle API standard di Java.)

Answer 2

Map.Entry

Che dire java.util.Map.Entry interfaccia?

Due concreta attuazione in bundle con Java 6 e versioni successive:

• java.util.AbstractMap.SimpleEntry
• java.util.AbstractMap.SimpleImmutableEntry

Answer 3

Ho usato AbstractMap.SimpleEntry e AbstractMap.SimpleImmutableEntry quando il bisogno di memorizzare coppie (come la dimensione e la raccolta di oggetti).

Questo pezzo dal mio codice di produzione:

public Map<L1Risk, Map.Entry<int[], Map<L2Risk, Map.Entry<int[], Map<L3Risk, List<Event>>>>>> 
     getEventTable(RiskClassifier classifier) { 
    Map<L1Risk, Map.Entry<int[], Map<L2Risk, Map.Entry<int[], Map<L3Risk, List<Event>>>>>> l1s = new HashMap<>(); 
    Map<L2Risk, Map.Entry<int[], Map<L3Risk, List<Event>>>> l2s = new HashMap<>(); 
    Map<L3Risk, List<Event>> l3s = new HashMap<>(); 
    List<Event> events = new ArrayList<>(); 
    ... 
    map.put(l3s, events); 
    map.put(l2s, new AbstractMap.SimpleImmutableEntry<>(l3Size, l3s)); 
    map.put(l1s, new AbstractMap.SimpleImmutableEntry<>(l2Size, l2s)); 
} 

codice sembra complicato ma invece di Map.Entry si limitato alla gamma di oggetti (con dimensioni 2) e perdere controlli di tipo ...

Answer 4

Ecco un'implementazione del SDK di Android:

/** 
* Container to ease passing around a tuple of two objects. This object provides a sensible 
* implementation of equals(), returning true if equals() is true on each of the contained 
* objects. 
*/ 
public class Pair<F, S> { 
    public final F first; 
    public final S second; 

    /** 
    * Constructor for a Pair. 
    * 
    * @param first the first object in the Pair 
    * @param second the second object in the pair 
    */ 
    public Pair(F first, S second) { 
     this.first = first; 
     this.second = second; 
    } 

    /** 
    * Checks the two objects for equality by delegating to their respective 
    * {@link Object#equals(Object)} methods. 
    * 
    * @param o the {@link Pair} to which this one is to be checked for equality 
    * @return true if the underlying objects of the Pair are both considered 
    *   equal 
    */ 
    @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); 
    } 

    /** 
    * Compute a hash code using the hash codes of the underlying objects 
    * 
    * @return a hashcode of the Pair 
    */ 
    @Override 
    public int hashCode() { 
     return (first == null ? 0 : first.hashCode())^(second == null ? 0 : second.hashCode()); 
    } 

    /** 
    * Convenience method for creating an appropriately typed pair. 
    * @param a the first object in the Pair 
    * @param b the second object in the pair 
    * @return a Pair that is templatized with the types of a and b 
    */ 
    public static <A, B> Pair <A, B> create(A a, B b) { 
     return new Pair<A, B>(a, b); 
    } 
} 

Answer 5

JavaFX ha come javafx.util.Pair.

http://docs.oracle.com/javafx/2/api/javafx/util/Pair.html

Se si include jfxrt.jar in Java SDK è possibile utilizzarlo.

Answer 6

La mia soluzione era:

public class Pair<F, S> extends java.util.AbstractMap.SimpleImmutableEntry<F, S> { 

    public Pair(F f, S s) { 
     super(f, s); 
    } 

    public F getFirst() { 
     return getKey(); 
    } 

    public S getSecond() { 
     return getValue(); 
    } 

    public String toString() { 
     return "["+getKey()+","+getValue()+"]"; 
    } 

} 

Molto semplice, con tutti i vantaggi della classe AbstractMap.SimpleImmutableEntry avvolto.