Implémente plusieurs interfaces avec conflit de signatures

Question

Enfin, j'ai essayé d'implémenter une structure hybride en Java, qui ressemble à ceci:

public class MapOfSet<K, V extends HasKey<K>> implements Set<V>, Map<K, Set<V>>

Où HasKey est l'interface suivante:

public interface HasKey<K> {
    public K getKey();
}

Malheureusement, il existe des conflits entre la signature methos de l'interface Set et l'interface Map en Java. J'ai finalement choisi d'implémenter uniquement l'interface Set et d'ajouter la méthode Map sans implémenter cette interface.

Voyez-vous une solution plus intéressante?

En réponse aux premiers commentaires, voici mon objectif:

  

Avoir une structure d’ensemble et pouvoir accéder efficacement à un sous-ensemble de valeurs de cet ensemble, correspondant à une valeur de clé donnée.   Au début, j'ai instancié une carte et un jeu, mais j'ai essayé de joindre les deux structures pour optimiser les performances.

Answer 1

Peut-être pourriez-vous ajouter plus d'informations sur les opérations que vous souhaitez réellement. Je suppose que vous voulez créer un ensemble qui regroupe automatiquement leurs éléments par une clé, non? La question est de savoir quelles opérations voulez-vous pouvoir effectuer? Comment les éléments sont-ils ajoutés à l'ensemble? Les éléments peuvent-ils être supprimés en les supprimant d'une vue groupée? Ma proposition serait une interface comme celle-ci:

public interface GroupedSet<K, V extends HasKey<K>> extends Set<V>{
    Set<V> havingKey(K k);
}

Si vous souhaitez pouvoir utiliser la définition en tant que carte, vous pouvez ajouter une autre méthode

Map<K,Set<V>> asMap();

Cela évite l'utilisation de l'héritage à plusieurs interfaces et les problèmes qui en résultent.

Answer 2

Qu'est-ce que vous essayez d'accomplir? Map expose déjà ses clés en tant que Set via son [keySet ()] ( http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map .html # keySet ()) méthode. Si vous souhaitez un ordre itératif fiable, il existe LinkedHashMap et TreeMap .

UPDATE: si vous voulez vous assurer qu'une valeur n'a été insérée qu'une seule fois, vous pouvez étendre l'une des classes mentionnées ci-dessus pour créer quelque chose comme un SingleEntryMap et remplacer l'implémentation de . put (clé K, valeur V) pour effectuer une vérification de l'unicité et émettre une exception lorsque la valeur a déjà été insérée.

UPDATE: Est-ce que quelque chose comme ça va marcher? (Je n'ai pas mon éditeur, donc cela ne peut pas compiler)

public final class KeyedSets<K, V> implements Map<K,Set<V>> {
    private final Map<K, Set<V>> internalMap = new TreeMap<K, Set<V>>;
    // delegate methods go here
    public Set<V> getSortedSuperset() {
        final Set<V> superset = new TreeSet<V>();
        for (final Map.Entry<K, V> entry : internalMap.entrySet()) {
            superset.addAll(entry.getValue());
        }
        return superset;
    }
}

Answer 3

Je dirais que quelque chose qui est censé être parfois utilisé comme une carte et parfois comme un ensemble doit implémenter Map, car cela peut être vu comme un ensemble de clés ou de valeurs ainsi que comme un mappage entre des clés et des valeurs. C’est à quoi servent les méthodes Map.containsKey () et Map.containsValue ().