Java 树映射键、值对存在，但.get（键）将值返回为null

我有下面的代码，当我打印树形图时，我可以清楚地看到键和值对。每个键都有一个值（输出中没有空值）。当我得到第一个键时，它会给我一个键，但是当我试图得到基于键的值时，它会返回null

TreeMap<String, Double> cosinesimilarityvalues = simvalfordoc.returnsortedcosinesimilarityvalues();
System.out.println(cosinesimilarityvalues);
String topkey = cosinesimilarityvalues.firstKey();      
System.out.println(topkey);
Double topvalue = cosinesimilarityvalues.get(topkey);
System.out.println(topvalue);
topones.put(topkey, topvalue);

所以我应该把article04_C9，article08_C12作为firstKey（）（我是这样做的） 但当我去检索与该键关联的值时，它返回null

下面是我用来填充树映射的代码

HashMap<String, Double> cosinesimilarityvalues = new HashMap<String, Double>();
TreeMap<String, Double> sortedcosinesimilarityvalues = new TreeMap<String, Double>();
public void comparecosinesimilarityvalues(List<tfidfvalues> matrix, tfidfvalues currentvector) {
    String articlename = currentvector.returnarticlename();
    String foldername = currentvector.returnfoldername();
    ArrayList<Double> tfidfval = currentvector.returntfidfvaluesforrow();
    articlefolder = articlename+ "_" + foldername;
    CosineSimilarity calculator = new CosineSimilarity();
    for(int i = 0; i < matrix.size(); i++) {
        String compvectorarticlename = matrix.get(i).returnarticlename();
        String compvectorfoldername = matrix.get(i).returnfoldername();
        ArrayList<Double> compvector = matrix.get(i).returntfidfvaluesforrow();

        Double cosinesimilarity = calculator.CosineSimilarityCalc(tfidfval, compvector);

        String comparingwhat = compvectorarticlename + "_" + compvectorfoldername;

        String comparingthese = articlefolder + "," + comparingwhat;
        cosinesimilarityvalues.put(comparingthese, cosinesimilarity);
    }

    Iterator<Map.Entry<String, Double>> iterator = cosinesimilarityvalues.entrySet().iterator();
    while(iterator.hasNext()) {
        Map.Entry<String, Double> entry = iterator.next();
        if((entry.getValue() > 0.989 && entry.getValue() < 1) || entry.getValue() > 1) {
            iterator.remove();
        }
    }

    sortedcosinesimilarityvalues = sortMapByValue(cosinesimilarityvalues);
}

public TreeMap<String, Double> returnsortedcosinesimilarityvalues() {
    return sortedcosinesimilarityvalues;
}

HashMap cosinismilarityvalues=newhashmap（）；
TreeMap sortedcosinesimilarityvalues=新TreeMap（）；
public void comparecosinesimilarityvalues（列表矩阵、tfidfvalues currentvector）{
String articlename=currentvector.returnarticlename（）；
字符串foldername=currentvector.returnfoldername（）；
ArrayList TfidVal=currentvector.ReturnTfidValuesError（）；
articlefolder=articlename+“”+foldername；
余弦相似性计算器=新余弦相似性（）；
对于（int i=0；i0.989&&entry.getValue（）<1）| | entry.getValue（）>1）{
iterator.remove（）；
}
}
SortedSineSimilarityValues=SortManByValues（余弦相似值）；
}
公共树映射返回的相似性值（）{
返回排序的相似性值；
}

这是我用来按值排序的函数…如果有帮助的话

发件人：

类ValueComparator实现Comparator{
HashMap=newHashMap（）；
公共价值比较器（HashMap）{
this.map.putAll（map）；
}
@凌驾
公共整数比较（字符串s1、字符串s2）{
if（map.get（s1）>=map.get（s2））{
返回1；
}否则{
返回-1；
}   
}
}
公共树映射sortMapByValue（HashMap映射）{
比较器比较器=新值比较器（map）；
//TreeMap是按其键排序的贴图。
//比较器用于按键对树映射进行排序。
TreeMap结果=新的TreeMap（比较器）；
结果：putAll（map）；
返回结果；
}

我不确定我做错了什么。请帮忙

谢谢

---

更新

我能够通过

Map.Entry<String, Double> entry1 = cosinesimilarityvalues.firstEntry();
String topkey = entry1.getKey();
Double topvalue = entry1.getValue();

Map.Entry entry1=cosisimilarityvalues.firstEntry（）；
字符串topkey=entry1.getKey（）；
Double-topvalue=entry1.getValue（）；

但我不知道为什么这个方法有效，而另一种方法无效。

---

虽然我的代码现在可以工作了，但我希望我能找出区别所在

很抱歉，现在还无法在问题中发表评论，因此必须在此处发布答案。也许您可以先尝试将整个字符串复制到get输入，看看是否仍然得到null

Double topvalue = cosinesimilarityvalues.get(“article04_C9,article08_C12”);

我发现问题在于自定义比较器的重写比较方法。以下内容复制了您的问题

    import java.util.Comparator;
