是否存在不允许空值的基本Java Set实现?




7 Answers

我会说使用组合而不是继承...它可能更多的工作,但面对Sun可能对集合框架所做的任何更改,它会更稳定。

public class NoNullSet<E> implements Set<E>
{
   /** The set that is wrapped. */
   final private Set<E> wrappedSet = new HashSet<E>();

   public boolean add(E e)
   {
     if (e == null) 
       throw new IllegalArgumentException("You cannot add null to a NoNullSet");
     return wrappedSet.add(e);
   }

   public boolean addAll(Collection<? extends E> c)
   {
     for (E e : c) add(e);
   }

   public void clear()
   { wrappedSet.clear(); }

   public boolean contains(Object o)
   { return wrappedSet.contains(o); }

   ... wrap the rest of them ...
}

编辑:另请注意,此实现不依赖于addAll调用add(这是一个实现细节,不应该使用,因为它不能保证在所有Java版本中都保持为true)。

编辑:添加了更多描述性错误消息。

编辑:使它如此清晰()不返回任何东西。

编辑:这样就可以添加(E e)。

编辑:抛出IllegalArgumentException而不是NullPointerException。

java api null set

Java Set接口的API指出:

例如,某些实现禁止null元素,而某些实现对其元素的类型有限制

我正在寻找一个不需要排序的基本Set实现(如ArrayListList接口提供的)并且不允许nullTreeSetHashSetLinkedHashSet都允许null元素。 另外,TreeSet要求元素实现Comparable

似乎目前没有这样的基本Set 。 有谁知道为什么? 或者,如果确实存在,我可以找到它?

[编辑]:我不想允许null ,因为稍后在代码中我的类将迭代集合中的所有元素并调用特定方法。 (我实际上正在使用HashSet<MyRandomObject >)。 我宁愿快速失败而不是失败,或者由于集合中的null而意外地产生一些奇怪的行为。




您可以通过继承适当的现有类来轻松编写自己的类,并覆盖所有相关方法,以便您不能添加null元素。




这是一种失败的通用方法 - 您提供了一个Filter实现,可以限制以您想要的方式添加的内容。 看一下java.util.Collections的源代码,了解有关包装的想法(我认为我对FilteredCollection类的实现是正确的......但它没有经过扩展测试)。 最后有一个示例程序显示用法。

public interface Filter<T>
{
    boolean accept(T item);
}

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;


public class FilteredCollections
{
    private FilteredCollections()
    {
    }

    public static <T> Collection<T> filteredCollection(final Collection<T> c,
                                                       final Filter<T>     filter)
    {
        return (new FilteredCollection<T>(c, filter));
    }

    private static class FilteredCollection<E>
        implements Collection<E>,
                   Serializable
    {
        private final Collection<E> wrapped;
        private final Filter<E> filter;

        FilteredCollection(final Collection<E> collection, final Filter<E> f)
        {
            if(collection == null)
            {
                throw new IllegalArgumentException("collection cannot be null");
            }

            if(f == null)
            {
                throw new IllegalArgumentException("f cannot be null");
            }

            wrapped = collection;
            filter  = f;
        }

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

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

        public boolean contains(final Object o)
        {
            return (wrapped.contains(o));
        }

        public Iterator<E> iterator()
        {
            return new Iterator<E>()
            {
                final Iterator<? extends E> i = wrapped.iterator();

                public boolean hasNext()
                {
                    return (i.hasNext());
                }

                public E next()
                {
                    return (i.next());
                }

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

        public Object[] toArray() 
        {
            return (wrapped.toArray());
        }

        public <T> T[] toArray(final T[] a)
        {
            return (wrapped.toArray(a));
        }

        public boolean add(final E e)
        {
            final boolean ret;

            if(filter.accept(e))
            {
                ret = wrapped.add(e);
            }
            else
            {
                // you could throw an exception instead if you want - 
               // IllegalArgumentException is what I would suggest
                ret = false;
            }

            return (ret);
        }

        public boolean remove(final Object o)
        {
            return (wrapped.remove(o));
        }

        public boolean containsAll(final Collection<?> c)
        {
            return (wrapped.containsAll(c));
        }

        public boolean addAll(final Collection<? extends E> c)
        {
            final E[] a;
            boolean   result;

            a = (E[])wrapped.toArray();

            result = false;

            for(final E e : a)
            {
                result |= wrapped.add(e);
            }

            return result;
        }

        public boolean removeAll(final Collection<?> c)
        {
            return (wrapped.removeAll(c));
        }

        public boolean retainAll(final Collection<?> c)
        {
            return (wrapped.retainAll(c));
        }

        public void clear() 
        {
            wrapped.clear();
        }

        public String toString()
        {
            return (wrapped.toString());
        }
    }
}


import java.util.ArrayList;
import java.util.Collection;


public class Main
{
    private static class NullFilter<T>
        implements Filter<T>
    {
        public boolean accept(final T item)
        {
            return (item != null);
        }
    }

    public static void main(final String[] argv) 
    {
        final Collection<String> strings;

        strings = FilteredCollections.filteredCollection(new ArrayList<String>(), 
                                                         new NullFilter<String>());
        strings.add("hello");
        strings.add(null);
        strings.add("world");

        if(strings.size() != 2)
        {
            System.err.println("ERROR: strings.size() == " + strings.size());
        }

        System.out.println(strings);
    }
}






顺便说一句,如果你要求一个不允许空值的Map实现,那么旧的java.util.Hashtable就不会。




对我来说,我没有找到一个,所以我overrode the add function

Collection<String> errors = new HashSet<String>() {
    @Override
    public boolean add(String s) {
        return StringUtil.hasContent(s) && super.add(s);//we don't want add null and we allow HashSet.add(null)
    }
};



Hashtable不允许空值......




Related