http://www.bukkit.fr/topic/19326-classer-des-joueurs-dune-mapplayer-integer-de-celui-poss%C3%A9dant-le-plus-gros-int-au-plus-petit/

ValueSortedMap.java

package fr.neatmonster.utils;

import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class ValueSortedMap<K extends Comparable<K>, V extends Comparable<V>>
        implements Map<K, V> {
    private final Map<K, V> map;
    private final Map<K, V> lookupMap;

    public ValueSortedMap() {
        map = new TreeMap<K, V>(new Comparator<K>() {

            @Override
            public int compare(final K k1, final K k2) {
                final V v1 = lookupMap.get(k1);
                if (v1 == null)
                    return -1;
                final V v2 = lookupMap.get(k2);
                if (v2 == null)
                    return 1;
                final int cmp = v1.compareTo(v2);
                if (cmp == 0)
                    return k1.compareTo(k2);
                return cmp;
            }
        });
        lookupMap = new HashMap<K, V>();
    }

    @Override
    public void clear() {
        lookupMap.clear();
        map.clear();
    }

    @Override
    public boolean containsKey(final Object key) {
        return lookupMap.containsKey(key);
    }

    @Override
    public boolean containsValue(final Object value) {
        return lookupMap.containsValue(value);
    }

    @Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        return map.entrySet();
    }

    @Override
    public boolean equals(final Object obj) {
        return map.equals(obj);
    }

    @Override
    public V get(final Object key) {
        return lookupMap.get(key);
    }

    @Override
    public int hashCode() {
        return map.hashCode();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public Set<K> keySet() {
        return map.keySet();
    }

    @Override
    public V put(final K key, final V value) {
        lookupMap.put(key, value);
        return map.put(key, value);
    }

    @Override
    public void putAll(final Map<? extends K, ? extends V> m) {
        lookupMap.putAll(m);
        map.putAll(m);
    }

    @Override
    public V remove(final Object key) {
        lookupMap.remove(key);
        return map.remove(key);
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public String toString() {
        return map.toString();
    }

    @Override
    public Collection<V> values() {
        return map.values();
    }
}