Using Java List when array is enough

Is it advisable to use Java Collections List in the cases when you know the size of the list before hand and you can also use array there? Are there any performance drawbacks?

Can a list be initialised with elements in a single statement like an array (list of开发者_开发问答 all elements separated by commas) ?

Is it advisable to use Java Collections List in the cases when you know the size of the list before hand and you can also use array there ?

In some (probably most) circumstances yes, it is definitely advisable to use collections anyway, in some circumstances it is not advisable.

On the pro side:

• If you use an List instead of an array, your code can use methods like contains, insert, remove and so on.
• A lot of library classes expect collection-typed arguments.
• You don't need to worry that the next version of the code may require a more dynamically sized array ... which would make an initial array-based approach a liability.

On the con side:

• Collections are a bit slower, and more so if the base type of your array is a primitive type.
• Collections do take more memory, especially if the base type of your array is a primitive type.

But performance is rarely a critical issue, and in many cases the performance difference is not relevant to the big picture.

And in practice, there is often a cost in performance and/or code complexity involved in working out what the array's size should be. (Consider the hypothetical case where you used a char[] to hold the concatenation of a series. You can work out how big the array needs to be; e.g. by adding up the component string sizes. But it is messy!)

Collections/lists are more flexible and provide more utility methods. For most situations, any performance overhead is negligible.

And for this single statement initialization, use:

Arrays.asList(yourArray);

From the docs:

Returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray. The returned list is serializable and implements RandomAccess.

My guess is that this is the most performance-wise way to convert to a list, but I may be wrong.

1) a Collection is the most basic type and only implies there is a collection of objects. If there is no order or duplication use java.util.Set, if there is possible duplication and ordering use java.util.List, is there is ordering but no duplication use java.util.SortedSet

2) Curly brackets to instantiate an Array, Arrays.asList() plus generics for the type inference

List<String> myStrings = Arrays.asList(new String[]{"one", "two", "three"});

There is also a trick using anonymous types but personally I'm not a big fan:

List<String> myStrings = new ArrayList<String>(){
// this is the inside of an anonymouse class
{
    // this is the inside of an instance block in the anonymous class
    this.add("one");
    this.add("two");
    this.add("three");
}};

Yes, it is advisable.

Some of the various list constructors (like ArrayList) even take arguments so you can "pre-allocate" sufficient backing storage, alleviating the need for the list to "grow" to the proper size as you add elements.

There are different things to consider: Is the type of the array known? Who accesses the array? There are several issues with arrays, e.g.:

• you can not create generic arrays
• arrays are covariant: if A extends B -> A[] extends B[], which can lead to ArrayStoreExceptions
• you cannot make the fields of an array immutable
• ...

Also see, item 25 "Prefer lists to arrays" of the Effective Java book.

That said, sometimes arrays are convenient, e.g. the new Object... parameter syntax.

How can a list be initialised with elements in a single statement like an array = {list of all elements separated by commas} ?

Arrays.asList(): http://download.oracle.com/javase/6/docs/api/java/util/Arrays.html#asList%28T...%29

Is it advisable to use Java Collections List in the cases when you know the size of the list before hand and you can also use array there ? Performance drawbacks ???

If an array is enough, then use an array. Just to keep things simple. You may even get a slightly better performance out of it. Keep in mind that if you...

• ever need to pass the resulting array to a method that takes a Collection, or
• if you ever need to work with List-methods such as .contains, .lastIndexOf, or what not, or
• if you need to use Collections methods, such as reverse...

then may just as well go for the Collection/List classes from the beginning.

How can a list be initialised with elements in a single statement like an array = {list of all elements separated by commas} ?

You can do

List<String> list = Arrays.asList("foo", "bar");

or

List<String> arrayList = new ArrayList<String>(Arrays.asList("foo", "bar"));

or

List<String> list = new ArrayList<String>() {{ add("foo"); add("bar"); }};

Is it advisable to use Java Collections List in the cases when you know the size of the list before hand and you can also use array there ? Performance drawbacks ?

It can be perfectly acceptable to use a List instead of an array, even if you know the size before hand.

How can a list be initialised with elements in a single statement like an array = {list of all elements separated by commas} ?

See Arrays.asList().