Esiste un'implementazione di base di Java Set che non consente valori nulli?

Question

L'API per gli stati di interfaccia Java Set:

Per esempio, alcune implementazioni vietare null elementi e alcuni hanno restrizioni sui tipi di loro elementi

Cerco un'implementazione di base Set che non richiede l'ordinazione (come ArrayList fornisce l'interfaccia List) e ciò non consente null. TreeSet, HashSet e LinkedHashSet consentono tutti elementi null. Inoltre, TreeSet ha il requisito che gli elementi implementino Comparable.

Sembra che al momento non esista uno standard di base Set. Qualcuno sa perché? O se esiste uno dove posso trovarlo?

[Modifica]: Non voglio consentire null s, perché più avanti nel codice la mia classe eseguirà un'iterazione su tutti gli elementi nella raccolta e chiamerà un metodo specifico. (In realtà sto usando HashSet<MyRandomObject>). Preferirei fallire più rapidamente che fallire successivamente o incidentalmente incorrere in qualche comportamento bizzarro a causa di un null nel set.

Answer 1

Meglio di estendere una particolare implementazione, è possibile scrivere facilmente un'implementazione proxy di Set che controlla null s. Questo analogo a Collections.checkedSet. Oltre ad essere applicabile a qualsiasi implementazione, puoi anche essere sicuro di aver ignorato tutti i metodi applicabili. Sono stati scoperti molti difetti estendendo le raccolte di calcestruzzi che poi hanno aggiunto metodi aggiuntivi nelle versioni successive.

Answer 2

Si potrebbe facilmente scrivere il proprio, per sottoclasse una classe esistente appropriata e sovrascrivendo tutti i metodi importanti in modo che non possibile aggiungere null elementi.

Answer 3

Non sono sicuro di un tipo che sia vero. Ma potresti non ereditare da una raccolta o HashTable di tua scelta e sovrascrivere il metodo Aggiungi, generando un'eccezione se l'elemento è nullo?

Answer 4

Perché non si desidera consentire null?

Si desidera generare un'eccezione se null viene aggiunto al set? Se è così, basta fare qualcosa di simile:

private Set<Object> mySet = new HashSet<Object>() { 
    @Override 
    public boolean add(Object e) { 
     if (e == null) 
      throw new IllegalArgumentException("null"); // or NPE 
     // or, of course, you could just return false 
     return super.add(e); 
    } 
}; 

HashSet 's addAll() chiamate add() ripetutamente, quindi questo è l'unico metodo che avrebbe dovuto ignorare.

Answer 5

Direi usare la composizione anziché l'ereditarietà ... potrebbe essere più lavoro ma sarà più stabile di fronte alle eventuali modifiche apportate da Sun al Framework delle raccolte.

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 ... 
} 

Edit: Si noti inoltre che questa implementazione non dipende addAll chiamare add (che è un dettaglio di implementazione e non deve essere utilizzato in quanto non può essere garantito per rimanere fedele in tutto Java release).

Modifica: Aggiunto più messaggio di errore descrittivo.

Modifica: Realizzato in modo chiaro() non restituisce nulla.

Modifica: Fatto questo è aggiungere (E e).

Edit: Lanci IllegalArgumentException invece di NullPointerException.

Answer 6

Si potrebbe anche voler verificare Google Collections. Sono più fobici, credo.

Answer 7

È possibile utilizzare le raccolte di apache e il relativo PredicatedCollection class e impostare il predicato in modo che non consenta valori nulli. Otterrete delle eccezioni se qualcuno invierà valori nulli.

Answer 8

Questo è un modo generico di failry per farlo: si fornisce un'implementazione del filtro che può limitare ciò che viene aggiunto nel modo desiderato. Dai un'occhiata al codice sorgente di java.util.Collections per le idee sul wrapping (penso che la mia implementazione della classe FilteredCollection sia corretta ... ma non è stata testata estensivamente). C'è un programma di esempio alla fine che mostra l'utilizzo.

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); 
    } 
} 

Answer 9

BTW, se avessi chiesto un implementazione Map che non consente i null, il vecchio java.util.Hashtable non lo fa.

Answer 10

Hashtable non consente valori nulli ......

Answer 11

Yes - nella documentazione per com.google.common.collect.ImmutableSet:

A ad alte prestazioni, Set immutabile affidabili, ordine di iterazione specificato dall'utente . Non consente elementi null.

Answer 12

In questo particolare domanda/esempio sicuramente se si dispone di un HashSet<MyRandomObject> mySet chiamata mySet.remove(null) prima di iniziare l'iterazione su tutti gli elementi che hai citato?

Answer 13

Non esiste un'implementazione di set proprietario di base che ignori o limiti null! C'è EnumSet, ma quello è il sarto per il contenimento dei tipi di enum.

Tuttavia, la creazione di una propria implementazione può essere evitato, se si utilizza Guava o Commons Collections:

1. Guava Soluzione:

Set noNulls = Constraints.constrainedSet(new HashSet(), Constraints.notNull()); 

2.Commons Collezioni:

Set noNulls = new HashSet(); 
CollectionUtils.addIgnoreNull(noNulls, object); 

Answer 14

per me, non ho trovato uno, così ho 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) 
    } 
};