Set Interface & Abstract Set

Data_Structure

Set & AbstractSet

1. Set Interface

        // In Set interface, it only come with the implementations in collection interface  
        public interface Set<E> extends Collection<E> {  
            int size();  
            boolean isEmpty();  
            boolean contains(Object o);  
            Iterator<E> iterator();  
            Object[] toArray();  
            <T> T[] toArray(T[] a);  
            boolean add(E e);  
            boolean remove(Object o);  
            boolean containsAll(Collection<?> c);  
            boolean addAll(Collection<? extends E> c);  
            boolean retainAll(Collection<?> c);  
            boolean removeAll(Collection<?> c);  
            void clear();  
            boolean equals(Object o);  
            int hashCode();  
        }

2. Abtract Set Interface

Implements some method for subclasses of Set

    public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {  
        protected AbstractSet() {
        }  
        /***** compare two object *******/  
        public boolean equals(Object o) {  
            if (o == this)// the same reference 
                return true;  
            if (!(o instanceof Set)) // type must be the same
                return false;  
            Collection c = (Collection) o; 
            if (c.size() != size()) // compare the size 
                return false;  
            try {  
                return containsAll(c);
                // compare the insided elements
            } catch (ClassCastException unused)   {  
                return false;  
            } catch (NullPointerException unused) {  
                return false;  
            }  
        }  
        /***** hashCode Implementation *****/
        public int hashCode() {  
            int h = 0;  
            Iterator<E> i = iterator();  
            while (i.hasNext()) {  
                E obj = i.next();  
                if (obj != null)  
                    h += obj.hashCode();  // ? why add
            }  
            return h;  
        }  
        /***** remove all elements in collection *****/  
        public boolean removeAll(Collection<?> c) {  
            boolean modified = false;  
             // choose the shorter one to remove element
            if (size() > c.size()) {
                for (Iterator<?> i = c.iterator(); i.hasNext(); )
                    modified |= remove(i.next());  // boolean operation '|'
            } else {  
                for (Iterator<?> i = iterator(); i.hasNext(); ) {  
                    if (c.contains(i.next())) {  
                        i.remove();  
                        modified = true;  
                    }  
                }  
            }  
            return modified;  
        }  
    }