Ordered Map : Customized Map « Collections Data Structure « Java

Ordered Map


import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

 * This is a simple Map implementation backed by a List of Map.Entry objects. 
 * It has the property that iterators return entries in the order in whick
 * they were inserted.
 * Operations involving searching, including get() and put(), have cost linear 
 * to the size of the map. In other words, avoid this implementation if your 
 * Map might get large.
 * If we could assume Java 1.4+, we'd just use java.util.LinkedHashMap 
 * instead of this class.  But we can't.
 * @author Mike Williams
public class OrderedMap extends AbstractMap {

    private Set _entrySet = new OrderedSet();

    public Set entrySet() {
        return _entrySet;

    public Object put(Object key, Object value) {
        Entry existingEntry = getEntryWithKey(key);
        if (existingEntry == null) {
            entrySet().add(new Entry(key, value));
            return null;
        Object previousValue = existingEntry.getValue();
        return previousValue;

    private Entry getEntryWithKey(Object key) {
        Iterator i = entrySet().iterator();
        while (i.hasNext()) {
            Entry e = (Entry) i.next();
            if (eq(e.getKey(), key)) {
                return e;
        return null;
    static class OrderedSet extends AbstractSet {

        private List _elementList = new LinkedList();

        public int size() {
            return _elementList.size();

        public Iterator iterator() {
            return _elementList.iterator();

        public boolean add(Object o) {
            return true;

    static class Entry implements Map.Entry {
        Object _key;
        Object _value;

        public Entry(Object key, Object value) {
            _key = key;
            _value = value;

        public Object getKey() {
            return _key;

        public Object getValue() {
            return _value;

        public Object setValue(Object value) {
            Object oldValue = _value;
            _value = value;
            return oldValue;

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry)) {
                return false;
            Map.Entry e = (Map.Entry) o;
            return eq(_key, e.getKey()) && eq(_value, e.getValue());

        public int hashCode() {
            return ((_key == null) ? 0 : _key.hashCode()) ^
                   ((_value == null) ? 0 : _value.hashCode());

        public String toString() {
            return _key + "=" + _value;


    private static boolean eq(Object o1, Object o2) {
        return (o1 == null ? o2 == null : o1.equals(o2));


Related examples in the same category

1.Case Insensitive Map
2.A Map collection with real-time behavior
3.Cache Map
4.Map implementation Optimized for Strings keys
5.An integer hashmap
6.An IdentityMap that uses reference-equality instead of object-equality
7.Int Object HashMap
8.Concurrent Skip List Map
9.A hash map that uses primitive ints for the key rather than objects.
10.Integer Map
11.Copy On Write Map
12.Expiring Map
13.Array Map
14.Int Object HashMap (from CERN)
15.Int HashMap from jodd.org
16.String Map
17.List Map
18.Map using Locale objects as keys
19.Map with keys iterated in insertion order
20.Most Recently Used Map
21.Multi Map
22.MultiMap is a Java version of the C++ STL class std::multimap
23.Object Int Map
24.Sequenced HashMap
25.Int Int Map
26.Int Object Map
27.Identity HashMap
28.A java.util.Map interface which can only hold a single object
29.A multi valued Map
30.A simple hashmap from keys to integers
31.A memory-efficient hash map.
32.An implementation of the java.util.Map interface which can only hold a single object.
33.Utility methods for operating on memory-efficient maps.
34.CaseBlindHashMap - a HashMap extension, using Strings as key values.
35.A fixed size map implementation.
36.Int HashMap
37.IntMap provides a simple hashmap from keys to integers
38.Complex Key HashMap
39.A Map with multiple values for a key
40.A Map that accepts int or Integer keys only
41.A Map where keys are compared by object identity, rather than equals()
42.Type-safe Map, from char array to String value
43.A hashtable-based Map implementation with soft keys
44.List ordered map
45.Hash map using String values as keys mapped to primitive int values.
46.Lookup table that stores a list of strings
47.HashNMap stores multiple values by a single key value. Values can be retrieved using a direct query or by creating an enumeration over the stored elements.
48.Combines multiple values to form a single composite key. MultiKey can often be used as an alternative to nested maps.