java从hashmap中减去两个值后返回最小差值的键？

Question

从hashmap中减去两个值后，如何返回差异最小的键

范例

first loop -> 10 - 8 = 2;
second loop -> 10 - 9 = 1;
third loop -> 10 - 7 = 3;

therefore second loop -> 10 - 9 = 1 is the smallest, so the key is "Three".

代码

import java.util.HashMap;

public class Difference {
    HashMap<String,Double> hashMap = new HashMap<>();
    double firstValue = 0;
    double secondValue = 0;
    double difference = 0;
    public Difference() {   
        hashMap.put("One", 10.0);
        hashMap.put("Two", 8.0);
        hashMap.put("Three", 9.0);
        hashMap.put("Four", 7.0);

        firstValue = hashMap.get("One");
        for (String key : hashMap.keySet()) {
            if(!key.equals("One")) {
                secondValue = hashMap.get(key);
                difference = Math.abs(secondValue - firstValue);
            }
        }
    }

    public static void main(String[] args) {
        new Difference();
    }
}

请帮忙。谢谢

Answer 1

您可以使用以下方法实现这一点：

public class MainTest {

  public static void main(String[] args) {

    HashMap<String,Double> hashMap = new HashMap<>();

    hashMap.put("One", 10.0);
    hashMap.put("Two", 8.0);
    hashMap.put("Three", 9.0);
    hashMap.put("Four", 7.0);
    hashMap.put("Five", 10.1);

    System.out.println(getSmallestDiffKeyJava8(hashMap, "One"));

  }

  /* This works only with java 8 */
  private static String getSmallestDiffKeyJava8(Map<String, Double> map, String constantKey) {
    double constant = map.get(constantKey);

    return map.entrySet().stream()
        .filter(entry -> !constantKey.equals(entry.getKey())) // Remove the constant from the values we process
        .map(entry -> new SimpleEntry<>(entry.getKey(), Math.abs(entry.getValue() - constant))) // Map to a new entry with the key and the diff
        .min((o1, o2) -> (int)(o1.getValue() - o2.getValue())) // Find the min
        .map(Entry::getKey)
        .get();


  }

  /* This works with older versions as well */
  private static String getSmallestDiffKey(Map<String, Double> map, String constantKey) {
    double constant = map.get(constantKey);
    String key = null;
    Double diff = null;

    for (Entry<String, Double> entry : map.entrySet()) {
      if (!constantKey.equals(entry.getKey())) {
        double d = Math.abs(entry.getValue() - constant);
        if (diff == null || diff > d) {
          diff = d;
          key = entry.getKey();
        }
      }
    }

  return key;
  }

}

Answer 2

尝试使用类似这样的代码：

String smallestKey;

if(difference !=0 && difference < Math.abs(secondValue - firstValue);){
   difference = Math.abs(secondValue - firstValue);
   smallestKey = key;
}

Answer 3

我认为你的问题比你想象的要简单。我知道这不是最好的，但这里有一个解决方案：

import java.util.HashMap;

public class Difference {
    HashMap<String,Double> hashMap = new HashMap<>();
    double firstValue = 0;
    double secondValue = 0;
    double difference = 0;
    HashMap<Double, String> theMap = new HashMap<Double, String>();

    public Difference() {   
        hashMap.put("One", 10.0);
        hashMap.put("Two", 8.0);
        hashMap.put("Three", 9.0);
        hashMap.put("Four", 7.0);

        firstValue = hashMap.get("One");
        for (String key : hashMap.keySet()) {
            if(!key.equals("One")) {
                secondValue = hashMap.get(key);
                difference = Math.abs(secondValue - firstValue);
                theMap.put(difference, key);
            }
        }

        Set<Double> dbl = theMap.keySet();
        Double smallestDifference = findSmallest(dbl);
        String smallestValue = hashMap.get(smallestDifference);
    }

    public Double findSmallest(Set<Double> setDbl){
        Double smallest = 99999999.0;
        for(Double d : setDbl){
            if(d < smallest)
                smallest = d;
        }
        return smallest;
    }

    public static void main(String[] args) {
        new Difference();
    }
}