TreeMap按照值排序，值可以是一个复杂json数据

主体思路：

1.TreeMap是有序集合，默认按照key的compareTo来排序。
2.重写comparator，按照值比较。
3.利用guava中Ordering.onResultOf方法

代码实现

import com.google.common.base.Functions;
import com.google.common.collect.Ordering;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;

public class ValueComparableMap<K extends Comparable<K>, V> extends TreeMap<K, V> {
    private final Map<K, V> valueMap;

    public ValueComparableMap(Comparator<V> comparator) {
        this(Ordering.from(comparator), new ConcurrentHashMap<K, V>());
    }

    private ValueComparableMap(Ordering<? super V> partialValueOrdering,
        Map<K, V> valueMap) {
        super(partialValueOrdering
            .onResultOf(Functions.forMap(valueMap)));

        this.valueMap = valueMap;
    }

    /**
     * 同步放入
     * @param k
     * @param v
     * @return
     */
    @Override
    public synchronized V put(K k, V v) {
        if (valueMap.containsKey(k)) {
            /*remove the key in the sorted set before adding the key again*/
            remove(k);
        }
        /*To get "real" unsorted values for the comparator*/
        valueMap.put(k, v);
        /*Put it in value order*/
        return super.put(k, v);
    }

    /**
     * 删除 同步删除副本map数据
     * @param k
     * @return V
     */
    @Override
    public synchronized V remove(Object k) {
        if (!valueMap.containsKey(k)) {
            return null;
        }
        super.remove(k);
        return valueMap.remove(k);
    }
}

测试案例代码：
public class ValueCompareTest {
    // 测试例
    public static void main(String []args) {
        TreeMap<String, String> valueComparableMap = new ValueComparableMap<>((o1, o2) -> {
            JSONObject object1 = JSONObject.fromObject(o1);
            JSONObject object2 = JSONObject.fromObject(o2);
            return object1.getInt("s") - object2.getInt("s");
        });

        TreeMap<String, String> treeMap = new TreeMap<>();
        List<String> keys = Arrays.asList("21", "1", "12", "4");
        String v1 = "{\"s\":9}";
        String v2 = "{\"s\":5}";
        String v3 = "{\"s\":2}";
        String v4 = "{\"s\":12}";
        List<String> values = Arrays.asList(v1,v2,v3,v4);
        for (int i = 0; i < keys.size(); i++) {
            valueComparableMap.put(keys.get(i), values.get(i));
            treeMap.put(keys.get(i), values.get(i));
        }
        // 输出值比较map数据
        valueComparableMap.entrySet().forEach(entry -> {
            System.out.println("value compare key:" + entry.getKey() + " value:" + entry.getValue());
        });
        // 输出treeMap数据
        treeMap.entrySet().forEach(entry -> {
            System.out.println("key map compare key:" + entry.getKey() + " value:" + entry.getValue());
        });
        /**为何字符串4在最后，看了下compareTo方法，俩string，长度如果不相等会截断长那个，然后比较俩字符串值*/
        System.out.println(keys.get(3).compareTo(keys.get(0)));
    }
}

输出结果：
value compare key:12 value:{"s":2}
value compare key:1 value:{"s":5}
value compare key:21 value:{"s":9}
value compare key:4 value:{"s":12}
key map compare key:1 value:{"s":5}
key map compare key:12 value:{"s":2}
key map compare key:21 value:{"s":9}
key map compare key:4 value:{"s":12}
2

guava相关jar
json相关jar