Avoir une Multimap triés sur les touches uniquement en Java

Je voudrais avoir un c.g.c.c.Multimap qui est triée en fonction des clés. Les valeurs ne devraient pas être triés. J'ai essayé de construire quelque chose avec la goyave est TreeMultimap, mais je ne peux pas l'utiliser parce que le type de la valeur n'est pas mise en œuvre Comparable.

public class MyObject /* doesn't implement Comparable */ {
  private String name;
  private int score;
  //Getters/setters are implemented
  public static Function<MyObject,Integer> myObjectToScore {
    @Override public Integer apply (MyObject o) { return o.score; }
  }
  public static Multimap<Integer,MyObject> indexOnScore(Iterable<MyObject> i) {
    Multimap<Integer,MyObject> m = Multimaps.index(i, myObjectToScore());
    //Do the sort of the keys.
    return m;
  }
}

J'ai pensé à un SortedSet des touches, puis en itérant sur chacune de ces touches dans l'ensemble trié pour récupérer les différentes valeurs, mais je m'attendais à l'aide d'un existant (encore inconnue) est une fonction de Goyave, plutôt que d'utiliser ce genre de hack.

Note: je ne vais pas faire MyObject mettre en œuvre Comparable parce qu'il n'a pas de sens avec mon objet réel.

Exemple d'entrée/sortie:

Set<MyObject> s = Sets.newHashSet(
  new MyObject("a", 2),
  new MyObject("b", 3),
  new MyObject("c", 1),
  new MyObject("d", 3),
  new MyObject("e", 1)
); //Assuming constructor MyObject(String name, int score)

for (Map.Entry<Integer, MyObject> e: MyObject.indexedOnScore(s).entries()) {
  System.out.printf("%d -> %s%n", e.getKey(), e.getValue().getName());
}

Imprime:

