Java : Pourquoi est-ce que j'obtiens null dans la sortie ?

Question

public class A{

   TreeMap<String, Double> sortedPairList;
   HashMap<String, Double> PairList = new HashMap<String, Double>();

   public static void main(String[] args) {

   A p = new A();

    p.PairList.put("a00", 0.3920948902348);
    p.PairList.put("a01", 0.4920948902348);
    p.PairList.put("a02", 0.3420948902348);
    p.PairList.put("a03", 0.5920948902348);
    p.PairList.put("a04", 0.6720948902348);
    p.PairList.put("a05", 0.3940948902348);
    p.PairList.put("a06", 0.3920948902348);
    p.PairList.put("a07", 0.9920948902348);
    p.PairList.put("a08", 0.6920948902348);
    p.PairList.put("a09", 0.7920948902348);
    p.PairList.put("a10", 0.8820948902348);
    p.PairList.put("a11", 0.1220948902348);
    p.PairList.put("a12", 0.1920948902348);
    p.PairList.put("a13", 0.4520948902348);
    p.PairList.put("a14", 0.3434948902348);
    p.PairList.put("a15", 0.5690948902348);
    p.PairList.put("a16", 0.5920948902348);
    p.PairList.put("a17", 0.8920948902348);
    p.PairList.put("a18", 0.920948902348);
    p.PairList.put("a19", 0.9820948902348);
    p.PairList.put("a20", 0.1920948902348);
    p.PairList.put("a21", 0.5920948902348);
    p.PairList.put("a22", 0.3920948902348);
    p.PairList.put("a23", 0.3920948902348);

    p.sortPairList(p.PairList) ;

    for(String s : p.sortedPairList.keySet() ){
         System.out.println("key:: value: " + s + "  ::"+p.sortedPairList.get(s));
    }

}//end of main

public void sortPairList(HashMap<String, Double> pairlist) {
    ValueComparator comp = new ValueComparator(pairlist);

    sortedPairList = new TreeMap<String, Double>(comp);

    sortedPairList.putAll(pairlist);

}// end of sortedPredicatePairList

class ValueComparator implements Comparator<Object> {

    Map<String, Double> temp;

    public ValueComparator(Map<String, Double> base) {
        this.temp = base;
    }

    public int compare(Object p1, Object p2) {

        if ((Double) temp.get(p1) < (Double) temp.get(p2)) {
            return 1;
        } else if ((Double) temp.get(p1) == (Double) temp.get(p2)) {
            return 0;
        } else {
            return -1;
        }

    }
}// end of class ValueComparator
}//end of classA

*Le résultat que j'obtiens est le suivant, pourquoi j'obtiens des valeurs nulles qui sont répétées ? *

clé : : valeur : a07 ::0.9920948902348

clé : : valeur : a19 ::0.9820948902348

clé : : valeur : a18 ::0.920948902348

clé : : valeur : a17 ::0.8920948902348

clé : : valeur : a10 ::0.8820948902348

clé : : valeur : a09 ::0.7920948902348

clé : : valeur : a08 ::0.6920948902348

clé : : valeur : a04 ::0.6720948902348

clé : : valeur : a03 ::0.5920948902348

clé : : valeur : a21 ::null

clé : : valeur : a16 ::null

clé : : valeur : a15 ::0.5690948902348

clé : : valeur : a01 ::0.4920948902348

clé : : valeur : a13 ::0.4520948902348

clé : : valeur : a05 ::0.3940948902348

clé : : valeur : a06 ::0.3920948902348

clé : : valeur : a23 ::0.3920948902348

clé : : valeur : a22 ::0.3920948902348

clé : : valeur : a00 ::null

clé : : valeur : a14 ::0.3434948902348

clé : : valeur : a02 ::0.3420948902348

clé : : valeur : a12 ::0.1920948902348

clé : : valeur : a20 ::null

clé : : valeur : a11 ::0.1220948902348

Answer 1

De API de la carte des arbres :

Notez que l'ordre maintenu par une carte triée (qu'un comparateur explicite soit fourni ou non) doit être cohérent avec les égaux si cette carte triée doit implémenter correctement l'interface Map. (Voir Comparable ou Comparateur pour une définition précise de consistent with equals). En effet, l'interface Map est définie en termes d'opération equals, mais une map effectue toutes les comparaisons de clés à l'aide de sa méthode compareTo (ou compare), de sorte que deux clés jugées égales par cette méthode sont, du point de vue de la map triée, égales.

Votre ValueComparator n'est définitivement pas compatible avec les égaux.

En quelque sorte p.sortedPairList.keySet() contient des clés qui sont "égales" selon votre "ValueComparator", mais vous avez obtenu null pour les clés dupliquées.

Answer 2

Déclarer PairList comme ça :

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

Et changez votre ValueComparator#compare méthode à :

public int compare(Object p1, Object p2) {
   return temp.get(p1).compareTo(temp.get(p2));
}

Mise à jour Conformément à vos commentaires, utilisez ce qui suit compare pour obtenir les 24 éléments dans l'ordre croissant :

public int compare(String p1, String p2) {
    if (temp.get(p1).doubleValue() < temp.get(p2).doubleValue())
        return 1;
    else if (temp.get(p1).doubleValue() == temp.get(p2).doubleValue())
        return p1.compareTo(p2);
    else
        return -1;
}

Answer 3

Le problème est dans votre comparateur.

En java, vous ne pouvez pas comparer des objets en utilisant == opérateur. Cet opérateur fait ce que vous attendez. Ainsi, pour comparer les valeurs des doubles que vous détenez dans votre carte, vous devez appeler doubleValue() . Voici ma version de votre comparateur qui fonctionne correctement.

    public int compare(Object p1, Object p2) {

        if (temp.get(p1).doubleValue() < temp.get(p2).doubleValue()) {
            return 1;
        } else if (temp.get(p1).doubleValue() == temp.get(p2).doubleValue()) {
            return 0;
        } else {
            return -1;
        }           
    }

Answer 4

C'est parce que vous comparez dans votre Comparateur avec le == signe. Remplacez-le par le equals() et cela devrait fonctionner :

 public int compare(Object p1, Object p2) {

            if ((Double) temp.get(p1) < (Double) temp.get(p2)) {
                return 1;
            } else if (((Double) temp.get(p1)).equals((Double) temp.get(p2))) {
                return 0;
            } else {
                return -1;
            }

        }