Question

我有<String,Double>的地图被视为对双打列表进行分类的阈值

HashMap<String, Double> map = new Hashmap<>();
map.put(A/B,0.7);
map.put(B/C,0.4);
map.put(C/D,0.3);
map.put(D/E,0.1);

散列的双打用作阈值来对给定的列表双精度进行分类，因此我想将此映射转换为类A，B，C，D的列表

Class A : from 0.7
Class B : from 0.4 to 0.7
Class C : from 0.3 to 0.4
Class D : from 0.1 to 0.3
Class E : less than 0.1

您是否知道如何执行该方法StringClassifyByValue(HashMap<String, Double> map, Double value){}返回作为参数给出的值的类对应的String？

示例：

this.StringClassifyByValue(map,0.5)必须返回B.

Answer 1

一些想法：首先，您的数据结构并没有真正帮助解决您想要解决的问题。但这正是数据结构的存在：为您提供有用的抽象，使您能够有效地解决“最重要”的问题。

从那里开始，我建议您首先创建更好适合您的问题陈述的类。你可以从像

这样的东西开始

public class Interval {

   private final double lowerBoundary;
   private final double upperBoundary;

   public Interval(double lowerBoundary, upperBoundary) {
     this.lowerBoundary = ...
   } 

   public boolean contains(double value) {
     return (value >= lowerBoundary) && (value <=upperBoundary);
   }

而不是继续使用Map<String, Double>而不是像List<Pair<Classification, Interval>>那样的地方：

Pair可以是一个只包含两个属于一起的值的类（而不是使用“泛型”对类，您也可以创建自己的自定义类组合 a { {1}} Classification}。
Interval代表一个“类”，例如A，B，C。关键是：小心使用原始String对象用于此类目的。也许一个简单的字符串现在很好，但也许你必须在以后进一步增强你的逻辑 - 然后发现“嗯，现在一个简单的字符串不再做了，但现在我必须更新大量的地方改变那个“。

当然：理想情况下，你会按“间隔”排序上面的列表。然后找到特定双值的Classification非常简单：

Classification

长话短说：我无法告诉你如何将现有地图转换到上面的配对对象列表中 - 因为我不知道大局。最初可能只是不创建该映射，并直接构建这样的对象列表。

并且为了记录：如果该地图作为地图存在，因为有其他，更重要的要求......那么如果你真的想继续使用地图+列表，你必须仔细平衡（意味着“双重保存”）或者如果您将上述所有逻辑放入某个将Map转换为List的服务中，那么查找然后会抛弃您的数据的“其他”表示。

Answer 2

private HashMap<String, HashMap<String, Double>> getMinMaxThreshold(HashMap<String, Double> map) {

        List<Double> threholds = map.values().stream().collect(Collectors.toList());
        HashMap<String,Double >map1= this.sortByValues(map);
        List<String> keys = map1.keySet().stream().collect(Collectors.toList());

        Collections.sort(threholds);
        Collections.reverse(threholds);

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


        for (int i =0;i<=threholds.size();i++){

            if(i==threholds.size()){
                HashMap<String, Double> testmap = new HashMap<>();
                testmap.put("max",threholds.get(i-1));
                testmap.put("min",0.0);
                boudaries.put(keys.get(keys.size()-1).split("/")[1], testmap);
                System.out.println(threholds.get(i-1)+" ->"+0+" : "+keys.get(keys.size()-1).split("/")[1] );
            }

            else if (i==0){
                HashMap<String, Double> testmap = new HashMap<>();
                testmap.put("max",Math.exp(1000));
                testmap.put("min",threholds.get(i));
                boudaries.put(keys.get(0).split("/")[0], testmap);
                System.out.println(Math.exp(100) +" ->"+threholds.get(i)+" : "+keys.get(0).split("/")[0] );}

            else{
                HashMap<String, Double> testmap = new HashMap<>();
                testmap.put("max",threholds.get(i-1));
                testmap.put("min",threholds.get(i));
                boudaries.put(keys.get(i).split("/")[0], testmap);
            System.out.println(threholds.get(i-1)+" ->"+threholds.get(i)+" : "+keys.get(i).split("/")[0]);}
        }

        System.err.println(boudaries);

        return boudaries;
    }

'keys'是'List'并代表A，B，C，D类。
阈值是'List'represent the thresholds。我们有使用这个阈值来制定边界。
我按值对阈值进行排序，以按降序获取字符串，并与双阈值列表相同，以使它们按相同的顺序排列。
我循环foreach元素的阈值..对于关于最后一个boudaries的第一个项目，所以我作为boudaries做了Exp（1000）和前一个元素..对于最后一个元素，它＆＃ 39; s关于最小0和最大阈值的boudaries。
我使用split来获取splited数组的第一个元素，除了最后一个项目，我使用数组的第二个元素来匹配最后一个元素。那是

测试：

如果我们将“地图”作为输入

{ "YELLOW_DARK/RED_LIGHT" : 0.20459770114942527 , "GREEN_DARK/GREEN_LIGHT" : 0.6226151930261519 , "GREEN_LIGHT/YELLOW_LIGHT" : 0.4632936507936508 , "YELLOW_LIGHT/YELLOW_DARK" : 0.3525246305418719 , "RED_LIGHT/RED_DARK" : 0.027777777777777776}

我的代码会将其转换为：

2.6881171418161356E43 ->0.6226151930261519 : GREEN_DARK
0.6226151930261519 ->0.4632936507936508 : GREEN_LIGHT
0.4632936507936508 ->0.3525246305418719 : YELLOW_LIGHT
0.3525246305418719 ->0.20459770114942527 : YELLOW_DARK
0.20459770114942527 ->0.027777777777777776 : RED_LIGHT
0.027777777777777776 ->0 : RED_DARK

并以HashMap<String, HashMap<String, Double>>

{GREEN_LIGHT={min=0.4632936507936508, max=0.6226151930261519}, YELLOW_DARK={min=0.20459770114942527, max=0.3525246305418719}, YELLOW_LIGHT={min=0.3525246305418719, max=0.4632936507936508}, RED_DARK={min=0.0, max=0.027777777777777776}, RED_LIGHT={min=0.027777777777777776, max=0.20459770114942527}, GREEN_DARK={min=0.6226151930261519, max=Infinity}}
{ "GREEN/LIGHT_YELLOW" : 0.5366379310344828 , "YELLOW_DARK/RED_LIGHT" : 0.18349195937745413 , "YELLOW_LIGHT/YELLOW_DARK" : 0.3571428571428571 , "RED_LIGHT/RED_DARK" : 0.08940809968847352}

通过阈值列表对值列表进行分类

2 个答案: