![]() ![]() ![]() |
Start of Tutorial > Start of Trail > Start of Lesson | Search |
This section describes several mini-implementations that can be more convenient and more efficient then the general purpose implementations when you don't need the full power of a general purpose implementation. All of the implementations in this section are made available via static factory methods or exported constants, rather than public classes.
TheArrays.asList
method returns a
List
-view of its array argument. Changes to theList
write through to the array and vice-versa. The size of the collection is that of the array, and cannot be changed. If theadd
orremove
method is called on theList
, anUnsupportedOperationException
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 aList
. However, this implementation has another use. If you need a fixed-sizeList
, it's more efficient than any general-purposeList
implementation. Here's the idiom:Note that a reference to the backing array is not retained.List l = Arrays.asList(new Object[size]);
Occasionally you'll need an immutableList
consisting of multiple copies of the same element. TheCollections.nCopies
method returns such a
List
. This implementation has two main uses. The first is to initialize a newly createdList
. For example, suppose you want anArrayList
initially consisting of 1000 null elements. The following incantation does the trick:Of course, the initial value of each element needn't be null. The second main use is to grow an existingList l = new ArrayList(Collections.nCopies(1000, null));List
. For example, suppose you want to add 69 copies of the stringfruit bat
to the end of aList
. It' not clear why you'd want to do such a thing, but let's just suppose you did. Here's how you'd do it:By using the form oflovablePets.addAll(Collections.nCopies(69, "fruit bat"));addAll
that takes an index as well as aCollection
, you can add the new elements to the middle of aList
instead of at the end.
Sometimes you'll need an immutable singletonSet
, which consists of a single, specified element. TheCollections.singleton
method returns such a
Set
. One use of this implementation is this idiom to remove all occurrences of a specified element from aCollection
:There's a related idiom to remove from ac.removeAll(Collections.singleton(e));Map
all elements that map to a specified value. For example, suppose you have aMap
,profession
, that maps people to their line of work. Suppose you want to eliminate all of the lawyers. This one-liner will do the deed:One more use of this implementation is to provide a single input value to a method that is written to accept aprofession.values().removeAll(Collections.singleton(LAWYER));Collection
of values.
TheCollections
class provides two constants, representing the emptySet
and the emptyList
,Collections.EMPTY_SET
and
Collections.EMPTY_LIST
. It's not clear that these constants really qualify as implementations, but this lesson seemed like as good a place to mention them as any. 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.
![]() ![]() ![]() |
Start of Tutorial > Start of Trail > Start of Lesson | Search |