## Uses of Interface
java.lang.Iterable

- Packages that use Iterable
  Package | Description
  --- | ---
  java.util |
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  org.netbeans.modules.openide.util |

- - ### Uses of Iterable in java.util

    Subinterfaces of Iterable in java.util
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Collection<E>` The root interface in the collection hierarchy.
    `interface` | `Deque<E>` A linear collection that supports element insertion and removal at both ends.
    `interface` | `List<E>` An ordered collection (also known as a sequence).
    `interface` | `NavigableSet<E>` A `SortedSet` extended with navigation methods reporting closest matches for given search targets.
    `interface` | `Queue<E>` A collection designed for holding elements prior to processing.
    `interface` | `Set<E>` A collection that contains no duplicate elements.
    `interface` | `SortedSet<E>` A `Set` that further provides a total ordering on its elements.

    Classes in java.util that implement Iterable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractCollection<E>` This class provides a skeletal implementation of the `Collection` interface, to minimize the effort required to implement this interface.
    `class` | `AbstractList<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).
    `class` | `AbstractQueue<E>` This class provides skeletal implementations of some `Queue` operations.
    `class` | `AbstractSequentialList<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).
    `class` | `AbstractSet<E>` This class provides a skeletal implementation of the `Set` interface to minimize the effort required to implement this interface.
    `class` | `ArrayDeque<E>` Resizable-array implementation of the `Deque` interface.
    `class` | `ArrayList<E>` Resizable-array implementation of the `List` interface.
    `class` | `EnumSet<E extends Enum<E>>` A specialized `Set` implementation for use with enum types.
    `class` | `HashSet<E>` This class implements the `Set` interface, backed by a hash table (actually a `HashMap` instance).
    `class` | `LinkedHashSet<E>` Hash table and linked list implementation of the `Set` interface, with predictable iteration order.
    `class` | `LinkedList<E>` Doubly-linked list implementation of the `List` and `Deque` interfaces.
    `class` | `PriorityQueue<E>` An unbounded priority queue based on a priority heap.
    `class` | `ServiceLoader<S>` A simple service-provider loading facility.
    `class` | `Stack<E>` The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
    `class` | `TreeSet<E>` A `NavigableSet` implementation based on a `TreeMap`.
    `class` | `Vector<E>` The `Vector` class implements a growable array of objects.

  - ### Uses of Iterable in java.util.concurrent

    Subinterfaces of Iterable in java.util.concurrent
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BlockingDeque<E>` A `Deque` that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.
    `interface` | `BlockingQueue<E>` A `Queue` that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
    `interface` | `TransferQueue<E>` A `BlockingQueue` in which producers may wait for consumers to receive elements.

    Classes in java.util.concurrent that implement Iterable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ArrayBlockingQueue<E>` A bounded blocking queue backed by an array.
    `class` | `ConcurrentLinkedDeque<E>` An unbounded concurrent deque based on linked nodes.
    `class` | `ConcurrentLinkedQueue<E>` An unbounded thread-safe queue based on linked nodes.
    `class` | `ConcurrentSkipListSet<E>` A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
    `class` | `CopyOnWriteArrayList<E>` A thread-safe variant of `ArrayList` in which all mutative operations (`add`, `set`, and so on) are implemented by making a fresh copy of the underlying array.
    `class` | `CopyOnWriteArraySet<E>` A `Set` that uses an internal `CopyOnWriteArrayList` for all of its operations.
    `class` | `DelayQueue<E extends Delayed>` An unbounded blocking queue of `Delayed` elements, in which an element can only be taken when its delay has expired.
    `class` | `LinkedBlockingDeque<E>` An optionally-bounded blocking deque based on linked nodes.
    `class` | `LinkedBlockingQueue<E>` An optionally-bounded blocking queue based on linked nodes.
    `class` | `LinkedTransferQueue<E>` An unbounded `TransferQueue` based on linked nodes.
    `class` | `PriorityBlockingQueue<E>` An unbounded blocking queue that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
    `class` | `SynchronousQueue<E>` A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.

  - ### Uses of Iterable in org.netbeans.modules.openide.util

    Methods in org.netbeans.modules.openide.util that return Iterable
    Modifier and Type | Method and Description
    --- | ---
    `Iterable<? extends Completion>` | ServiceProviderProcessor.`getCompletions(Element annotated, AnnotationMirror annotation, ExecutableElement attr, String userText)`

Copyright © 2025 API Design. All Rights Reserved.