Documentation
The Java™ Tutorials
Download Ebooks
Download JDK
Search Java Tutorials
Hide TOC
Implementations
Set Implementations
List Implementations
Map Implementations
Queue Implementations
Deque Implementations
Wrapper Implementations
Convenience Implementations
Summary of Implementations
Questions and Exercises
Trail: Collections
Lesson: Implementations
« Previous • Trail • Next »

# 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 • Trail • Next »

Previous page: Wrapper Implementations
Next page: Summary of Implementations