Keith Devens .com

Tuesday, October 11, 2005

Arrays.asList()

Arrays.asList is a feature every Java developer should know about. It'll save you from writing code like:

List<Foo> foolist = new ArrayList<Foo>();

foolist.add(foo);

return foolist;

or maybe

if(map.containsKey(id)){

    map.get(id).add(foo);

}else{

    List<Foo> foolist = new ArrayList<Foo>();

    foolist.add(foo);

    map.put(id, foo);

}

and allow you to write code like:

return Arrays.asList(foo);

and

if(map.containsKey(id))

    map.get(id).add(foo);

else

    map.put(id, Arrays.asList(foo));

Update: I didn't notice that Arrays.asList returns a List that can't be added too. When you try to call add on the returned List, you'll get an UnsupportedOperationException in AbstractList.add. That seemed lame to me, but the List interface does say that add is an "optional operation". For the lists to be mutable, the above code snippets have to be changed to something like:

return new ArrayList<Foo>(Arrays.asList(foo));

and

if(map.containsKey(id))

    map.get(id).add(foo);

else

    map.put(id, new ArrayList<Foo>(Arrays.asList(foo)));

Update: Of course, the more pathalogical example of what Arrays.asList saves you from is:

List<Foo> foolist = new ArrayList<Foo>(fooarray.length);

for(int i=0,n=fooarray.length; i<n; i++){

    foolist.add(fooarray[i]);

}

List<Foo> foolist = new ArrayList<Foo>(fooarray.length);

for(Foo f : fooarray){

    foolist.add(f);

}

because that becomes just:

List<Foo> foolist = Arrays.asList(fooarray);

Permalink | 3 Comments | Tags: Programming | id 7439

18:08 (utc-5)
edited: 2005-10-12 12:50 (utc-5)

Comments

You might also chose to mention the Collections class with static methods such as addAll(...), the helpful public static members EMPTY_LIST, et al, and most on point for your code example, singletonList(T). Thus:

Arrays.asList(foo);

Becomes:

Collections.singletonList(foo);

Which to me seems to document better the intention of the code. However, the returned list is indeed a singleton: you cannot later modify it, so that may violate the contract of the surrounding method for the code fragment.

∴ B. K. Oxley (binkley) | 12-Oct-2005 7:48am est | http://binkley.blogspot.com | #8453

I usually have the following utility to create lists

public abstract class Utils {

    public static <T> List<T> list(T... elements) {

        final List<T> result = new ArrayList<T>();

        for (T element : elements) {

            result.add(element);

        }

        return result;

    }

}

Usage:

final List<String> coffees = Utils.list("mocha", latte");

Cool, thanks. I wonder how much more efficient that is, if any, than the above:

new ArrayList<Foo>(Arrays.asList(foo));

Also, may I recommend a small change:

final List<T> result = new ArrayList<T>(elements.length);

for obvious reasons.

∴ Keith | 14-Oct-2005 1:52am est | http://keithdevens.com/ | #8458

Feel free to post a comment below. Please see my comment policy.

Formatting Rules (No HTML):

**bold**, *italic*, _underlined_, --strikeout--
"text"="url" creates a link, and URLs are auto-highlighted
Blockquote: Like e-mail, begin paragraph with > (greater-than sign)
Lists: begin paragraph with *,-, or + (unordered), or # (ordered)
Code block: ?!code:language=perl|php|sql|javascript|etc.{\n}...{\n}?!/code

December 2008

Sun

Mon

Tue

Wed

Thu

Fri

Sat

Tuesday, October 11, 2005

Arrays.asList()

Comments

Recent comments