我有一个同时包含键和值的字符串的Map。
数据如下：
“ question1”，“ 1”
“ question9”，“ 1”
“ question2”，“ 4”
“ question5”，“ 2”
我想根据其键对地图进行排序。因此，最后，我将拥有question1, question2, question3...等等。
最终，我试图从此Map中获取两个字符串。
现在，我有以下内容：
Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
questionAnswers += pairs.getKey() + ",";
}
这使我的问题成串出现，但顺序不正确。
Answers:
使用TreeMap。这正是它的目的。
如果此地图传递给您，并且您无法确定类型，则可以执行以下操作：
SortedSet<String> keys = new TreeSet<>(map.keySet());
for (String key : keys) {
String value = map.get(key);
// do something
}
这将以键的自然顺序在地图上进行迭代。
从技术上讲，您可以使用任何实现的方法SortedMap，但是在极少数情况下TreeMap，Map实现的费用与使用实现的费用通常相同HashMap。
如果您的键是无法实现Comparable的复杂类型，或者您不想使用自然顺序，然后TreeMap又有TreeSet其他构造函数可以让您传递Comparator：
// placed inline for the demonstration, but doesn't have to be a lambda expression
Comparator<Foo> comparator = (Foo o1, Foo o2) -> {
...
}
SortedSet<Foo> keys = new TreeSet<>(comparator);
keys.addAll(map.keySet());
请记住，当使用TreeMap或时TreeSet，它将具有与HashMap或不同的性能特征HashSet。粗略地说，查找或插入元素的操作将从O（1）到O（Log（N））。
在中HashMap，从1000项增加到10,000项并不会真正影响您查找元素的时间，但是对于一个元素，TreeMap查找时间将慢3倍左右（假设Log 2）。对于每个元素查找，从1000迁移到100,000将慢6倍。
假设TreeMap对您不利（并假设您不能使用泛型）：
List sortedKeys=new ArrayList(yourMap.keySet());
Collections.sort(sortedKeys);
// Do what you need with sortedKeys.
使用TreeMap可以对地图进行排序。
Map<String, String> map = new HashMap<>();
Map<String, String> treeMap = new TreeMap<>(map);
for (String str : treeMap.keySet()) {
System.out.println(str);
}
使用TreeMap！
如果您已经有了地图，并且想按键对它进行排序，则只需使用：
Map<String, String> treeMap = new TreeMap<String, String>(yourMap);一个完整的工作示例：
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
class SortOnKey {
public static void main(String[] args) {
HashMap<String,String> hm = new HashMap<String,String>();
hm.put("3","three");
hm.put("1","one");
hm.put("4","four");
hm.put("2","two");
printMap(hm);
Map<String, String> treeMap = new TreeMap<String, String>(hm);
printMap(treeMap);
}//main
public static void printMap(Map<String,String> map) {
Set s = map.entrySet();
Iterator it = s.iterator();
while ( it.hasNext() ) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + " => " + value);
}//while
System.out.println("========================");
}//printMap
}//class如果您不能使用TreeMap，在Java 8中，我们可以使用toMap（）方法，Collectors该方法具有以下参数：
Java 8示例
Map<String,String> sample = new HashMap<>(); // push some values to map
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
.sorted(Map.Entry.<String,String>comparingByKey().reversed())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
.sorted(Map.Entry.<String,String>comparingByValue().reversed())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));我们可以修改该示例以使用自定义比较器并基于以下项对键进行排序：
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
.sorted((e1,e2) -> e1.getKey().compareTo(e2.getKey()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));使用Java 8：
Map<String, Integer> sortedMap = unsortMap.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));此代码可以按升序和降序这两个顺序对键值映射进行排序。
<K, V extends Comparable<V>> Map<K, V> sortByValues
(final Map<K, V> map, int ascending)
{
Comparator<K> valueComparator = new Comparator<K>() {
private int ascending;
public int compare(K k1, K k2) {
int compare = map.get(k2).compareTo(map.get(k1));
if (compare == 0) return 1;
else return ascending*compare;
}
public Comparator<K> setParam(int ascending)
{
this.ascending = ascending;
return this;
}
}.setParam(ascending);
Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
sortedByValues.putAll(map);
return sortedByValues;
}举个例子：
Map<Integer,Double> recommWarrVals = new HashMap<Integer,Double>();
recommWarrVals = sortByValues(recommWarrVals, 1); // Ascending order
recommWarrVals = sortByValues(recommWarrVals,-1); // Descending order要Map<K, V>按键排序，请将键放入List<K>：
List<K> result = map.keySet().stream().sorted().collect(Collectors.toList());要Map<K, V>按键排序，请将条目放入List<Map.Entry<K, V>>：
List<Map.Entry<K, V>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toList());最后但并非最不重要的一点：以对语言环境敏感的方式对字符串进行排序-使用Collator（比较器）类：
Collator collator = Collator.getInstance(Locale.US);
collator.setStrength(Collator.PRIMARY); // case insensitive collator
List<Map.Entry<String, String>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey(collator))
.collect(Collectors.toList());List<String> list = new ArrayList<String>();
Map<String, String> map = new HashMap<String, String>();
for (String str : map.keySet()) {
list.add(str);
}
Collections.sort(list);
for (String str : list) {
System.out.println(str);
}我们还可以使用Arrays.sort方法对键进行排序。
Map<String, String> map = new HashMap<String, String>();
Object[] objArr = new Object[map.size()];
for (int i = 0; i < map.size(); i++) {
objArr[i] = map.get(i);
}
Arrays.sort(objArr);
for (Object str : objArr) {
System.out.println(str);
}以防万一您不想使用 TreeMap
public static Map<Integer, Integer> sortByKey(Map<Integer, Integer> map) {
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
list.sort(Comparator.comparingInt(Map.Entry::getKey));
Map<Integer, Integer> sortedMap = new HashMap<>();
list.forEach(sortedMap.put(e.getKey(), e.getValue()));
return sortedMap;
}另外，如果您想根据values更改Map.Entry::getKey为Map.Entry::getValue