java.util
Class AbstractCollection<E>

java.lang.Object
  java.util.AbstractCollection<E>

All Implemented Interfaces:

Iterable<E>, Collection<E>

Direct Known Subclasses:

AbstractList, AbstractQueue, AbstractSet

---

public abstract class AbstractCollection<E>extends Objectimplements Collection<E>

This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.

To implement an unmodifiable collection, the programmer needs only to extend this class and provide implementations for the iterator and size methods. (The iterator returned by the iterator method must implement hasNext and next.)

To implement a modifiable collection, the programmer must additionally override this class's add method (which otherwise throws an UnsupportedOperationException), and the iterator returned by the iterator method must additionally implement its remove method.

The programmer should generally provide a void (no argument) and Collection constructor, as per the recommendation in the Collection interface specification.

The documentation for each non-abstract methods in this class describes its implementation in detail. Each of these methods may be overridden if the collection being implemented admits a more efficient implementation.

This class is a member of the Java Collections Framework.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

java.util
Class AbstractList<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>

All Implemented Interfaces:

Iterable<E>, Collection<E>, List<E>

Direct Known Subclasses:

AbstractSequentialList, ArrayList, Vector

---

public abstract class AbstractList<E>extends AbstractCollection<E>implements List<E>

This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "random access" data store (such as an array). For sequential access data (such as a linked list), AbstractSequentialList should be used in preference to this class.

To implement an unmodifiable list, the programmer needs only to extend this class and provide implementations for the get(int index) and size() methods.

To implement a modifiable list, the programmer must additionally override the set(int index, E element) method (which otherwise throws an UnsupportedOperationException. If the list is variable-size the programmer must additionally override the add(int index, E element) and remove(int index) methods.

The programmer should generally provide a void (no argument) and collection constructor, as per the recommendation in the Collection interface specification.

Unlike the other abstract collection implementations, the programmer does not have to provide an iterator implementation; the iterator and list iterator are implemented by this class, on top the "random access" methods: get(int index), set(int index, Object element), set(int index, Object element), add(int index, Object element) and remove(int index).

The documentation for each non-abstract methods in this class describes its implementation in detail. Each of these methods may be overridden if the collection being implemented admits a more efficient implementation.

This class is a member of the Java Collections Framework.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

java.util
Class AbstractMap<K,V>

java.lang.Object
  java.util.AbstractMap<K,V>

All Implemented Interfaces:

Map<K,V>

Direct Known Subclasses:

ConcurrentHashMap, EnumMap, HashMap, IdentityHashMap, TreeMap, WeakHashMap

---

public abstract class AbstractMap<K,V>extends Objectimplements Map<K,V>

This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.

To implement an unmodifiable map, the programmer needs only to extend this class and provide an implementation for the entrySet method, which returns a set-view of the map's mappings. Typically, the returned set will, in turn, be implemented atop AbstractSet. This set should not support the add or remove methods, and its iterator should not support the remove method.

To implement a modifiable map, the programmer must additionally override this class's put method (which otherwise throws an UnsupportedOperationException), and the iterator returned by entrySet().iterator() must additionally implement its remove method.

The programmer should generally provide a void (no argument) and map constructor, as per the recommendation in the Map interface specification.

The documentation for each non-abstract methods in this class describes its implementation in detail. Each of these methods may be overridden if the map being implemented admits a more efficient implementation.

This class is a member of the Java Collections Framework.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

java.util
Class AbstractSequentialList<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.AbstractSequentialList<E>

All Implemented Interfaces:

Iterable<E>, Collection<E>, List<E>

Direct Known Subclasses:

LinkedList

---

public abstract class AbstractSequentialList<E>extends AbstractList<E>

This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "sequential access" data store (such as a linked list). For random access data (such as an array), AbstractList should be used in preference to this class.

This class is the opposite of the AbstractList class in the sense that it implements the "random access" methods (get(int index), set(int index, Object element), set(int index, Object element), add(int index, Object element) and remove(int index)) on top of the list's list iterator, instead of the other way around.

To implement a list the programmer needs only to extend this class and provide implementations for the listIterator and size methods. For an unmodifiable list, the programmer need only implement the list iterator's hasNext, next, hasPrevious, previous and index methods.

For a modifiable list the programmer should additionally implement the list iterator's set method. For a variable-size list the programmer should additionally implement the list iterator's remove and add methods.

The programmer should generally provide a void (no argument) and collection constructor, as per the recommendation in the Collection interface specification.

This class is a member of the Java Collections Framework.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

java.util
Class AbstractSet<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractSet<E>

All Implemented Interfaces:

Iterable<E>, Collection<E>, Set<E>

Direct Known Subclasses:

CopyOnWriteArraySet, EnumSet, HashSet, TreeSet

---

public abstract class AbstractSet<E>extends AbstractCollection<E>implements Set<E>

This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface.

The process of implementing a set by extending this class is identical to that of implementing a Collection by extending AbstractCollection, except that all of the methods and constructors in subclasses of this class must obey the additional constraints imposed by the Set interface (for instance, the add method must not permit addition of multiple instances of an object to a set).

Note that this class does not override any of the implementations from the AbstractCollection class. It merely adds implementations for equals and hashCode.

This class is a member of the Java Collections Framework.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

java.lang
Interface Iterable<T>

All Known Subinterfaces:

BeanContext, BeanContextServices, BlockingQueue<E>, Collection<E>, List<E>, Queue<E>, Set<E>, SortedSet<E>

All Known Implementing Classes:

AbstractCollection, AbstractList, AbstractQueue, AbstractSequentialList, AbstractSet, ArrayBlockingQueue, ArrayList, AttributeList, BeanContextServicesSupport, BeanContextSupport, ConcurrentLinkedQueue, CopyOnWriteArrayList, CopyOnWriteArraySet, DelayQueue, EnumSet, HashSet, JobStateReasons, LinkedBlockingQueue, LinkedHashSet, LinkedList, PriorityBlockingQueue, PriorityQueue, RoleList, RoleUnresolvedList, Stack, SynchronousQueue, TreeSet, Vector

---

public interface Iterable<T>

Implementing this interface allows an object to be the target of the "foreach" statement.