挿入時制限付きコレクション（２）

挿入時制限付きコレクション（１）の続き、挿入時、applyメソッドの戻り値 boolean に沿って
コレクションの生成の実装は以下のとおり。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
/**
 * 挿入時制限付きコレクション生成.
 */
public final class LimitCollections{
   private LimitCollections(){}

   /**
    * 挿入時制限付きArrayList作成.
    * @param predicate ListPredicate実装インスタンスを指定
    * @return List<E>
    */
   public static <E> List<E> createArrayList(final ListPredicate<E> predicate){
      return new ArrayList<E>(){
         private static final long serialVersionUID = 1L;
         @Override
         public void add(int index,E e){
            if (predicate.apply(e)){
               super.add(index,e);
            }
         }
         @Override
         public boolean add(E e){
            return predicate.apply(e) ? super.add(e) : false;
         }
         @Override
         public boolean addAll(Collection<? extends E> c){
            boolean rtn = false;
            for(E e : c){
               rtn |= this.add(e);
            }
            return rtn;
         }
         @Override
         public boolean addAll(int index,Collection<? extends E> c){
            if (c.size() < 1) return false;
            int ix = index;
            for(E e : c){
               if (predicate.apply(e)){
                  this.add(ix,e);
                  ix++;
               }
            }
            return true;
         }
      };
   }
   /**
    * 挿入時制限付きHashMap作成.
    * @param predicate MapPredicate実装インスタンスを指定
    * @return Map<K,V>
    */
   public static <K,V> Map<K,V> createHashMap(final MapPredicate<K,V> predicate){
      return new HashMap<K,V>(){
         private static final long serialVersionUID = 1L;
         @Override
         public V put(K key,V value){
            if (predicate.apply(key,value)){
               return super.put(key,value);
            }
            return null;
         }
         @Override
         public void putAll(Map<? extends K,? extends V> m){
            for(K k : m.keySet()){
               V v = m.get(k);
               if (predicate.apply(k,v)){
                  super.put(k,v);
               }
            }
         }
      };
   }
   /**
    * 挿入時制限付きTreeSet作成.
    *   Comparator を指定しません。要素 E の java.lang.Comparable 実装に従います。
    * @param predicate TreePredicate実装インスタンスを指定
    * @return Set<E>
    */
   public static <E> Set<E> createTreeSet(final TreePredicate<E> predicate){
      return new TreeSet<E>(){
         private static final long serialVersionUID = 1L;
         @Override
         public boolean add(E e){
            return predicate.apply(e) ? super.add(e) : false;
         }
         @Override
         public boolean addAll(Collection<? extends E> c){
            boolean rtn = false;
            for(E e : c){
               rtn |= this.add(e);
            }
            return rtn;
         }
      };
   }
   /**
    * 挿入時制限付き Comparator が指定されたTreeSet作成.
    * @param predicate ComparePredicate実装インスタンスを指定
    * @return Set<E>
    */
   public static <E> Set<E> createTreeSet(final ComparePredicate<E> predicate){
     return new TreeSet<E>(new Comparator<E>(){
            @SuppressWarnings("unchecked")
            @Override
            public int compare(E e1,E e2){
               if (!predicate.apply(e1)) return 0;
               return predicate.compare(e1,e2);
            }
         }
      );
   }
   /**
    * 挿入時制限付きTreeMap作成.
    *   Comparator を指定しません。Key K の java.lang.Comparable 実装に従います。
    * @param predicate TreePredicate実装インスタンスを指定
    * @return Map<K,V>
    */
   public static <K,V> Map<K,V> createTreeMap(final TreePredicate<K> predicate){
      return new TreeMap<K,V>(new Comparator<K>(){
            @SuppressWarnings("unchecked")
            @Override
            public int compare(K k1,K k2){
               if (!predicate.apply(k1)) return 0;
               return *1 return 0;
               return predicate.compare(k1,k2);
            }
         }
      );
   }
}

*1:Comparable)k1).compareTo(k2);
            }
         }
      );
   }
   /**
    * 挿入時制限付き Comparator が指定されたTreeMap作成.
    * @param predicate ComparePredicate実装インスタンスを指定
    * @return Map<K,V>
    */
   public static <K,V> Map<K,V> createTreeMap(final ComparePredicate<K> predicate){
      return new TreeMap<K,V>(new Comparator<K>(){
            @SuppressWarnings("unchecked")
            @Override
            public int compare(K k1,K k2){
               if (!predicate.apply(k1