Key für Maximalwert in Hashtable

Question

Hallo habe ich folgendes Objekt:

Hashtable<Object, Double> 

und ich möchte den Schlüssel des maximalen Double-Wert in der Tabelle zu finden. Der einfachste Weg, das zu tun?

Dank

Answer 1

Es gibt keine integrierte Funktion aus dem Maximalwert erhalten ein Hashtable Sie eine Schleife über alle Tasten haben werden und manuell den max bestimmen.

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: Um mehr als 1 Schlüssel für den Maximalwert

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()); 
    } 
} 

Answer 2

Sie können Schleife durch und finden Sie den maximalen Wert zu finden:

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); 
} 

Answer 3

Es gibt keine spezielle Bibliothek Methode für es, aber Sie können wie folgt tun

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); 
      } 

Answer 4

Wenn es wirklich wichtig ist, Sie es tun, ohne alle Schlüssel iterieren, einfach erweitern 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); 
    } 
} 

Answer 5

gibt es einen wichtigen Fang-ya hier: Es könnte sein, mehr als ein Eintrag mit dem gleichen MAX doppelten Wert.

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); 
    } 
} 

Ergebnis: Alle max Tasten: [b, d]