Java 在HashMap中迭代如何持续到第一个？

我有HashMAp

 items = new HashMap<String, String>();
        items.put("A", "1");
        items.put("B", "2");
        items.put("C", "3");

HashMap不保证任何排序。如果您使用，它将按插入顺序排列，但仍然没有方便的方法进行后退

---

一种方法是调用

items.entrySet（）

。返回一个

集

。然后，您可以获得集合的大小，调用

toArray（）

，然后执行降序循环。

编辑：我和Matthew显然对您的问题的含义有不同的解释。您是指插入的顺序相反，还是键的顺序相反

如果您指的是键的相反顺序，请按以下方法操作：

使用有序映射，如TreeMap，然后迭代items.keySet（）

TreeMap按键值的自然顺序进行排序，因此需要将比较器传递给构造函数，以便按相反顺序对键进行排序：

Map<String, String> items = new TreeMap<String, String>(new Comparator<String>() {
  public int compare(String a, String b) {
    return b.compareTo(a);
  }
});

items.put("A", "1");
items.put("B", "2");
items.put("C", "3");

for (String s: items.keySet()) {
  System.out.println(s + " " + items.get(s));
}

Map items=newtreemap（newcomparator（）{
公共整数比较（字符串a、字符串b）{
返回b.compareTo（a）；
}
});
项目。投入（“A”、“1”）；
项目。投入（“B”、“2”）；
项目。投入（“C”、“3”）；
对于（字符串s:items.keySet（））{
System.out.println（s+“”+items.get（s））；
}

另一种方法-创建钥匙的分类数据集：

import java.util.*;

class MyComparator implements Comparator<String> {
    public int compare(String a, String b) {
        return -a.compareTo(b);
    }

    public boolean equals(String a, String b) {
        return a.equals(b);
    }
}

public class test {
    public static void main(String[] args) {
        HashMap<String, String> items = new HashMap<String, String>();
        items.put("A", "1");
        items.put("B", "2");
        items.put("C", "3");

        TreeSet<String> ts = new TreeSet<String>(new MyComparator());
        ts.addAll(items.keySet());
        for(Iterator<String> i = ts.iterator(); i.hasNext(); ) {
            String key = i.next();
            System.out.println("key: " + key + ", value: " + items.get(key));
        }
    }
}

import java.util.*；
类MyComparator实现比较器{
公共整数比较（字符串a、字符串b）{
返回-a.与（b）比较；
}
公共布尔等于（字符串a、字符串b）{
返回a等于（b）；
}
}
公开课考试{
公共静态void main（字符串[]args）{
HashMap items=新的HashMap（）；
项目。投入（“A”、“1”）；
项目。投入（“B”、“2”）；
项目。投入（“C”、“3”）；
TreeSet ts=新的TreeSet（新的MyComparator（））；
ts.addAll（items.keySet（））；
for（迭代器i=ts.Iterator（）；i.hasNext（）；）{
字符串键=i.next（）；
System.out.println（“键：+key+”，值：+items.get（键））；
}
}
}

输出：

key: C, value: 3 key: B, value: 2 key: A, value: 1 键：C，值：3 键：B，值：2 键：A，值：1 您可以使用（是一个

NavigableMap

），它是一个具有导航功能的

SortedMap

返回此映射中包含的映射的逆序视图（不是副本）

例如：

NavigableMap<String, String> items = new TreeMap<String, String>();
items.put("B", "2");
items.put("A", "1");
items.put("C", "3");

for (Map.Entry<String, String> e : items.entrySet()) {
    System.out.println(e);
}
// gives
// A=1
// B=2
// C=3

for (Map.Entry<String, String> e : items.descendingMap().entrySet()) {
    System.out.println(e);
}

// gives
// C=3
// B=2
// A=1

NavigableMap items=newtreemap（）；
项目。投入（“B”、“2”）；
项目。投入（“A”、“1”）；
项目。投入（“C”、“3”）；
对于（Map.Entry e:items.entrySet（））{
系统输出打印ln（e）；
}
//给予
//A=1
//B=2
//C=3
对于（Map.Entry e:items.downingmap（）.entrySet（））{
系统输出打印ln（e）；
}
//给予
//C=3
//B=2
//A=1

注意：如果您关心

地图中按键的自然顺序，则此答案有效。如果您关心插入顺序或访问顺序，请查看
LinkedHashMap

注2：在您的问题中，您使用了一个
HashMap
。请注意，
HashMap
不保证其元素的任何顺序。事实上，它甚至不能保证订单在一段时间内保持不变。更多参考请参见HashMap的第一段。
术语Last和first似乎表示时间。我看到的大多数答案都假设最后一个和第一个是语义的（例如C比A大，因此最后一个）。如果您需要插入时间顺序，并且键中没有插入时间戳，OrderedMaps将无法帮助您。
HashMap
不保证其元素的任何顺序。特别是，它不能保证顺序随时间保持不变。因此，
HashMap
不是您想要的，如果您必须维护任何类型的顺序。您假设最后一个是在键的上下文中，但我认为他指的是插入时间。如果插入时间不在键中，则比较器无法帮助您。我不同意。我认为插入时间与此无关。我认为他犯了一个错误，认为HashMap可以按某种顺序进行迭代，并希望将其反转。我假设他的意思是按字母顺序排列的。顺序是基于键语义的。但我认为问题在于插入时间。因此，反向顺序对您没有帮助，因为顺序标准（插入时间）不是键的一部分。我添加了一个注释以澄清这一点。此代码等效：
Map items=new TreeMap（Collections.reverseOrder（））
NavigableMap<String, String> items = new TreeMap<String, String>();
items.put("B", "2");
items.put("A", "1");
items.put("C", "3");

for (Map.Entry<String, String> e : items.entrySet()) {
    System.out.println(e);
}
// gives
// A=1
// B=2
// C=3

for (Map.Entry<String, String> e : items.descendingMap().entrySet()) {
    System.out.println(e);
}

// gives
// C=3
// B=2
// A=1