package com.test.sort;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* sort public static <T> void sort(T[] a, Comparator<? super T> c)
* 根据指定比较器产生的顺序对指定对象数组进行排序。
* 数组中的所有元素都必须是通过指定比较器可相互比较的
* (也就是说,对于数组中的任何 e1 和 e2
* 元素而言,c.compare(e1, e2) 不得抛出 ClassCastException)。
* 保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
*
* 该排序算法是一个经过修改的合并排序算法
* (其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。
* 此算法提供可保证的 n*log(n)性能。
*
* 参数: a - 要排序的数组 c - 确定数组顺序的比较器。
* null 值指示应该使用元素的自然顺序。 抛出: ClassCastException
* - 如果数组包含使用指定的比较器不可相互比较的 的元素。
*
* @param h
* @return 实现对map按照value升序排序
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Map.Entry[] getSortedHashtableByValue(Map h) {
Set set = h.entrySet();
Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set
.size()]);
Arrays.sort(entries, new Comparator() {
public int compare(Object arg0, Object arg1) {
Long key1 = Long.valueOf(((Map.Entry) arg0).getValue()
.toString());
Long key2 = Long.valueOf(((Map.Entry) arg1).getValue()
.toString());
// 升序
// return key1.compareTo(key2);
// 降序
return key2.compareTo(key1);
}
});
return entries;
}
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 3);
map.put("b", 5);
map.put("c", 4);
map.put("d", 4);
Map.Entry[] sortMapEntry = getSortedHashtableByValue(map);
for (int i = 0; i < sortMapEntry.length; i++) {
Map.Entry<String, Integer> everyEntry = sortMapEntry[i];
System.out.println(everyEntry.getKey() + ";"
+ everyEntry.getValue());
}
}
}
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/***
*具体排序算法可以参见java Arrays sort源码
***/
public class HashMapSortByValue {/**
* sort public static <T> void sort(T[] a, Comparator<? super T> c)
* 根据指定比较器产生的顺序对指定对象数组进行排序。
* 数组中的所有元素都必须是通过指定比较器可相互比较的
* (也就是说,对于数组中的任何 e1 和 e2
* 元素而言,c.compare(e1, e2) 不得抛出 ClassCastException)。
* 保证此排序是稳定的:不会因调用 sort 方法而对相等的元素进行重新排序。
*
* 该排序算法是一个经过修改的合并排序算法
* (其中,如果低子列表中的最高元素小于高子列表中的最低元素,则忽略合并)。
* 此算法提供可保证的 n*log(n)性能。
*
* 参数: a - 要排序的数组 c - 确定数组顺序的比较器。
* null 值指示应该使用元素的自然顺序。 抛出: ClassCastException
* - 如果数组包含使用指定的比较器不可相互比较的 的元素。
*
* @param h
* @return 实现对map按照value升序排序
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Map.Entry[] getSortedHashtableByValue(Map h) {
Set set = h.entrySet();
Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set
.size()]);
Arrays.sort(entries, new Comparator() {
public int compare(Object arg0, Object arg1) {
Long key1 = Long.valueOf(((Map.Entry) arg0).getValue()
.toString());
Long key2 = Long.valueOf(((Map.Entry) arg1).getValue()
.toString());
// 升序
// return key1.compareTo(key2);
// 降序
return key2.compareTo(key1);
}
});
return entries;
}
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 3);
map.put("b", 5);
map.put("c", 4);
map.put("d", 4);
Map.Entry[] sortMapEntry = getSortedHashtableByValue(map);
for (int i = 0; i < sortMapEntry.length; i++) {
Map.Entry<String, Integer> everyEntry = sortMapEntry[i];
System.out.println(everyEntry.getKey() + ";"
+ everyEntry.getValue());
}
}
}