Start of Tutorial > Start of Trail > Start of Lesson |
Search
Feedback Form |
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 aList
-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 aList
. 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 aSet
. 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
andCollections.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 aCollection
of values, when you don't want to provide any values at all.
Start of Tutorial > Start of Trail > Start of Lesson |
Search
Feedback Form |