Java Code:
import java.util.*;
import java.lang.ref.*;

public class SoftHashMap extends AbstractMap implements Map {

  private Set entrySet = null;
  private Map hash;
  private ReferenceQueue queue = new ReferenceQueue();

  static private class SoftKey extends SoftReference {
    private int hash;

    private SoftKey(Object k) {
      super(k);
      hash = k.hashCode();
    }
    private static SoftKey create(Object k) {
      if (k == null) {
        return null;
      } else {
        return new SoftKey(k);
      }
    }
    private SoftKey(Object k, ReferenceQueue q) {
      super(k, q);
      hash = k.hashCode();
    }
    private static SoftKey create(Object k, ReferenceQueue q) {
      if (k == null) {
        return null;
      } else {
        return new SoftKey(k, q);
      }
    }
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      } else if (!(o instanceof SoftKey)) {
        return false;
      }
      Object t = this.get();
      Object u = ((SoftKey)o).get();
      if ((t == null) || (u == null)) {
        return false;
      } else if (t == u) {
        return true;
      } else {
        return t.equals(u);
      }
    }
    public int hashCode() {
      return hash;
    }
  }

  private void processQueue() {
    SoftKey sk;
    while ((sk = (SoftKey)queue.poll()) != null) {
      hash.remove(sk);
    }
  }

  public SoftHashMap() {
    hash = new HashMap();
  }

  public SoftHashMap(Map t) {
    this(Math.max(2*t.size(), 11), 0.75f);
    putAll(t);
  }

  public SoftHashMap(int initialCapacity) {
    hash = new HashMap(initialCapacity);
  }

  public SoftHashMap(int initialCapacity, float loadFactor) {
    hash = new HashMap(initialCapacity, loadFactor);
  }

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

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

  public boolean containsKey(Object key) {
    return hash.containsKey(SoftKey.create(key));
  }

  public Object get(Object key) {
    return hash.get(SoftKey.create(key));
  }

  public Object put(Object key, Object value) {
    processQueue();
    return hash.put(SoftKey.create(key, queue), value);
  }

  public Object remove(Object key) {
    processQueue();
    return hash.remove(SoftKey.create(key));
  }

  public void clear() {
    processQueue();
    hash.clear();
  }

  private static class Entry implements Map.Entry {
    private Map.Entry ent;
    private Object key;

    Entry(Map.Entry ent, Object key) {
      this.ent = ent;
      this.key = key;
    }

    public Object getKey() {
      return key;
    }

    public Object getValue() {
      return ent.getValue();
    }

    public Object setValue(Object value) {
      return ent.setValue(value);
    }

    public boolean equals(Object o) {
      if (!(o instanceof Map.Entry)) {
        return false;
      } else {
        Map.Entry e = (Map.Entry)o;
        Object value = getValue();
        return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
      }
    }

    public int hashCode() {
      Object value = getValue();
      return (((key == null) ? 0 : key.hashCode())
        ^ ((value == null) ? 0 : value.hashCode()));
    }

  }

  public Set entrySet() {
    if (entrySet == null) {
      entrySet = new EntrySet();
    }
    return entrySet;
  }

  private class EntrySet extends AbstractSet {
    Set set = hash.entrySet();

    public Iterator iterator() {

      return new Iterator() {
        Iterator iter = set.iterator();
        Entry next = null;

        public boolean hasNext() {
          while (iter.hasNext()) {
            Map.Entry ent = (Map.Entry)iter.next();
            SoftKey sk = (SoftKey)ent.getKey();
            Object k = null;
            if ((sk != null) && ((k = sk.get()) == null)) {
              /* Soft key has been cleared by GC */
              continue;
            }
            next = new Entry(ent, k);
            return true;
          }
          return false;
        }

        public Object next() {
          if ((next == null) && !hasNext()) {
            throw new NoSuchElementException();
          }
          Entry element = next;
          next = null;
          return element;
        }

        public void remove() {
          iter.remove();
        }
      };
    }

    public boolean isEmpty() {
      return !(iterator().hasNext());
    }

    public int size() {
      int size = 0;
      for (Iterator i = iterator(); i.hasNext(); i.next(), size++);
      return size;
    }

    public boolean remove(Object o) {
      processQueue();
      if (!(o instanceof Map.Entry)) {
        return false;
      }
      Map.Entry e = (Map.Entry)o;
      Object ev = e.getValue();
      SoftKey sk = SoftKey.create(e.getKey());
      Object hv = hash.get(sk);
      if ((hv == null)
          ? ((ev == null) && hash.containsKey(sk)) : hv.equals(ev)) {
        hash.remove(sk);
        return true;
      }
      return false;
    }

    public int hashCode() {
      int h = 0;
      for (Iterator i = set.iterator(); i.hasNext();) {
        Map.Entry ent = (Map.Entry)i.next();
        SoftKey sk = (SoftKey)ent.getKey();
        Object v;
        if (sk == null) {
          continue;
        }
        h += (sk.hashCode()
          ^ (((v = ent.getValue()) == null) ? 0 : v.hashCode()));
      }
      return h;
    }
  }
}