web-dev-qa-db-fra.com

Trouver le plus grand nombre dans HashSet/HashMap java

Je voudrais trouver le plus grand nombre dans HashSet et HashMap. Disons que j'ai le numéro [22,6763,32,42,33] dans mon HashSet et que je veux trouver le plus grand nombre dans mon HashSet actuel .. comment pourrais-je le faire? Et même chose pour le HashMap aussi. J'espère que vous pourrez m'aider avec ça. Je vous remercie. 

javahashmaphashset
19
user2064467

Vous pouvez utiliser Collections.max(Collection) pour rechercher l'élément maximal dans n'importe quelle collection . De même, pour une HashMap , vous pouvez utiliser la même méthode sur sa keySet() ou values() , selon que vous voulez clé maximale ou valeur maximale. 

En outre, si vous le souhaitez, vous pouvez utiliser à la place les variables TreeSet et TreeMap , qui stockent les éléments dans un ordre de clé trié.

60
Rohit Jain

essayer

    int max = Collections.max(set);
    int maxKey = Collections.max(map.keySet());
    int maxValue Collections.max(map.values());
7
Evgeniy Dorofeev

Si vous êtes obligé d'utiliser une variable HashSet/HashMap, vous devez alors analyser la variable HashSet/HashMap entière afin de trouver le maximum. Les fonctions de bibliothèque telles que Collections.max() feront comme ceci.

Si vous souhaitez que O(1) récupère le maximum et que vous soyez autorisé à modifier le type de collection en cours d'utilisation, utilisez un ensemble/une carte triés (par exemple, TreeSet/TreeMap).

6
gd1

Quelque chose comme ça:

Set<Integer> values = new HashSet<Integer>() {{
    add(22);
    add(6763);
    add(32);
    add(42);
    add(33);
}};
int maxValue = Integer.MIN_VALUE;
for (int value : values) {
    if (value > maxValue) {
        maxValue = value;
    }
}

Et ça: 

Map<String, Integer> values = new HashMap<String, Integer>() {{
    put("0", 22);
    put("1", 6763);
    put("2", 32);
    put("3", 42);
    put("4", 33);
}};
int maxValue = Integer.MIN_VALUE;
for (int value : values.values()) {
    if (value > maxValue) {
        maxValue = value;
    }
}
2
duffymo

Dans le cas de TreeMap, si vous savez que la clé/les valeurs sont insérées de manière aléatoire, l’arbre sera plus ou moins équilibré. Les arbres sont déséquilibrés. Si les données sont insérées dans un ordre déjà trié, la capacité de trouver rapidement (ou d'insérer ou de supprimer) un élément donné est perdue. En cas d’arbre déséquilibré, cela prendra du temps proportionnel à n, O(n) sinon O (1).

0
Satish

Voici une méthode simple qui fait ce que vous demandez:

  public String getMapKeyWithHighestValue(HashMap<String, Integer> map) {
    String keyWithHighestVal = "";

    // getting the maximum value in the Hashmap
    int maxValueInMap = (Collections.max(map.values()));

    //iterate through the map to get the key that corresponds to the maximum value in the Hashmap
    for (Map.Entry<String, Integer> entry : map.entrySet()) {  // Iterate through hashmap
        if (entry.getValue() == maxValueInMap) {

            keyWithHighestVal = entry.getKey();     // this is the key which has the max value
        }

    }
    return keyWithHighestVal;
}
0
ctu

Pensez à utiliser Apache Commons Math . Voici la documentation API .
La classe d'intérêt est SummaryStatistics . Cela fonctionne avec doubles et calcule max, min, moyenne, etc. à la volée (au fur et à mesure que vous lui ajoutez des valeurs). Les valeurs de données n'étant pas stockées en mémoire, cette classe peut être utilisée pour calculer des statistiques pour des flux de données très volumineux.

0
naXa

Note : Si vous voulez trouver la plus grande valeur de Map, essayez maxEntry.get (). GetValue () au lieu de maxEntry.get (). GetKey ()

1. Utilisation de Stream 

public <K, V extends Comparable<V>> V maxUsingStreamAndLambda(Map<K, V> map) {
    Optional<Entry<K, V>> maxEntry = map.entrySet()
        .stream()
        .max((Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
            .compareTo(e2.getValue())
        );

    return maxEntry.get().getKey();
}

2. Utilisation de Collections.max () avec une expression Lambda 

public <K, V extends Comparable<V>> V maxUsingCollectionsMaxAndLambda(Map<K, V> map) {
    Entry<K, V> maxEntry = Collections.max(map.entrySet(), (Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
        .compareTo(e2.getValue()));
    return maxEntry.getKey();
}

3. Utilisation de Stream avec Method Reference 

public <K, V extends Comparable<V>> V maxUsingStreamAndMethodReference(Map<K, V> map) {
    Optional<Entry<K, V>> maxEntry = map.entrySet()
        .stream()
        .max(Comparator.comparing(Map.Entry::getValue));
    return maxEntry.get()
        .getKey();
}

4. Utilisation de Collections.max () 

public <K, V extends Comparable<V>> V maxUsingCollectionsMax(Map<K, V> map) {
    Entry<K, V> maxEntry = Collections.max(map.entrySet(), new Comparator<Entry<K, V>>() {
        public int compare(Entry<K, V> e1, Entry<K, V> e2) {
            return e1.getValue()
                .compareTo(e2.getValue());
        }
    });
    return maxEntry.getKey();
}

5. Utilisation d'une simple itération 

public <K, V extends Comparable<V>> V maxUsingIteration(Map<K, V> map) {
    Map.Entry<K, V> maxEntry = null;
    for (Map.Entry<K, V> entry : map.entrySet()) {
        if (maxEntry == null || entry.getValue()
            .compareTo(maxEntry.getValue()) > 0) {
            maxEntry = entry;
        }
    }
    return maxEntry.getKey();
}
0
Manas Ranjan Mahapatra