1 -> c //or switched with line below
1 -> e
2 -> a
3 -> b //or switched with line below
3 -> d
InformationsquelleAutor Olivier Grégoire | 2011-03-31
  1. 22

    Multimaps.index retourne un ImmutableListMultimap, de sorte que vous ne seriez pas en mesure de faire le tri après sa création. Vous pouvez, cependant, d'abord créer une triés copie de votre Iterable<MyObject> et nourrir que de Multimap.index... ImmutableListMultimap garde les choses dans le même ordre qu'il a donné.

    public static ImmutableMultimap<Integer, MyObject> indexOnScore(Iterable<MyObject> i) {
  List<MyObject> sorted = Ordering.natural().onResultOf(myObjectToScore())
      .sortedCopy(i);
  return Multimaps.index(sorted, myObjectToScore());
}

    Une autre option pourrait être de créer un TreeMultimap et l'utilisation Ordering.arbitrary() comme le Comparator pour les valeurs.

    • Oui, c'est ce que je cherchais. Et vous m'avez donné non pas un mais deux possibilités. Merci beaucoup! Edit: j'ai tout de même aversion pour les deux sortes dans une rangée, mais je vais essayer d'y faire face.
    • Eh bien, il ne fait pas de tri à deux fois... il trie juste une fois, puis crée le Multimap dans le même ordre. Il ne copie les données de la Iterable à un intermédiaire List bien.
    • Ok, merci pour l'explication!
    • Vous pouvez également utiliser ImmutableMultimap.constructeur().orderKeysBy(); ou vous pouvez utiliser Multimaps.newMultimap() qui vous permet de choisir le support de la carte et des collections (utiliser un TreeMap et, disons, ArrayList).
    • Sympa... n'avait pas remarqué ImmutableMultimap.builder().orderKeysBy() avant.
    • Je pense qu'il serait très utile d'inclure Kevin commentaire dans votre réponse.
    • Pourquoi ne pas Ordering.allEqual() au lieu de Ordering.arbitrary() pour les valeurs? La documentation dit: "Retourne une commande qui traite de toutes les valeurs de l'égalité, en indiquant "aucun ordre."
    • La principale raison de ne pas le faire serait que TreeMultimap utilise un TreeSet pour ses valeurs, et si toutes les valeurs sont considérés comme égal, il ne finissent par ne contenant que des un de ces valeurs par clé. Aussi, Ordering.allEqual() a été ajouté dans la Goyave 13, plus d'un an après que j'ai répondu à cette question. =P

    InformationsquelleAutor ColinD
  2. 16

    MultimapBuilder a été introduit dans la Goyave 16:

    <K extends Comparable<? super K>, V> ListMultimap<K, V> multimap() {
    return MultimapBuilder.treeKeys().linkedListValues().build();
}

    Qui garde vos clés triés en fonction de leur ordre naturel (treeKeys() est aussi surchargé d'accepter une coutume de comparaison), et les valeurs associées à chaque touche sont maintenus dans un LinkedList (ArrayList et HashSet sont parmi les autres options).

    InformationsquelleAutor gdejohn
  3. 8

    Si l'OP, la situation semble avoir été entendu à l'aide de immuable multimap fonctions de construction, j'ai besoin d'une mutable version de ce qu'il demandait. Dans le cas où il aide à quelqu'un, voici le générique de la méthode que j'ai fini par créer:

    static <K, V> Multimap<K, V> newTreeArrayListMultimap(
    final int expectedValuesPerKey)
{
    return Multimaps.newMultimap(new TreeMap<K, Collection<V>>(),
        new Supplier<Collection<V>>()
        {
            @Override
            public Collection<V> get()
            {
                return new ArrayList<V>(expectedValuesPerKey);
            }
        });
}
    InformationsquelleAutor Trevor Robinson
  4. 4

    Appel Multimaps.newMultimap, qui vous donne la souplesse nécessaire pour créer, par exemple, une Multimap soutenu par TreeMap dont les valeurs sont ArrayLists.

    • Intéressant de voir que vous avez écrit le Multimaps code et pourtant, personne ne semble le remarquer
    InformationsquelleAutor Jared Levy
  5. 2

    Je tiens à souligner que la solution de rechange solution proposée, à savoir "pour créer un TreeMultimap et l'utilisation de la Commande.arbitraire() comme point de Comparaison pour les valeurs", ne fonctionne que si MyObject ne pas remplacer equals() ou hashcode(). De la commande.arbitraire() est incompatible avec d'égal à égal et utilise l'identité de l'objet au lieu de cela, ce qui rend-il pas une bonne idée de l'utiliser en conjonction avec un TreeSet.

    InformationsquelleAutor GFonte
  6. 1

    Comment à ce sujet:

        public static Multimap<Integer, MyObject> indexOnScore(Iterable<MyObject> i) {
        Multimap<Integer, MyObject> m = Multimaps.index(i, myObjectToScore());

        Multimap<Integer, MyObject> sortedKeys = Multimaps.newMultimap(
                Maps.<Integer, Collection<MyObject>>newTreeMap(),
                new Supplier<Collection<MyObject>>() {
                    @Override
                    public Collection<MyObject> get() {
                        return Lists.newArrayList(); //Or a Set if appropriate
                    }
                }
        );

        sortedKeys.putAll(m);

        return sortedKeys;
    }

    Il y aurait de la surcharge de la création de deux Multimaps dans ce cas, si.

    • Comme vous l'avez dit, c'est trop de la création de deux différents Multimaps.
    • Ouais, j'aime @ColinD la réponse de mieux moi aussi.
    InformationsquelleAutor Paul Blessing
  7. 1

    Vous pouvez le faire avec TreeMultimap si vous utilisez des Comparateurs.

    Créer un Comparateur pour le type de clé et le type de la valeur (MyObject?). Ensuite, utilisez créer(Comparateur de keyComparator, Comparateur valueComparator) pour faire la carte.

    L'avantage d'utiliser un Comparateur sur la mise en œuvre de Comparable, c'est que vous pouvez faire le Comparateur spécifiques à la situation que vous voulez avec la carte et il n'a pas d'effet de votre objet en général. Tant que votre Comparateur est compatible avec égal à égal, il peut faire ce que vous voulez.

    • Je n'aime pas vraiment cela. J'ai dit qu'il n'a pas de sens d'avoir MyObject mettre en œuvre Comparable. Une extension de cette déclaration est que je me suis logiquement n'ont pas un "défaut" Comparator pour MyObject ainsi. Mon but est vraiment d'avoir une Multimap qui a ses clés triés, mais les valeurs de l'une des touches ne devrait pas être triés.
    InformationsquelleAutor justkt
  8. 0

    Meilleure solution qui fonctionne toujours pour moi est d'utiliser Multimap & TreeMultiMap. cela permettra de trier les résultats par ordre croissant sur les touches même si vous disposez de plusieurs doubles de clés. La Solution ci-dessous:

    Multimap<Double, Integer> map= TreeMultimap.create(Ordering.natural().reverse(),         Ordering.natural());

if (!map.isEmpty()) {               
                printMap(map);
            }

public static <K, V> void printMap(Multimap<Double, Integer> map) throws Exception {
        for (Map.Entry<Double, Integer> entry : map.entries()) {
            System.out.println("Key : " + entry.getKey() 
                + " Value : " + entry.getValue());              
        }
    }
    InformationsquelleAutor Rahul k