Obtenir minvalue d'une Carte(Clé,Double)

Est-il une méthode (peut-être avec Google Collections) pour obtenir la valeur min de un Map(Key, Double)?

De façon traditionnelle, il faudrait que je sorte la carte, en fonction des valeurs, et de prendre la première/dernière.

InformationsquelleAutor user326667 | 2010-05-05

guava java

47

Vous pouvez utiliser la norme Collections#min() pour cela.
```
Map<String, Double> map = new HashMap<String, Double>();
map.put("1.1", 1.1);
map.put("0.1", 0.1);
map.put("2.1", 2.1);

Double min = Collections.min(map.values());
System.out.println(min); //0.1
```
Mise à jour: depuis que vous avez besoin de la clé ainsi, eh bien, je ne vois pas les moyens de Collections ou Google Collections2 API depuis un Map n'est pas un Collection. Le Cartes#filterEntries() est pas vraiment utile, puisque vous ne connaissez que le résultat réel à fin de l'itération.

Plus simple solution serait alors de ceci:
```
Entry<String, Double> min = null;
for (Entry<String, Double> entry : map.entrySet()) {
    if (min == null || min.getValue() > entry.getValue()) {
        min = entry;
    }
}

System.out.println(min.getKey()); //0.1
```
(nullcheck sur min laissé de côté)
- Merci pour la réponse - j'ai oublié de mentionner que j'ai besoin de la clé de la valeur min
- Merci beaucoup, par le façon, j'aurais aussi besoin d'obtenir des rangs d'une triés carte. Je voudrais utiliser l'indice de classement (1,2,3...) Ce qui pourrait être la meilleure façon de le faire avec des cartes comme ici ce n'est pas possible d'obtenir l'indice. Il est plutôt inconvinient pour créer une liste à partir de la carte à chaque fois
- Si vous voulez un indice, vous aurez vraiment besoin d'utiliser un List<SomeObject> au lieu de cela, en combinaison avec un Comparator<SomeObject> ou peut-être Comparable<SomeObject>. Le SomeObject tour, puis maintenez la carte originale, une clé et une valeur. Un Set<SomeObject> peut également être adapté, vous n'aurez qu'à compter de l'index vous-même.
InformationsquelleAutor BalusC

Vous pouvez toujours utiliser Collections.min avec une coutume Comparator pour obtenir le Map.Entry avec la valeur la plus faible:

Map<String, Double> map = new HashMap<String, Double>();
map.put("1.1", 1.1);
map.put("0.1", 0.1);
map.put("2.1", 2.1);
Entry<String, Double> min = Collections.min(map.entrySet(), new Comparator<Entry<String, Double>>() {
    public int compare(Entry<String, Double> entry1, Entry<String, Double> entry2) {
        return entry1.getValue().compareTo(entry2.getValue());
    }
});
System.out.printf("%s: %f", min.getKey(), min.getValue()); //0.1: 0.100000

Avec Java 8:

Entry<String, Double> min = Collections.min(map.entrySet(),
                                       Comparator.comparing(Entry::getValue));

InformationsquelleAutor superfav

5

De façon traditionnelle, il faudrait que je
trier les carte, en fonction des valeurs,
et prendre la première/dernière. grâce

Non, vous ne le soit pas. Vous devez parcourir toutes les valeurs et à chaque étape, de comparer l'état actuel de l'élément avec le plus petit vu jusqu'à présent. C'est O(n), par rapport à O(n*log(n)) pour le tri, ce qui pourrait être énorme différence.

BTW, c'est exactement comment Collections.min() œuvres.
- Si je sort la carte, en fonction des valeurs, je reçois un nouveau triées de la Carte, par exemple: (A,1),(B,2),(C,3) Ici, je peux prendre juste la clé du premier élément.
- il prend beaucoup plus de temps et utilise plus de mémoire que nécessaire.
InformationsquelleAutor Michael Borgwardt

À l'aide de Java 8 flux:

return map
            .entrySet()
            .stream()
            .sorted(Comparator.comparingDouble(Map.Entry::getValue))
            .findFirst()
            .map(Map.Entry::getValue);

return map
            .entrySet()
            .stream()
            .min(Comparator.comparingDouble(Map.Entry::getValue))
            .map(Map.Entry::getValue);

Mais si vous voulez le faire à plusieurs reprises, sans aucun doute donner à tas un coup d'oeil.

InformationsquelleAutor voho

2

Je serais enclin à utiliser un Google Collections BiMap:
```
     String minKey = HashBiMap.create(map).inverse().get(Collections.min(map.values()));
```
Ou quelque chose comme ça (pas testé).
- Nice oneliner, mais pas vraiment efficace.
- Mais il se peut que les valeurs sont de la même valeur (double) quelle touche dois-je obtenir dans ce cas?
- il a à voir avec ce qui est la clé et quelle est la valeur de la carte, et non leurs types. En fin de compte, au moment de l'exécution, ils sont tous les Objets de toute façon.
- Certainement pas, mais qui ne peut pas d'importance. Si la carte est grande et souvent utilisé de façon bidirectionnelle, il peut être stocké dans un BiMap en premier lieu. inverse() est une opération pas cher dans ce cas.
InformationsquelleAutor Yishai

Java8 One-Liner

Key key = Collections.min(map.entrySet(), Map.Entry.comparingByValue()).getKey()

InformationsquelleAutor Ankit Sharma

1

Afin de le faire de manière efficace, vous pouvez définir votre propre structure de données, telle qu'elle implémente l'interface de la Carte,mais permet aussi efficace getMin() de l'opération.

Cela peut être fait à l'aide de deux structures de données internes: une carte et un arbre (ou d'un segment de données de la structure). Chaque fois qu'une nouvelle paire (K,V) est ajouté, les ajouter à la carte, et aussi à l'arbre (comme une seule entrée). Cela permet à O(1) fois pour get(Clé) de l'exploitation, et de O(log n) pour l'ajout, la suppression, et getMin opérations.

InformationsquelleAutor Eyal Schneider

À l'aide de java 8 (statique et importations). Nous pouvons faire @superfav solution beaucoup plus propre:

Map<String, Double> myMap;
String theKeyWithHighestValue = Collections.min(myMap.entrySet(), comparingDouble(Entry::getValue)).getKey()

InformationsquelleAutor Tarrasch

1

Dans Java 8, nous pouvons obtenir facilement:
```
Double minValue = map.entrySet().stream().min(Map.Entry.comparingByValue()).get().getValue();
Double maxValue = map.entrySet().stream().max(Map.Entry.comparingByValue()).get().getValue();
```
- sympa, mais peut conduire à des erreurs à l'aide de .get(). Ceux-ci créent une Option.get()' sans 'isPresent()' avertissement. Découvrez cette page pour certaines solutions de rechange plus sécuritaires
InformationsquelleAutor Az.MaYo

Vous devez vous connecter pour publier un commentaire.