Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.google.common.collect
Class ImmutableList<E>

    java.lang.Object
      com.google.common.collect.ImmutableCollection<E>
          com.google.common.collect.ImmutableList<E>

All Implemented Interfaces:
  Serializable, Iterable<E>, Collection<E>, List<E>, RandomAccess

    public abstract class ImmutableList<E>

extends ImmutableCollection<E>
implements List<E>, RandomAccess

A high-performance, immutable, random-access `List` implementation. Does not permit null elements.

Unlike `Collections.unmodifiableList(java.util.List)`, which is a view of a separate collection that can still change, an instance of `ImmutableList` contains its own private data and will never change. `ImmutableList` is convenient for `public static final` lists ("constant lists") and also lets you easily make a "defensive copy" of a list provided to your class by a caller.

Note: Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this type are guaranteed to be immutable.

Author:
  Kevin Bourrillion
See Also:
  `ImmutableMap`, `ImmutableSet`, Serialized Form

Nested Class Summary
`static class` | `ImmutableList.Builder<E>` A builder for creating immutable list instances, especially `public static final` lists ("constant lists").

Method Summary
`void` | `add(int index, E element)` Guaranteed to throw an exception and leave the list unmodified.
`boolean` | `addAll(int index, Collection<? extends E> newElements)` Guaranteed to throw an exception and leave the list unmodified.
`static
`<E> ImmutableList.Builder<E>`
` | `builder()` Returns a new builder.
`static
`<E> ImmutableList<E>`
` | `copyOf(Iterable<? extends E> elements)` Returns an immutable list containing the given elements, in order.
`static
`<E> ImmutableList<E>`
` | `copyOf(Iterator<? extends E> elements)` Returns an immutable list containing the given elements, in order.
`abstract int` | `indexOf(Object object)` Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
`abstract UnmodifiableIterator<E>` | `iterator()` Returns an unmodifiable iterator across the elements in this collection.
`abstract int` | `lastIndexOf(Object object)` Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
`static
`<E> ImmutableList<E>`
` | `of()` Returns the empty immutable list.
`static
`<E> ImmutableList<E>`
` | `of(E... elements)` Returns an immutable list containing the given elements, in order.
`static
`<E> ImmutableList<E>`
` | `of(E element)` Returns an immutable list containing a single element.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)` Identical to `of(Object[])`.
`static
`<E> ImmutableList<E>`
` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10, E e11)` Identical to `of(Object[])`.
`E` | `remove(int index)` Guaranteed to throw an exception and leave the list unmodified.
`E` | `set(int index, E element)` Guaranteed to throw an exception and leave the list unmodified.
`abstract ImmutableList<E>` | `subList(int fromIndex, int toIndex)` Returns an immutable list of the elements between the specified `fromIndex`, inclusive, and `toIndex`, exclusive.

Methods inherited from class com.google.common.collect.ImmutableCollection
`add, addAll, clear, contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toString`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface java.util.List
`add, addAll, clear, contains, containsAll, equals, get, hashCode, isEmpty, listIterator, listIterator, remove, removeAll, retainAll, size, toArray, toArray`

Method Detail

### of

    public static <E> ImmutableList<E> of()

  Returns the empty immutable list. This set behaves and performs comparably to `Collections.emptyList()`, and is preferable mainly for consistency and maintainability of your code.

### of

    public static <E> ImmutableList<E> of(E element)

  Returns an immutable list containing a single element. This list behaves and performs comparably to `Collections.singleton(T)`, but will not accept a null element. It is preferable mainly for consistency and maintainability of your code.

  Throws:
    `NullPointerException` - if `element` is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6,
                                          E e7)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6,
                                          E e7,
                                          E e8)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6,
                                          E e7,
                                          E e8,
                                          E e9)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6,
                                          E e7,
                                          E e8,
                                          E e9,
                                          E e10)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E e1,
                                          E e2,
                                          E e3,
                                          E e4,
                                          E e5,
                                          E e6,
                                          E e7,
                                          E e8,
                                          E e9,
                                          E e10,
                                          E e11)

  Identical to `of(Object[])`.

  Throws:
    `NullPointerException` - if any element is null

### of

    public static <E> ImmutableList<E> of(E... elements)

  Returns an immutable list containing the given elements, in order.

  Throws:
    `NullPointerException` - if any of `elements` is null

