Покритикуйте код

package ru.hixon.cache;
 
import java.util.*;
 
public class FixedSizeCache<K,V> implements Map<K,V> {
 
    private ArrayList<K> keys;
    private ArrayList<V> values;
    private int maxCapacity;
 
    public FixedSizeCache() {
        keys = new ArrayList<>();
        values = new ArrayList<>();
        maxCapacity = -1;
    }
    
    public FixedSizeCache(int capacity) {
        this();
        if (capacity > 0) {
            maxCapacity = capacity;
        } else {
            maxCapacity = 0;
        }
    }
 
    /** Return the number of mappings in this Map. */
    @Override
    public int size() {
        return keys.size();
    }
 
    /** Return true if this map is empty. */
    @Override
    public boolean isEmpty() {
        return size() == 0;
    }
 
    /** Return true if key is contained as a Key in this Map. */
    @Override
    public boolean containsKey(Object key) {
        return keys.contains((K)key);
    }
 
    /** Return true if value is contained as a Value in this Map. */
    @Override
    public boolean containsValue(Object value) {
        return values.contains((V)value);
    }
 
    /** Get the V value corresponding to key k. */
    @Override
    public V 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.
     */
    @Override
    public V put(K k, V v) {
        if (k == null) {
             throw new NullPointerException();
        }
 
        if (maxCapacity == keys.size() && keys.size() > 0) {
            keys.remove(0);
            values.remove(0);
        }
 
        for (int i=0; i < keys.size(); i++) {
            K old = keys.get(i);
 
            /* Does the key already exist? */
            if (((Comparable)k).compareTo(keys.get(i)) == 0) {
                values.set(i, v);
                return get(old);
            }
        }
 
        // Else it goes at the end.
        int where = keys.size();
        keys.add(where, k);
        values.add(where, v);
        return null;
    }
 
    /** Put all the pairs from oldMap into this map */
    @Override
    public void putAll(Map<? extends K, ? extends V> oldMap) {
        Iterator<? extends K> keysIter = oldMap.keySet().iterator();
        while (keysIter.hasNext()) {
            K k = (K)keysIter.next();
            V v = oldMap.get(k);
            put(k, v);
        }
    }
 
    @Override
    public V remove(Object k) {
        int i = keys.indexOf(k);
        if (i == -1) {
            return null;
        }
        V old = values.get(i);
        keys.remove(i);
        values.remove(i);
        return old;
    }
 
    @Override
    public void clear() {
        keys.clear();
        values.clear();
    }
 
    @Override
    public java.util.Set<K> keySet() {
        return new TreeSet<>(keys);
    }
 
    @Override
    public java.util.Collection<V> values() {
        return values;
    }
 
    /** The Map.Entry objects contained in the Set returned by entrySet().
     */
    private class MyMapEntry<K,V> implements Map.Entry<K,V>, Comparable {
        private K key;
        private V value;
        MyMapEntry(K k, V v) {
            key = k;
            value = v;
        }
        
        @Override
        public K getKey() { 
            return key; 
        }
        
        @Override
        public V getValue() { 
            return value; 
        }
        
        @Override
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
 
        @Override
        public int compareTo(Object o2) {
            if (!(o2 instanceof MyMapEntry)) {
                throw new IllegalArgumentException("Not a MapEntry");
            }
            Object otherKey = ((MyMapEntry<K,V>)o2).getKey();
            return ((Comparable)key).compareTo((Comparable)otherKey);
        }
    }
 
    /** The set of Map.Entry objects returned from entrySet(). */
    private class MyMapSet<MyMapEntry> extends AbstractSet<MyMapEntry> {
        List<MyMapEntry> list;
        MyMapSet(ArrayList<MyMapEntry> al) {
          list = al;
        }
        
        @Override
        public Iterator iterator() {
          return list.iterator();
        }
        
        @Override
        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.
    */
    @Override
    public java.util.Set entrySet() {
        if (keys.size() != values.size()) {
            throw new IllegalStateException("InternalError: keys and values out of sync");
        }
        ArrayList<MyMapEntry<K,V>> 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);
    }
    
    public static void main(String[] argv) {
        Map<String,String> map = new FixedSizeCache<String,String>(100);
 
        for (int i = 0; i<200; i++) {
            map.put(String.valueOf(i), String.valueOf(i));
        }
 
        for (String key : map.keySet()) {
            System.out.println("Key " + key + "; Value " + (String) map.get(key));
        }
    }
}

    @Override
    public boolean containsKey(Object key) {
        return keys.contains((K)key);
    }

    @Override
    public boolean containsKey(K key) {
        return keys.contains(key);
    }