具有键值映射和排序的数据结构

Question

I need a data structure that provides key-value mappings, like a Map , but that also allows me to fetch the key based on an (int) index (eg myKey = myDS.get(index) ), without having to iterate over the data structure to get the key at the desired index.

I thought of using LinkedHashMap , but I don't see a way to get the key at a given index. Am I missing something in LinkedHashMap ? Or is there another data structure I can use?

EDIT :
This is not a duplicate. The correct answer to the other question is to use some sort of SortedMap ; however, that is not the correct answer to this question, since I'd like to be able to retrieve an Entry from the data structure via an Integer index, which is not supported in any Java library.

Answer 1

LinkedHashMap provides a hash table/doubly linked list implementation of the Map interface. Since it extends HashMap , it's still backed by an array, but there is also a doubly-linked list of Entry objects to ensure that the iteration order is predictable.

So, basically what it means is that when you iterate through the map like so:

for (Map.Entry<keyType,valueType>> entry : linkedHashMap.entrySet())
{
   System.out.println("Key: " + entry.getKey().toString() + 
                     " Value: " + entry.getValue.toString());
}

it will print in the order that you added the keys, as opposed to a non-linked Map, which will not print in insertion order . You cannot access the elements of the array like you want to, because the array that backs the hash is not in order . Only the doubly linked list is ordered.

Solution:

What you are looking for is a LinkedMap from Apache Commons.

Answer 2

AFAIK, there is no single data structure that will do this. There is certainly not one in the standard Java collection suite.

Also LinkedHashMap is not the solution because you cannot efficiently index a LinkedHashMap .

If you want to do index-based lookup as well as keep-based lookup, solution needs to be a combination of two data structures.

• A Map<Key, Value> and an ArrayList<Value> is the simpler approach, but it has a couple of problems: - Insertion and deletion of values from the ArrayList is expensive, unless you are inserting / deleting at the tail end of the list. - Insertion and deletion makes the list positions unstable,.

• If you want stable indexes and scalable insertion and deletion, then you need a Map<Key, Value> and a Map<Integer, Value> ... and a way to manage (ie recycle) the index values.

---

The Apache Commons LinkedMap class is a possible solution, except that it suffers from the problem that index values are not stable in the face of insertions and deletions.

Answer 3

How about using:

Map<String, String> map = new LinkedHashMap<String, String>();
List<Entry<String, String>> mapAsList = new ArrayList<Map.Entry<String,String>>(map.entrySet());

 mapAsList.get(index);

Answer 4

I do not believe there is a collection for this; collections are either based on the idea that you want to know exactly where an element is (lists) or that you want quick access based on some key or criteria (maps); doing both would be very resource-intensive to maintain.

Of course, you can make something like this, as rocketboy's answer suggests, but I'm guessing it's not really possible to make efficient.

Answer 5

There is no direct DS in the standard Java Collections API to provide a indexed map. However, the following should let you achieve the result:

// An ordered map
Map<K, V> map = new LinkedHashMap<K, V>();
// To create indexed list, copy the references into an ArrayList (backed by an array)
List<Entry<K, V>> indexedList = new ArrayList<Map.Entry<K, V>>(map.entrySet());
// Get the i'th term
<Map.Entry<K,V>> entry = indexedList.get(index);
K key = entry.getKey();
V value = entry.getValue();

You might still want to retain the concerns of data persistence in the map separate from the retrieval.

Update: Or use LinkedMap from Apache Commons as suggested by Steve.