Quelle est la meilleure façon de représenter une clé composite (clé contenant deux valeurs) d'une classe et d'un booléen

Question

HashMap<Pair<Class<T>,Boolean>,String> abc = new HashMap<Pair<Class<T>,Boolean>,String>(); 

Quelle est la meilleure façon de représenter la paire ici ... Java offre-t-il quelque chose?

Ma clé sera toujours une paire {classe, booléenne}.

Merci!

Answer 1

Je créerais une nouvelle classe d'emballage et l'utiliser comme la clé

class CustomKey 
{ 
    String cls; 
    boolean booleanValue;  
    // override equals and hashcode 
} 

Answer 2

Il n'y a pas une classe Pair dans la bibliothèque Java. Il peut y en avoir un dans JDK7. Beaucoup de grandes bases de code finissent avec un.

Cependant, êtes-vous sûr qu'un Pair est vraiment ce que vous voulez. Une classe bien encapsulée avec un comportement approprié peut être plus appropriée. Les deux Boolean et Pair et notable pour ne pas avoir de signification spécifique.

Si vous voulez vraiment l'efficacité, vous pouvez opter pour deux IdentityHashMap<Class<T>,String> s.

FWIW, autant que je sache, le plus proche de Pair<Class<T>,Boolean> dans la bibliothèque Java est java.util.concurrent.atomic.AtomicMarkableReference, mais vous aurez besoin de l'étendre à passer outre equals et hashCode

Answer 3

A cette époque Java ne dispose pas d'un type de paire ou quelque chose de similaire. Je n'en ai pas trouvé non plus dans les communes d'Apache, bien qu'il soit possible que j'aie manqué quelque chose. Dans tous les cas habituellement dans ce cas, une petite classe de données immuable est créé:

public class Key<T> { 
    private final Class<T> cls; 
    private final boolean flag; 

    public Key(Class<T> cls, boolean flag) { 
    this.cls = cls; 
    this.flag = flag; } 

    public Class<T> getClass() { 
    return cls; } 

    public boolean getFlag() { 
    return flag; } 

    // equals and hashCode *must* be implemented -- see Effective Java for examples 
} 

Certaines personnes dans ce cas, utiliseront des méthodes finales publiques au lieu - il est une question de goût, plus la probabilité de la classe va se compliquer .

J'ai vu quelques classes Pair ou Tuple implémentées si la classe est nécessaire en dehors d'un seul cas (ou si les développeurs ont un arrière-plan fonctionnel).

Answer 4

Il n'existe aucune classe appelée Pair en Java; mais il y a l'interface Map.Entry<K,V>, et il y a deux implémentations publiques de celui-ci: AbstractMap.SimpleEntry et AbstractMap.SimpleImmutableEntry.

Si vous trouvez laid utiliser les classes imbriquées directement dans votre code, vous pouvez toujours créer une classe Pair:

public class Pair<Type1, Type2> extends AbstractMap.SimpleEntry<Type1, Type2> { 
    public Pair(Type1 t1, Type2 t2) { 
     super(t1, t2); 
    } 
} 

Ou vous pouvez écrire votre propre comme ceci:

public final class Pair<Type1, Type2> { 
    public final Type1 first; 
    public final Type2 second; 

    public Pair(Type1 first, Type2 second) { 
     this.first = first; 
     this.second = second; 
    } 

    /** 
    * Factory method to ease the pain of generics. 
    */ 
    public static <T1, T2> Pair of(T1 first, T2 second) { 
     return new Pair<T1, T2>(first, second); 
    } 

    @Override 
    public boolean equals(Object obj) { 
     if (obj == null) 
      return false; 
     if (getClass() != obj.getClass()) 
      return false; 

     final Pair other = (Pair) obj; // no generics needed here 
     if (this.first != other.first && 
      (this.first == null || !this.first.equals(other.first))) 
      return false; 
     if (this.second != other.second && 
      (this.second == null || !this.second.equals(other.second))) 
      return false; 
     return true; 
    } 

    @Override 
    public int hashCode() { 
     int hash = 7; 
     hash = 37 * hash + (this.first != null ? this.first.hashCode() : 0); 
     hash = 37 * hash + (this.second != null ? this.second.hashCode() : 0); 
     return hash; 
    } 
} 

Answer 5

I avoir deux approches ici ... créer une clé {class, Boolean} -> {string} ou je pourrais aussi le faire.

{class} -> {Boolean, string}

la première approche a 1 niveau d'indirection dont la deuxième approche a 2 ... quels sont les avantages et les inconvénients ici? La deuxième approche est-elle mauvaise?