Download the JDK
Search the Tutorials
Hide the TOC
Trail: Collections
Lesson: Implementations
Implementations
Set Implementations
List Implementations
Map Implementations
Queue Implementations
Wrapper Implementations
Convenience Implementations
Summary of Implementations
Questions and Exercises
Home Page > Collections > Implementations
Convenience Implementations

> This section describes several mini-implementations that can be more convenient and more efficient than general-purpose implementations when you don't need their full power. All the implementations in this section are made available via static factory methods rather than `public` classes.

### List View of an Array

> The `Arrays.asList` method returns a `List` view of its array argument. Changes to the `List` write through to the array and vice versa. The size of the collection is that of the array and cannot be changed. If the `add` or the `remove` method is called on the `List`, an `UnsupportedOperationException` will result.

> The normal use of this implementation is as a bridge between array-based and collection-based APIs. It allows you to pass an array to a method expecting a `Collection` or a `List`. However, this implementation also has another use. If you need a fixed-size `List`, it's more efficient than any general-purpose `List` implementation. This is the idiom.

> >     List<String> list = Arrays.asList(new String[size]);

> Note that a reference to the backing array is not retained.

### Immutable Multiple-Copy List

> Occasionally you'll need an immutable `List` consisting of multiple copies of the same element. The `Collections.nCopies` method returns such a list. This implementation has two main uses. The first is to initialize a newly created `List`; for example, suppose you want an `ArrayList` initially consisting of 1,000 `null` elements. The following incantation does the trick.

> >     List<Type> list =
> >         new ArrayList<Type>(Collections.nCopies(1000, (Type)null);

> Of course, the initial value of each element need not be `null`. The second main use is to grow an existing `List`. For example, suppose you want to add 69 copies of the string `"fruit bat"` to the end of a `List<String>`. It's not clear why you'd want to do such a thing, but let's just suppose you did. The following is how you'd do it.

> >     lovablePets.addAll(Collections.nCopies(69, "fruit bat"));

> By using the form of `addAll` that takes both an index and a `Collection`, you can add the new elements to the middle of a `List` instead of to the end of it.

### Immutable Singleton Set

> Sometimes you'll need an immutable singleton `Set`, which consists of a single, specified element. The `Collections.singleton` method returns such a `Set`. One use of this implementation is to remove all occurrences of a specified element from a `Collection`.

> >     c.removeAll(Collections.singleton(e));

> A related idiom removes all elements that map to a specified value from a `Map`. For example, suppose you have a `Map` — `job` — that maps people to their line of work and suppose you want to eliminate all the lawyers. The following one-liner will do the deed.

> >     job.values().removeAll(Collections.singleton(LAWYER));

> One more use of this implementation is to provide a single input value to a method that is written to accept a collection of values.

### Empty Set, List, and Map Constants

> The `Collections` class provides methods to return the empty `Set`, `List`, and `Map` — `emptySet`, `emptyList`, and `emptyMap`. The main use of these constants is as input to methods that take a `Collection` of values when you don't want to provide any values at all, as in this example.

> >     tourist.declarePurchases(Collections.emptySet());

Previous page: Wrapper Implementations
Next page: Summary of Implementations