implements Map : Map « java.util « Java by API

1. Java by API
2. java.util
3. Map

implements Map

 
/*
You asked about Google.
They are located in: null

Key Adobe; Value Mountain View, CA
Key IBM; Value White Plains, NY
Key Learning Tree; Value Los Angeles, CA
entrySet() returns 3 Map.Entry's*/

import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

public class MainClass {

  public static void main(String[] argv) {
    Map map = new MyMap();

    map.put("Adobe", "Mountain View, CA");
    map.put("Learning Tree", "Los Angeles, CA");
    map.put("IBM", "White Plains, NY");

    String queryString = "Google";
    System.out.println("You asked about " + queryString + ".");
    String resultString = (String) map.get(queryString);
    System.out.println("They are located in: " + resultString);
    System.out.println();

    Iterator k = map.keySet().iterator();
    while (k.hasNext()) {
      String key = (String) k.next();
      System.out.println("Key " + key + "; Value " + (String) map.get(key));
    }

    Set es = map.entrySet();
    System.out.println("entrySet() returns " + es.size() + " Map.Entry's");
  }
}

class MyMap implements Map {

  private ArrayList keys;

  private ArrayList values;

  public MyMap() {
    keys = new ArrayList();
    values = new ArrayList();
  }

  /** Return the number of mappings in this Map. */
  public int size() {
    return keys.size();
  }

  /** Return true if this map is empty. */
  public boolean isEmpty() {
    return size() == 0;
  }

  /** Return true if o is contained as a Key in this Map. */
  public boolean containsKey(Object o) {
    return keys.contains(o);
  }

  /** Return true if o is contained as a Value in this Map. */
  public boolean containsValue(Object o) {
    return keys.contains(o);
  }

  /** Get the object value corresponding to key k. */
  public Object get(Object k) {
    int i = keys.indexOf(k);
    if (i == -1)
      return null;
    return values.get(i);
  }

  /**
   * Put the given pair (k, v) into this map, by maintaining "keys" in sorted
   * order.
   */
  public Object put(Object k, Object v) {
    for (int i = 0; i < keys.size(); i++) {
      Object old = keys.get(i);

      /* Does the key already exist? */
      if (((Comparable) k).compareTo(keys.get(i)) == 0) {
        keys.set(i, v);
        return old;
      }

      /*
       * Did we just go past where to put it? i.e., keep keys in sorted order.
       */
      if (((Comparable) k).compareTo(keys.get(i)) == +1) {
        int where = i > 0 ? i - 1 : 0;
        keys.add(where, k);
        values.add(where, v);
        return null;
      }
    }

    // Else it goes at the end.
    keys.add(k);
    values.add(v);
    return null;
  }

  /** Put all the pairs from oldMap into this map */
  public void putAll(java.util.Map oldMap) {
    Iterator keysIter = oldMap.keySet().iterator();
    while (keysIter.hasNext()) {
      Object k = keysIter.next();
      Object v = oldMap.get(k);
      put(k, v);
    }
  }

  public Object remove(Object k) {
    int i = keys.indexOf(k);
    if (i == -1)
      return null;
    Object old = values.get(i);
    keys.remove(i);
    values.remove(i);
    return old;
  }

  public void clear() {
    keys.clear();
    values.clear();
  }

  public java.util.Set keySet() {
    return new TreeSet(keys);
  }

  public java.util.Collection values() {
    return values;
  }

  /**
   * The Map.Entry objects contained in the Set returned by entrySet().
   */
  private class MyMapEntry implements Map.Entry, Comparable {
    private Object key, value;

    MyMapEntry(Object k, Object v) {
      key = k;
      value = v;
    }

    public Object getKey() {
      return key;
    }

    public Object getValue() {
      return value;
    }

    public Object setValue(Object nv) {
      throw new UnsupportedOperationException("setValue");
    }

    public int compareTo(Object o2) {
      if (!(o2 instanceof MyMapEntry))
        throw new IllegalArgumentException("Huh? Not a MapEntry?");
      Object otherKey = ((MyMapEntry) o2).getKey();
      return ((Comparable) key).compareTo((Comparable) otherKey);
    }
  }

  /** The set of Map.Entry objects returned from entrySet(). */
  private class MyMapSet extends AbstractSet {
    List list;

    MyMapSet(ArrayList al) {
      list = al;
    }

    public Iterator iterator() {
      return list.iterator();
    }

    public int size() {
      return list.size();
    }
  }

  /**
   * Returns a set view of the mappings contained in this Map. Each element in
   * the returned set is a Map.Entry. NOT guaranteed fully to implement the
   * contract of entrySet declared in java.util.Map.
   */
  public java.util.Set entrySet() {
    if (keys.size() != values.size())
      throw new IllegalStateException("InternalError: keys and values out of sync");
    ArrayList al = new ArrayList();
    for (int i = 0; i < keys.size(); i++) {
      al.add(new MyMapEntry(keys.get(i), values.get(i)));
    }
    return new MyMapSet(al);
  }
}

           
         
  

Related examples in the same category