Compact syntax for instantiating an initializing collection

Question

I'm looking for a compact syntax for instantiating a collection and adding a few items to it. I currently use this syntax:

Collection<String> collection = 
    new ArrayList<String>(Arrays.asList(new String[] { "1", "2", "3" }));

I seem to recall that there's a more compact way of doing this that uses an anonymous subclass of ArrayList, then adds the items in the subclass' constructor. However, I can't seem to remember the exact syntax.

score 47 · Accepted Answer · answered Sep 22 '10 at 13:08

47

http://blog.firdau.si/2010/07/01/java-tips-initializing-collection/

List<String> s = Arrays.asList("1", "2");

answered Sep 22 '10 at 13:08

nanda

24,458
13
71
90

6

Only works like that if you don't need the result to be extendable, though. – Michael Borgwardt Sep 22 '10 at 13:21

score 13 · Answer 2 · answered Sep 22 '10 at 13:06

I guess you're thinking about

collection = new ArrayList<String>() { // anonymous subclass
     { // anonymous initializer
         add("1");
         add("2");
         add("3");
     }
}

which, one comapcted, gives

collection = new ArrayList<String>() {{ add("1"); add("2"); add("3"); }}

FUGLY, to say the least. However, there is a variant to the Arrays.asList method : Arrays.asList(T...a) which provides comapcity and readability. As an example, it gives the following line of code :

collection = new ArrayList<String>(Arrays.asList("1", "2", "3")); // yep, this one is the shorter

And notice you don't create an anonymous subclass of ArrayList of dubious use.

score 5 · Answer 3 · answered Sep 22 '10 at 13:05

5

Maybe that was

Collection<String> collection = new ArrayList<String>() {{
    add("foo");
    add("bar");
}};

Also known as double-bracket initialization.

answered Sep 22 '10 at 13:05

Vivien Barousse

20,555
2
63
64

score 4 · Answer 4 · answered Jun 07 '22 at 12:01

4

From JDK9 you can use factory methods:

List<String> list = List.of("foo", "bar", "baz");
Set<String> set = Set.of("foo", "bar", "baz");

answered Jun 07 '22 at 12:01

Alex Burtsev

12,418
8
60
87

These are great methods but cannot be used for mutable collections. – Ellen Spertus Dec 26 '22 at 17:46

Haroldo_OK · Answer 5 · 2016-07-05T14:18:31.903

3

You could create an utility function:

@SafeVarargs
public static <T> List<T> listOf(T ... values) {
    return new ArrayList<T>(Arrays.asList(values));
}

So you could call it like:

collection = MyUtils.listOf("1", "2", "3");

That way, you can populate a list very easily, and still keep it mutable.

edited Jul 05 '16 at 14:18

answered Jul 05 '16 at 14:12

Haroldo_OK

6,612
3
43
80

score 0 · Answer 6 · edited May 23 '17 at 12:17

0

See Initialization of an ArrayList in one line

edited May 23 '17 at 12:17

Community

1
1

answered Sep 22 '10 at 13:06

dogbane

266,786
75
396
414

score 0 · Answer 7 · answered Sep 22 '10 at 13:47

Maybe it's just me but I dont see the point of complicating things, purely in pursuit of writing shorter/faster code. Given the choice of typing marginally fewer lines of code and far easier debugging/revising I am pretty sure I'd choose the second option.

So unless there is a particular reason to push for keeping this short, I'd say stick to Ockham's razor, and given a number of solutions to a problem, go with the simplest one. That way when something does go wrong (which Murphy's law clearly dictates it will) you'll have a much easier time to track it. :)

Compact syntax for instantiating an initializing collection

7 Answers7