Como classificar um LinkedHashMap pelo campo de sua classe de valor?

Question

Eu uso as seguintes linhas para classificar uma LinkedHashMap, mas nem todos os itens são ordenados, algo errado?

LinkedHashMap<String,PatternData> statisticsMap;
// fill in the map ...

LinkedHashMap<String,PatternData> sortedStatisticsMap=new LinkedHashMap<String,PatternData>();       // Sort it by patternData's average

ArrayList<PatternData> statisticsMapValues=new ArrayList<PatternData>(statisticsMap.values());
Collections.sort(statisticsMapValues,Collections.reverseOrder());                // Sorting it (in reverse order)

patternData last_i=null;
for (PatternData i : statisticsMapValues)                                       // Now, for each value
{
  if (last_i==i) continue;                                                         // Without dublicates
  last_i=i;

  for (String s : statisticsMap.keySet())                                         // Get all hash keys
    if (statisticsMap.get(s)==i)                                                  // Which have this value
    {
      sortedStatisticsMap.put(s,i);
    }
}


class PatternData implements Comparable<PatternData>
{
  float sum=0,average;
  int totalCount=0;
  Vector<String> records=new Vector<String>();

  public PatternData() { }

  public void add(float data)
  {
    sum+=data;
    totalCount++;
    average=sum/totalCount;
  }

  public void add(float data,String record)
  {
    add(data);
    records.add(record);
  }

  float getAverage() { return average; }

  public int compareTo(patternData o) { return (int)(average-o.average); }
}

Answer 1

Quando você retornar int, o intervalo quando médio-o.average é entre -1 e 1 sempre retornará 0.

Uma solução é simplesmente mudar a sua função compareTo para:

return Float.compare(average, o.average);

Answer 2

Você está classificando números de ponto usando inteiros flutuante. Inteiros não fique arredondada; eles são truncados. Além disso, dada a forma como você está realmente fazendo a triagem, considere usar um TreeHashMap vez.

(e apenas para nitpick, Java usa convenções minúsculas para nomes de métodos e variáveis)