HashOjbect之HashObjectMap(5)

private abstract class HashIterator implements Iterator<T> {
    BaseHashObject next; // next entry to return
        int expectedModCount; // For fast-fail
        int index; // current slot
        BaseHashObject current; // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
            BaseHashObject[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final T nextObject() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            BaseHashObject e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.getNext()) == null) {
            BaseHashObject[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        current = e;
            return (T)e;
        }

        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            BaseHashObject k = current;
            current = null;
            HashObjectMap.this.remove(k);
            expectedModCount = modCount;
        }

    }
   
    public Collection<T> objects() {
        return new Objects();
    }

    private final class Objects extends AbstractCollection<T> {
        public Iterator<T> iterator() {
            return newObjectIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(BaseHashObject o) {
            return containsObject(o);
        }
        public void clear() {
            HashObjectMap.this.clear();
        }
    }
    public void putAll(Collection<BaseHashObject> objects) {
        int numKeysToBeAdded = objects.size();
        if (numKeysToBeAdded == 0)
            return;

        /*
         * Expand the map if the map if the number of mappings to be added
         * is greater than or equal to threshold.  This is conservative; the
         * obvious condition is (m.size() + size) >= threshold, but this
         * condition could result in a map with twice the appropriate capacity,
         * if the keys to be added overlap with the keys already in this map.
         * By using the conservative calculation, we subject ourself
         * to at most one extra resize.
         */
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }
       
        for (Iterator<BaseHashObject> i = objects.iterator(); i.hasNext(); ) {
        put(i.next());
        }
    }
}