我建议使用LinkedHashMap或TreeMap。LinkedHashMap按插入键的顺序保存键，而TreeMap则通过Comparator或键的自然可比顺序保持排序。

因为它不需要保持元素排序，LinkedHashMap在大多数情况下应该更快;根据Javadocs, TreeMap对于containsKey、get、put和remove的性能为O(log n)，而LinkedHashMap则为O(1)。

如果您的API只期望可预测的排序顺序，而不是特定的排序顺序，请考虑使用这两个类实现的接口NavigableMap或SortedMap。这将允许您不会将特定的实现泄漏到您的API中，然后随意切换到这些特定的类或完全不同的实现。

我不知道它是否是开源的，但在谷歌了一下之后，我发现了这个使用数组列表的Map实现。它似乎是1.5之前的Java，所以您可能想要泛化它，这应该很容易。注意，这个实现有O(N)访问权限，但如果您没有向JPanel添加数百个小部件，这应该不是问题，无论如何也不应该这样做。

您可以维护Map(用于快速查找)和List(用于顺序)，但LinkedHashMap可能是最简单的。你也可以尝试SortedMap，例如TreeMap，它可以有你指定的任何顺序。

如果一个不可变映射符合您的需求，那么谷歌有一个名为guava的库(参见guava问题)

Guava提供了一个具有可靠的用户指定迭代顺序的ImmutableMap。这个ImmutableMap对于containsKey, get有O(1)的性能。显然不支持放置和移除。

ImmutableMap对象是通过使用优雅的静态方便方法()和copyOf()或Builder对象来构造的。

当你遍历映射的keySet()， entrySet()或values()时，LinkedHashMap将按它们插入到映射中的顺序返回元素。

Map<String, String> map = new LinkedHashMap<String, String>();

map.put("id", "1");
map.put("name", "rohan");
map.put("age", "26");

for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

这将按元素放入map中的顺序打印它们:

id = 1
name = rohan 
age = 26 

每当我需要维护事物的自然顺序，我使用一个EnumMap提前知道

键将是枚举，你可以插入任何你想要的顺序，但当你迭代它将迭代在枚举顺序(自然顺序)。

此外，在使用EnumMap时，不应该有碰撞，这可以更有效。

我真的发现使用enumMap可以生成清晰可读的代码。 这里有一个例子

你可以使用LinkedHashMap来确定Map中的插入顺序

关于Java LinkedHashMap类的要点是:

它只包含独特的元素。 LinkedHashMap包含基于键的值。 它可以有一个空键和多个空值。 它与HashMap相同，只是维护插入顺序 公共类LinkedHashMap<K,V>扩展HashMap<K,V>实现Map<K,V>

但如果你想使用用户定义对象或任何基本数据类型键对map中的值进行排序，那么你应该使用TreeMap获取更多信息，请参阅此链接

你可以使用LinkedHashMap<K, V>或者你可以实现你自己的CustomMap来维护插入顺序。

您可以将以下CustomHashMap与以下特性一起使用:

插入顺序是通过内部使用LinkedHashMap来维护的。 不允许键具有null或空字符串。 一旦key with value被创建，我们就不会重写它的值。

HashMap vs LinkedHashMap vs CustomHashMap

interface CustomMap<K, V> extends Map<K, V> {
    public boolean insertionRule(K key, V value);
}

@SuppressWarnings({ "rawtypes", "unchecked" })
public class CustomHashMap<K, V> implements CustomMap<K, V> {
    private Map<K, V> entryMap;
    // SET: Adds the specified element to this set if it is not already present.
    private Set<K> entrySet;

    public CustomHashMap() {
        super();
        entryMap = new LinkedHashMap<K, V>();
        entrySet = new HashSet();
    }

    @Override
    public boolean insertionRule(K key, V value) {
        // KEY as null and EMPTY String is not allowed.
        if (key == null || (key instanceof String && ((String) key).trim().equals("") ) ) {
            return false;
        }

        // If key already available then, we are not overriding its value.
        if (entrySet.contains(key)) { // Then override its value, but we are not allowing
            return false;
        } else { // Add the entry
            entrySet.add(key);
            entryMap.put(key, value);
            return true;
        }
    }
    public V put(K key, V value) {
        V oldValue = entryMap.get(key);
        insertionRule(key, value);
        return oldValue;
    }
    public void putAll(Map<? extends K, ? extends V> t) {
        for (Iterator i = t.keySet().iterator(); i.hasNext();) {
            K key = (K) i.next();
            insertionRule(key, t.get(key));
        }
    }

    public void clear() {
        entryMap.clear();
        entrySet.clear();
    }
    public boolean containsKey(Object key) {
        return entryMap.containsKey(key);
    }
    public boolean containsValue(Object value) {
        return entryMap.containsValue(value);
    }
    public Set entrySet() {
        return entryMap.entrySet();
    }
    public boolean equals(Object o) {
        return entryMap.equals(o);
    }
    public V get(Object key) {
        return entryMap.get(key);
    }
    public int hashCode() {
        return entryMap.hashCode();
    }
    public boolean isEmpty() {
        return entryMap.isEmpty();
    }
    public Set keySet() {
        return entrySet;
    }
    public V remove(Object key) {
        entrySet.remove(key);
        return entryMap.remove(key);
    }
    public int size() {
        return entryMap.size();
    }
    public Collection values() {
        return entryMap.values();
    }
}

CustomHashMap的用法:

public static void main(String[] args) {
    System.out.println("== LinkedHashMap ==");
    Map<Object, String> map2 = new LinkedHashMap<Object, String>();
    addData(map2);

    System.out.println("== CustomHashMap ==");
    Map<Object, String> map = new CustomHashMap<Object, String>();
    addData(map);
}
public static void addData(Map<Object, String> map) {
    map.put(null, "1");
    map.put("name", "Yash");
    map.put("1", "1 - Str");
    map.put("1", "2 - Str"); // Overriding value
    map.put("", "1"); // Empty String
    map.put(" ", "1"); // Empty String
    map.put(1, "Int");
    map.put(null, "2"); // Null

    for (Map.Entry<Object, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " = " + entry.getValue());
    }
}

O/P:

== LinkedHashMap == | == CustomHashMap ==
null = 2            | name = Yash
name = Yash         | 1 = 1 - Str
1 = 2 - Str         | 1 = Int
 = 1                |
  = 1               |
1 = Int             |

如果你知道KEY是固定的，那么你可以使用EnumMap。从属性/XML文件中获取值

EX:

enum ORACLE {
    IP, URL, USER_NAME, PASSWORD, DB_Name;
}

EnumMap<ORACLE, String> props = new EnumMap<ORACLE, String>(ORACLE.class);
props.put(ORACLE.IP, "127.0.0.1");
props.put(ORACLE.URL, "...");
props.put(ORACLE.USER_NAME, "Scott");
props.put(ORACLE.PASSWORD, "Tiget");
props.put(ORACLE.DB_Name, "MyDB");