### copyOf

    public static <E> ImmutableList<E> copyOf(Iterable<? extends E> elements)

  Returns an immutable list containing the given elements, in order. This method iterates over `elements` at most once. Note that if `list` is a `List<String>`, then `ImmutableList.copyOf(list)` returns an `ImmutableList<String>` containing each of the strings in `list`, while ImmutableList.of(list)} returns an `ImmutableList<List<String>>` containing one element (the given list itself).

  Note: Despite what the method name suggests, if `elements` is an `ImmutableList`, no copy will actually be performed, and the given list itself will be returned.

  Throws:
    `NullPointerException` - if any of `elements` is null

### copyOf

    public static <E> ImmutableList<E> copyOf(Iterator<? extends E> elements)

  Returns an immutable list containing the given elements, in order.

  Throws:
    `NullPointerException` - if any of `elements` is null

### iterator

    public abstract UnmodifiableIterator<E> iterator()

  Description copied from class: `ImmutableCollection`
  Returns an unmodifiable iterator across the elements in this collection.

  Specified by:
    `iterator` in interface `Iterable<E>`
  Specified by:
    `iterator` in interface `Collection<E>`
  Specified by:
    `iterator` in interface `List<E>`
  Specified by:
    `iterator` in class `ImmutableCollection<E>`
  Returns:
    an `Iterator` over the elements in this collection

### indexOf

    public abstract int indexOf(@Nullable
                                Object object)

  Description copied from interface: `java.util.List`
  Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the lowest index `i` such that `(o==null ? get(i)==null : o.equals(get(i)))`, or -1 if there is no such index.

  Specified by:
    `indexOf` in interface `List<E>`
  Parameters:
    `object` - element to search for
  Returns:
    the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element

### lastIndexOf

    public abstract int lastIndexOf(@Nullable
                                    Object object)

  Description copied from interface: `java.util.List`
  Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the highest index `i` such that `(o==null ? get(i)==null : o.equals(get(i)))`, or -1 if there is no such index.

  Specified by:
    `lastIndexOf` in interface `List<E>`
  Parameters:
    `object` - element to search for
  Returns:
    the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element

### subList

    public abstract ImmutableList<E> subList(int fromIndex,
                                             int toIndex)

  Returns an immutable list of the elements between the specified `fromIndex`, inclusive, and `toIndex`, exclusive. (If `fromIndex` and `toIndex` are equal, the empty immutable list is returned.)

  Specified by:
    `subList` in interface `List<E>`
  Parameters:
    `fromIndex` - low endpoint (inclusive) of the subList
    `toIndex` - high endpoint (exclusive) of the subList
  Returns:
    a view of the specified range within this list

### addAll

    public final boolean addAll(int index,
                                Collection<? extends E> newElements)

  Guaranteed to throw an exception and leave the list unmodified.

  Specified by:
    `addAll` in interface `List<E>`
  Parameters:
    `index` - index at which to insert the first element from the specified collection
    `newElements` - collection containing elements to be added to this list
  Returns:
    `true` if this list changed as a result of the call
  Throws:
    `UnsupportedOperationException` - always

### set

    public final E set(int index,
                       E element)

  Guaranteed to throw an exception and leave the list unmodified.

  Specified by:
    `set` in interface `List<E>`
  Parameters:
    `index` - index of the element to replace
    `element` - element to be stored at the specified position
  Returns:
    the element previously at the specified position
  Throws:
    `UnsupportedOperationException` - always

### add

    public final void add(int index,
                          E element)

  Guaranteed to throw an exception and leave the list unmodified.

  Specified by:
    `add` in interface `List<E>`
  Parameters:
    `index` - index at which the specified element is to be inserted
    `element` - element to be inserted
  Throws:
    `UnsupportedOperationException` - always

### remove

    public final E remove(int index)

  Guaranteed to throw an exception and leave the list unmodified.

  Specified by:
    `remove` in interface `List<E>`
  Parameters:
    `index` - the index of the element to be removed
  Returns:
    the element previously at the specified position
  Throws:
    `UnsupportedOperationException` - always

### builder

    public static <E> ImmutableList.Builder<E> builder()

  Returns a new builder. The generated builder is equivalent to the builder created by the `ImmutableList.Builder` constructor.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD