La clé pour un maximum de valeur dans la table de hachage

Salut j'ai l'objet suivant:

Hashtable<Object, Double>

et je veux trouver la clé de la au maximum le Double de la valeur dans le tableau. La plus simple façon de le faire?

Grâce

Vous auriez besoin de parcourir toutes les Clés.

OriginalL'auteur chopchop | 2012-04-04

  1. 6

    Il n'y a pas de fonction intégrée pour obtenir la valeur maximale d'un Hashtable vous allez avoir à en boucle sur toutes les clés et de déterminer manuellement le max.

    Object maxKey=null;
Double maxValue = Double.MIN_VALUE; 
for(Map.Entry<Object,Double> entry : table.entrySet()) {
     if(entry.getValue() > maxValue) {
         maxValue = entry.getValue();
         maxKey = entry.getKey();
     }
}

    Edit: Pour trouver plus de touche 1 pour la valeur max

    ArrayList<Object> maxKeys= new ArrayList<Object>();
Double maxValue = Double.MIN_VALUE; 
for(Map.Entry<Object,Double> entry : table.entrySet()) {
     if(entry.getValue() > maxValue) {
         maxKeys.clear(); /* New max remove all current keys */
         maxKeys.add(entry.getKey());
         maxValue = entry.getValue();
     }
     else if(entry.getValue() == maxValue)
     {
       maxKeys.add(entry.getKey());
     }
}
    Puis-je savoir ce qui se passe si leurs sont les deux valeurs les plus élevées? ce que je suis supposé faire pour trouver à la fois des valeurs de clé? merci à l'avance
    cochez la case modifier pour gérer plusieurs touches avec la même valeur max

    OriginalL'auteur twain249

  2. 4

    Si c'est vraiment important de le faire sans itération, toutes les touches, il suffit de prolonger HashTable

    class MyHashtable extends Hashtable<Object, Double> {

    private Double maxValue = Double.MIN_VALUE;

    @Override
    public synchronized Double put(Object k, Double v) {
        maxValue = Math.max(maxValue, v);
        return super.put(k, v);
    }

    @Override
    public synchronized void clear() {
        super.clear();
        maxValue = Double.MIN_VALUE;
    }

    public Double getMaxValue() {
        return maxValue;
    }

    @Override
    public synchronized Double remove(Object key) {
        //TODO: Left as an Excercise for the user, refer the other answers
        return super.remove(key);
    }
}

    OriginalL'auteur st0le

  3. 0

    Vous pouvez parcourir et de trouver la valeur max:

    public static void main(String[] args) {
    Map<Object, Double> maps = new HashMap<Object, Double>();
    maps.put("5", new Double(50.0));
    maps.put("4", new Double(40.0));
    maps.put("2", new Double(20.0));
    maps.put("1", new Double(100.0));
    maps.put("3", new Double(30.0));
    maps.put("5", new Double(50.0));

    Double max = Double.MIN_VALUE;
    for(Object key: maps.keySet()) {
        Double tmp = maps.get(key);
        if(tmp.compareTo(max) > 0) {
            max = tmp;
        }
    }

    System.out.println(max);
}

    OriginalL'auteur Pau Kiat Wee

  4. 0

    Il n'y a pas de méthode de bibliothèque, mais vous pouvez faire comme ci-dessous

    Hashtable<Object, Double> hashTable = new Hashtable<Object, Double>();
          hashTable.put("a", 10.0);
          hashTable.put("b", 15.0);
          hashTable.put("c", 18.0);

          Collection<Double> values = hashTable.values();
          Double maxValue = Collections.max(values);
          Enumeration<Object> keys = hashTable.keys();
          while(keys.hasMoreElements()){
              Object key = keys.nextElement();
              if((hashTable.get(key)).equals(maxValue))
                  System.out.println(key);
          }

    OriginalL'auteur Chandra Sekhar

  5. 0

    il y a une importante Fourre-ya ici: Il pourrait y avoir plus d'une entrée avec la même MAX double valeur. 

    import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;


public class HashtableTest {

    public static void main(String[] args){
        Hashtable<Object, Double> table = new Hashtable<Object, Double>();
    table.put("a", 10.0);
    table.put("b", 15.0);
    table.put("c", 18.0);
    table.put("d", 18.0);


        List<Object> maxKeyList=new ArrayList<Object>();
        Double maxValue = Double.MIN_VALUE; 
        for(Map.Entry<Object,Double> entry : table.entrySet()) {
             if(entry.getValue() > maxValue) {
                 maxValue = entry.getValue();
                 maxKeyList.add(entry.getKey());
             }
        }
        System.out.println("All max Keys : "+maxKeyList);
    }
}

    résultat: Tous les max les Touches : [b, d]

    Puis-je savoir ce qui se passe si leurs sont les deux valeurs les plus élevées?
    ce que je suis supposé faire pour trouver les deux valeurs clés
    Ce trouve toutes les clés de remplacer l'ancienne valeur maximale. Avec votre jeu de test, il devrait avoir retourné 'c' et 'd' non 'b' et 'd'.
    votre algorithme/code donne la mauvaise réponse. @Twain249 dit, il trouve toutes les clés qui remplace l'ancienne valeur max. Il faut plutôt trouver une clé qui a valeur max ou toutes les clés qui ont leur valeur en tant que valeur max.

    OriginalL'auteur Michael