我对Java比较陌生，经常发现需要对值进行Map<Key，Value>排序。
由于这些值不是唯一的，我发现自己将keySet转换为一个数组，并使用自定义比较器通过数组排序对该数组进行排序，该比较器根据与该键关联的值进行排序。
有没有更简单的方法？
当前回答
三个单行答案。。。
我会使用GoogleCollectionsGuava来实现这一点-如果你的价值观是可比较的，那么你可以使用
valueComparator = Ordering.natural().onResultOf(Functions.forMap(map))
这将为地图创建一个函数（对象）[将任何键作为输入，返回相应的值]，然后对它们应用自然（可比较）排序[值]。
如果它们不具有可比性，那么您需要按照
valueComparator = Ordering.from(comparator).onResultOf(Functions.forMap(map))
这些可以应用于TreeMap（因为Ordering扩展了Comparator），或者在排序后应用于LinkedHashMap
注意：如果要使用TreeMap，请记住，如果比较==0，则该项已在列表中（如果有多个值进行比较，则会发生这种情况）。为了缓解这种情况，您可以像这样将键添加到比较器中（假设键和值是可比较的）：
valueComparator = Ordering.natural().onResultOf(Functions.forMap(map)).compound(Ordering.natural())
=对键映射的值应用自然排序，并将其与键的自然排序组合
请注意，如果您的键与0比较，这仍然不起作用，但这对于大多数可比较的项来说应该足够了（因为hashCode、equals和compareTo通常是同步的…）
请参见Ordering.onResultOf（）和Functions.forMap（）。
实施
现在我们有了一个比较器，它可以满足我们的需要，我们需要从中得到一个结果。
map = ImmutableSortedMap.copyOf(myOriginalMap, valueComparator);
现在，这很可能奏效，但：
需要完成一张完整的地图不要在TreeMap上尝试上面的比较器；当插入的键在put之后才有值时，尝试比较它是没有意义的，也就是说，它会很快断开
第1点对我来说有点破坏交易；google集合非常懒惰（这很好：你几乎可以在一瞬间完成所有操作；真正的工作是在你开始使用结果时完成的），这需要复制整个地图！
“完整”答案/按值排序的实时地图
不过别担心；如果你痴迷于以这种方式对“实时”地图进行排序，那么你可以用以下疯狂的方式解决上述问题，而不是其中一个，而是两个（！）：
注意：这在2012年6月发生了重大变化-以前的代码永远无法工作：需要内部HashMap来查找值，而不需要在TreeMap.get（）->compare（）和compare（（）->get（）之间创建无限循环
import static org.junit.Assert.assertEquals;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import com.google.common.base.Functions;
import com.google.common.collect.Ordering;
class ValueComparableMap<K extends Comparable<K>,V> extends TreeMap<K,V> {
//A map for doing lookups on the keys for comparison so we don't get infinite loops
private final Map<K, V> valueMap;
ValueComparableMap(final Ordering<? super V> partialValueOrdering) {
this(partialValueOrdering, new HashMap<K,V>());
}
private ValueComparableMap(Ordering<? super V> partialValueOrdering,
HashMap<K, V> valueMap) {
super(partialValueOrdering //Apply the value ordering
.onResultOf(Functions.forMap(valueMap)) //On the result of getting the value for the key from the map
.compound(Ordering.natural())); //as well as ensuring that the keys don't get clobbered
this.valueMap = valueMap;
}
public V put(K k, V v) {
if (valueMap.containsKey(k)){
//remove the key in the sorted set before adding the key again
remove(k);
}
valueMap.put(k,v); //To get "real" unsorted values for the comparator
return super.put(k, v); //Put it in value order
}
public static void main(String[] args){
TreeMap<String, Integer> map = new ValueComparableMap<String, Integer>(Ordering.natural());
map.put("a", 5);
map.put("b", 1);
map.put("c", 3);
assertEquals("b",map.firstKey());
assertEquals("a",map.lastKey());
map.put("d",0);
assertEquals("d",map.firstKey());
//ensure it's still a map (by overwriting a key, but with a new value)
map.put("d", 2);
assertEquals("b", map.firstKey());
//Ensure multiple values do not clobber keys
map.put("e", 2);
assertEquals(5, map.size());
assertEquals(2, (int) map.get("e"));
assertEquals(2, (int) map.get("d"));
}
}
当我们放入时，我们确保哈希映射具有比较器的值，然后将其放入TreeSet进行排序。但在此之前，我们检查哈希图，看看该键实际上不是重复的。此外，我们创建的比较器还将包括关键字，这样重复的值就不会删除非重复的关键字（由于==比较）。这两项对于确保地图合同得到遵守至关重要；如果你认为你不想这样，那么你几乎就要完全颠倒地图了（地图＜V，K＞）。
构造函数需要调用为
new ValueComparableMap(Ordering.natural());
//or
new ValueComparableMap(Ordering.from(comparator));
其他回答
这种方法正好能达到目的。（“挫折”是Values必须实现java.util.Comparable接口）
/**
* Sort a map according to values.
* @param <K> the key of the map.
* @param <V> the value to sort according to.
* @param mapToSort the map to sort.
* @return a map sorted on the values.
*/
public static <K, V extends Comparable< ? super V>> Map<K, V>
sortMapByValues(final Map <K, V> mapToSort)
{
List<Map.Entry<K, V>> entries =
new ArrayList<Map.Entry<K, V>>(mapToSort.size());
entries.addAll(mapToSort.entrySet());
Collections.sort(entries,
new Comparator<Map.Entry<K, V>>()
{
@Override
public int compare(
final Map.Entry<K, V> entry1,
final Map.Entry<K, V> entry2)
{
return entry1.getValue().compareTo(entry2.getValue());
}
});
Map<K, V> sortedMap = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : entries)
{
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
http://javawithswaranga.blogspot.com/2011/06/generic-method-to-sort-hashmap.html
三个单行答案。。。
我会使用GoogleCollectionsGuava来实现这一点-如果你的价值观是可比较的，那么你可以使用
valueComparator = Ordering.natural().onResultOf(Functions.forMap(map))
这将为地图创建一个函数（对象）[将任何键作为输入，返回相应的值]，然后对它们应用自然（可比较）排序[值]。
如果它们不具有可比性，那么您需要按照
valueComparator = Ordering.from(comparator).onResultOf(Functions.forMap(map))
这些可以应用于TreeMap（因为Ordering扩展了Comparator），或者在排序后应用于LinkedHashMap
注意：如果要使用TreeMap，请记住，如果比较==0，则该项已在列表中（如果有多个值进行比较，则会发生这种情况）。为了缓解这种情况，您可以像这样将键添加到比较器中（假设键和值是可比较的）：
valueComparator = Ordering.natural().onResultOf(Functions.forMap(map)).compound(Ordering.natural())
=对键映射的值应用自然排序，并将其与键的自然排序组合
请注意，如果您的键与0比较，这仍然不起作用，但这对于大多数可比较的项来说应该足够了（因为hashCode、equals和compareTo通常是同步的…）
请参见Ordering.onResultOf（）和Functions.forMap（）。
实施
现在我们有了一个比较器，它可以满足我们的需要，我们需要从中得到一个结果。
map = ImmutableSortedMap.copyOf(myOriginalMap, valueComparator);
现在，这很可能奏效，但：
需要完成一张完整的地图不要在TreeMap上尝试上面的比较器；当插入的键在put之后才有值时，尝试比较它是没有意义的，也就是说，它会很快断开
第1点对我来说有点破坏交易；google集合非常懒惰（这很好：你几乎可以在一瞬间完成所有操作；真正的工作是在你开始使用结果时完成的），这需要复制整个地图！
“完整”答案/按值排序的实时地图
不过别担心；如果你痴迷于以这种方式对“实时”地图进行排序，那么你可以用以下疯狂的方式解决上述问题，而不是其中一个，而是两个（！）：
注意：这在2012年6月发生了重大变化-以前的代码永远无法工作：需要内部HashMap来查找值，而不需要在TreeMap.get（）->compare（）和compare（（）->get（）之间创建无限循环
import static org.junit.Assert.assertEquals;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import com.google.common.base.Functions;
import com.google.common.collect.Ordering;
class ValueComparableMap<K extends Comparable<K>,V> extends TreeMap<K,V> {
//A map for doing lookups on the keys for comparison so we don't get infinite loops
private final Map<K, V> valueMap;
ValueComparableMap(final Ordering<? super V> partialValueOrdering) {
this(partialValueOrdering, new HashMap<K,V>());
}
private ValueComparableMap(Ordering<? super V> partialValueOrdering,
HashMap<K, V> valueMap) {
super(partialValueOrdering //Apply the value ordering
.onResultOf(Functions.forMap(valueMap)) //On the result of getting the value for the key from the map
.compound(Ordering.natural())); //as well as ensuring that the keys don't get clobbered
this.valueMap = valueMap;
}
public V put(K k, V v) {
if (valueMap.containsKey(k)){
//remove the key in the sorted set before adding the key again
remove(k);
}
valueMap.put(k,v); //To get "real" unsorted values for the comparator
return super.put(k, v); //Put it in value order
}
public static void main(String[] args){
TreeMap<String, Integer> map = new ValueComparableMap<String, Integer>(Ordering.natural());
map.put("a", 5);
map.put("b", 1);
map.put("c", 3);
assertEquals("b",map.firstKey());
assertEquals("a",map.lastKey());
map.put("d",0);
assertEquals("d",map.firstKey());
//ensure it's still a map (by overwriting a key, but with a new value)
map.put("d", 2);
assertEquals("b", map.firstKey());
//Ensure multiple values do not clobber keys
map.put("e", 2);
assertEquals(5, map.size());
assertEquals(2, (int) map.get("e"));
assertEquals(2, (int) map.get("d"));
}
}
当我们放入时，我们确保哈希映射具有比较器的值，然后将其放入TreeSet进行排序。但在此之前，我们检查哈希图，看看该键实际上不是重复的。此外，我们创建的比较器还将包括关键字，这样重复的值就不会删除非重复的关键字（由于==比较）。这两项对于确保地图合同得到遵守至关重要；如果你认为你不想这样，那么你几乎就要完全颠倒地图了（地图＜V，K＞）。
构造函数需要调用为
new ValueComparableMap(Ordering.natural());
//or
new ValueComparableMap(Ordering.from(comparator));
对于按关键字排序，我找到了一个更好的TreeMap解决方案（我也会尝试为基于值的排序准备一个解决方案）：
public static void main(String[] args) {
Map<String, String> unsorted = new HashMap<String, String>();
unsorted.put("Cde", "Cde_Value");
unsorted.put("Abc", "Abc_Value");
unsorted.put("Bcd", "Bcd_Value");
Comparator<String> comparer = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}};
Map<String, String> sorted = new TreeMap<String, String>(comparer);
sorted.putAll(unsorted);
System.out.println(sorted);
}
输出将是：
｛Abc=Abc_Value，Bcd=Bcd_Value，Cde=Cde_Value｝
如果您的Map值实现Comparable（例如String），那么这应该会起作用
Map<Object, String> map = new HashMap<Object, String>();
// Populate the Map
List<String> mapValues = new ArrayList<String>(map.values());
Collections.sort(mapValues);
如果映射值本身没有实现Comparable，但您有一个Comparable实例可以对它们进行排序，请将最后一行替换为：
Collections.sort(mapValues, comparable);
这太复杂了。地图不应该按价值排序。最简单的方法是创建自己的类，以满足您的需求。
在下面的示例中，您应该在*所在的位置添加TreeMap比较器。但通过javaAPI，它只提供比较器键，而不提供值。此处所述的所有示例均基于2个地图。一个哈希和一个新树。这很奇怪。
示例：
Map<Driver driver, Float time> map = new TreeMap<Driver driver, Float time>(*);
因此，通过以下方式将地图更改为集合：
ResultComparator rc = new ResultComparator();
Set<Results> set = new TreeSet<Results>(rc);
您将创建类Results，
public class Results {
private Driver driver;
private Float time;
public Results(Driver driver, Float time) {
this.driver = driver;
this.time = time;
}
public Float getTime() {
return time;
}
public void setTime(Float time) {
this.time = time;
}
public Driver getDriver() {
return driver;
}
public void setDriver (Driver driver) {
this.driver = driver;
}
}
以及Comparator类：
public class ResultsComparator implements Comparator<Results> {
public int compare(Results t, Results t1) {
if (t.getTime() < t1.getTime()) {
return 1;
} else if (t.getTime() == t1.getTime()) {
return 0;
} else {
return -1;
}
}
}
这样，您可以轻松添加更多依赖项。
最后一点，我将添加简单迭代器：
Iterator it = set.iterator();
while (it.hasNext()) {
Results r = (Results)it.next();
System.out.println( r.getDriver().toString
//or whatever that is related to Driver class -getName() getSurname()
+ " "
+ r.getTime()
);
}