import java.util.TreeMap;
public class MyTreeMapComparator {
    public static void main(String a[]){
        //the treemap sorts by key
        TreeMap<String, String> hm = new TreeMap<String, String>(new MyComp());
         //add key-value pair to TreeMap
         hm.put("java", "language");
         hm.put("computer", "machine");
         hm.put("india","country");
         hm.put("mango","fruit");
         System.out.println(hm.get("java"));
     }
}
class MyComp implements Comparator<String>{
    @Override
    public int compare(String str1, String str2) {
        if (str1.compareTo(str2) >= 0) {return 1;}
        else {return -1;}
    }
}

import java.util.Comparator；
导入java.util.TreeMap；
公共类MyTreeMapComparator{
公共静态void main（字符串a[]{
//树映射按键排序
TreeMap hm=新的TreeMap（new mycop（））；
//将键值对添加到树映射
hm.put（“java”、“语言”）；
hm.put（“计算机”、“机器”）；
hm.put（“印度”、“国家”）；
hm.put（“芒果”、“水果”）；
System.out.println（hm.get（“java”）；
}
}
类MyComp实现了比较器{
@凌驾
公共整数比较（字符串str1、字符串str2）{
如果（str1.compareTo（str2）>=0{返回1；}
else{return-1；}
}
}

如果你改成这个，它就可以了

    import java.util.Comparator;
import java.util.TreeMap;
public class MyTreeMapComparator {
    public static void main(String a[]){
        //the treemap sorts by key
        TreeMap<String, String> hm = new TreeMap<String, String>(new MyComp());
         //add key-value pair to TreeMap
         hm.put("java", "language");
         hm.put("computer", "machine");
         hm.put("india","country");
         hm.put("mango","fruit");
         System.out.println(hm.get("java"));
     }
}
class MyComp implements Comparator<String>{
    @Override
    public int compare(String str1, String str2) {
        if (str1.compareTo(str2) == 0) {return 0;}
        else if (str1.compareTo(str2) > 0) {return 1;}
        else {return -1;}
    }
}

import java.util.Comparator；
导入java.util.TreeMap；
公共类MyTreeMapComparator{
公共静态void main（字符串a[]{
//树映射按键排序
TreeMap hm=新的TreeMap（new mycop（））；
//将键值对添加到树映射
hm.put（“java”、“语言”）；
hm.put（“计算机”、“机器”）；
hm.put（“印度”、“国家”）；
hm.put（“芒果”、“水果”）；
System.out.println（hm.get（“java”）；
}
}
类MyComp实现了比较器{
@凌驾
公共整数比较（字符串str1、字符串str2）{
if（str1.compareTo（str2）==0{返回0；}
else如果（str1.compareTo（str2）>0{返回1；}
else{return-1；}
}
}

如果映射的内部状态不一致，则通常会启动“行为异常”。对于树映射，就像在您的例子中一样，这可能是由一个不稳定的比较器引起的，这意味着对于相同的输入值，它并不总是返回相同的结果

无法访问整个代码很难找出原因，但是需要注意的一点是，如果在sort方法中初始创建树映射之后对其进行修改，则树映射将变得不一致。这是因为比较器依赖于映射实例化时的状态，比较器看不到以后的任何更改

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

    public ValueComparator(HashMap<String, Double> map){
        this.map.putAll(map);
    }

    @Override
    public int compare(Object s1, Object s2) {
        if(((Double) map.get(s1)).doubleValue() > ((Double) map.get(s2)).doubleValue()){
            return 1;
        }
        else if (((Double) map.get(s1)).doubleValue() == ((Double) map.get(s2)).doubleValue()){
    return ((String)s1).compareTo(((String)s2));
         }
         else{
            return -1;
        }   
    }

firstKey（）

和

firstEntry（）

方法不使用比较器进行检索，它们只是在支持树映射的二叉树中一直向左走。但是，

get（key）

使用比较器在树中查找键，在您的情况下，它不能正常工作

另一个可能的原因是你的公司

    import java.util.Comparator;
import java.util.TreeMap;
public class MyTreeMapComparator {
    public static void main(String a[]){
        //the treemap sorts by key
        TreeMap<String, String> hm = new TreeMap<String, String>(new MyComp());
         //add key-value pair to TreeMap
         hm.put("java", "language");
         hm.put("computer", "machine");
         hm.put("india","country");
         hm.put("mango","fruit");
         System.out.println(hm.get("java"));
     }
}
class MyComp implements Comparator<String>{
    @Override
    public int compare(String str1, String str2) {
        if (str1.compareTo(str2) == 0) {return 0;}
        else if (str1.compareTo(str2) > 0) {return 1;}
        else {return -1;}
    }
}

sgn(compare(x, y)) == -sgn(compare(y, x))

map.get(s1).equals(map.get(s2))

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

    public ValueComparator(HashMap<String, Double> map){
        this.map.putAll(map);
    }

    @Override
    public int compare(Object s1, Object s2) {
        if(((Double) map.get(s1)).doubleValue() > ((Double) map.get(s2)).doubleValue()){
            return 1;
        }
        else if (((Double) map.get(s1)).doubleValue() == ((Double) map.get(s2)).doubleValue()){
    return ((String)s1).compareTo(((String)s2));
         }
         else{
            return -1;
        }   
    }

treemap.put( "two",2.0);
   treemap.put( "one",1.0);
   treemap.put( "three",3.0);
   treemap.put( "six",6.0);
   treemap.put( "five",5.0);

First key is: one
Value against first key: 1.0