List ordered map : Customized Map « Collections Data Structure « Java






List ordered map

   
/*
 * Copyright 2004, 2005, 2006 Odysseus Software GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 
 * List ordered map.
 * The iterators returned by <code>keySet()</code>, <code>values()</code>
 * and <code>entrySet()</code> methods reflect the order in which keys have
 * been added to the map.
 *
 * @author Christoph Beck
 */
public class ListOrderedMap implements Map {

  private final Map map;
  private final List lst; 

  public static Map decorate(Map map) {
    return new ListOrderedMap(map, new ArrayList());
  }
  
  protected ListOrderedMap(Map map, List lst) {
    super();
    
    this.map = map;
    this.lst = lst;

    lst.addAll(map.keySet());
  }

    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    public boolean containsValue(Object value) {
        return map.containsValue(value);
    }

    public Object get(Object key) {
        return map.get(key);
    }

    public boolean isEmpty() {
        return map.isEmpty();
    }

    public int size() {
        return map.size();
    }
   
    public boolean equals(Object object) {
      return object == this ? true : map.equals(object); 
    }

    public int hashCode() {
        return map.hashCode();
    }

  public Object put(Object key, Object value) {
    if (!map.containsKey(key)) {
      lst.add(key);
    }
    return map.put(key, value);
  }

  public void putAll(Map map) {
    Iterator it = map.entrySet().iterator();
    while (it.hasNext()) {
      Map.Entry entry = (Map.Entry) it.next();
      put(entry.getKey(), entry.getValue());
    }
  }

  public Object remove(Object key) {
    if (map.containsKey(key)) {
      lst.remove(key);
      return map.remove(key);
    }
    return null;
  }

  public void clear() {
    map.clear();
    lst.clear();
  }

  public Collection values() {
    return new AbstractCollection() {
      public int size() {
        return map.size();
      }
      public boolean contains(Object value) {
        return map.containsValue(value);
      }
      public void clear() {
        ListOrderedMap.this.clear();
      }
      public Iterator iterator() {
        return new Iterator() {
          Object last = null;
          Iterator keys = lst.iterator();
          public Object next() {
            return map.get(last = keys.next());
          }
          public boolean hasNext() {
            return keys.hasNext();
          }
          public void remove() {
            keys.remove();
            map.remove(last);
          }
        };
      }
    };
  }

  public Set keySet() {
    return new AbstractSet() {
      public int size() {
        return map.size();
      }
      public boolean contains(Object value) {
        return map.containsKey(value);
      }
      public void clear() {
        ListOrderedMap.this.clear();
      }
      public Iterator iterator() {
        return new Iterator() {
          Object last = null;
          Iterator keys = lst.iterator();
          public Object next() {
            return last = keys.next();
          }
          public boolean hasNext() {
            return keys.hasNext();
          }
          public void remove() {
            keys.remove();
            map.remove(last);
          }
        };
      }
    };
  }
  
  public Set entrySet() {
    return new AbstractSet() {
      Set delegate = ListOrderedMap.this.map.entrySet();
      public int size() {
        return ListOrderedMap.this.size();
      }
      public boolean contains(Object obj) {
        return delegate.contains(obj);
      }
      public boolean remove(Object obj) {
        boolean result = contains(obj);
        if (result) {
          ListOrderedMap.this.remove(((Map.Entry)obj).getKey());
        }
        return result;
      }
      public void clear() {
        ListOrderedMap.this.clear();
      }
      public boolean equals(Object obj) {
        return obj == this ? true : delegate.equals(obj);
      }
      public int hashCode() {
        return delegate.hashCode();
      }
      public String toString() {
        return delegate.toString();
      }
      public Iterator iterator() {
        return new Iterator() {
          Iterator keys = lst.iterator();
          Object last = null;
          public Object next() {
            last = keys.next();
            return new Map.Entry() {
              Object key = last;
              public Object getKey() {
                return key;
              }
              public Object getValue() {
                return map.get(key);
              }
              public Object setValue(Object value) {
                return map.put(key, value);
              }
            };
          }
          public boolean hasNext() {
            return keys.hasNext();
          }
          public void remove() {
            keys.remove();
            map.remove(last);
          }
        };
      }
    };
  }

  public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append('{');
    Iterator keys = keySet().iterator();
    while (keys.hasNext()) {
      Object key = keys.next();
      buf.append(key);
      buf.append('=');
      buf.append(get(key));
      if (keys.hasNext()) {
        buf.append(", ");
      }
    }
    buf.append('}');
    return buf.toString();
  }
}

   
    
    
  








Related examples in the same category

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