CODEWITHSUNDEEP
javagenerics
Sinan
Sinan

Reputation: 463

Java generic collections

I start learning the Java generic collection using Deitel Harvey book - but I am facing a difficulty understanding the three line of codes below - Do all of them perform the same operation on by intializing and adding the relevant values of array ( colors ) to the LinkList variable (list1). How does the second method and third method works - I am having a bit difficulty understanding how Arrays can viewed as a list.. As I know arrays are not dynamic data structure, they have fixed sized length, adding/ removing elements on array can not be done on running time comparing to Lists in general.

String[] colors = { "black", "white", "blue", "cyan" };
List< String > list1 = new LinkedList< String >();

// method 1 of initalizing and adding elments to the list
for (String color : colors)
    list1.add(color);

// method 2 of initializing and adding elements to the list
List< String > list1 = new LinkedList< String > (Arrays.asList(colors));

// method 3 of initializing and adding elements to the list
List< String > list1 = Arrays.asList(colors);

Please help me understand my queries above, don't judge me as I am still new to this. Thank you, Sinan

Upvotes: 2

Views: 845

Answers (7)

Rohini Kumar
Rohini Kumar

Reputation: 249

if you see the link below http://docs.oracle.com/javase/1.5.0/docs/api/java/util/LinkedList.html#LinkedList%28java.util.Collection%29

you will see the constructor of linked list class which is accepting a collection object as parameter.

Any in your post, the 2nd and 3 rd lines are passing an object of collection class(i.e Arrays.asList is finally giving a List which is a sub class of collection).

So both 2nd and 3rd lines fairly valid implementations. More over you can observe one more good coding practice in all the 3 lines. That is

writing code to interceptors than to classes

. (referring

LinkedList

instance with

List

interface)

Always try to refer your classes with interceptors which is a good practice

Upvotes: 0

Yegoshin Maxim
Yegoshin Maxim

Reputation: 881

Every time you are interested in implementation you can look into certain method. For example, by press Ctrl+left mouse button onto method or class.

// method 2 of initializing and adding elements to the list
List<String> list1 = new LinkedList<String> (Arrays.asList(colors));

This code leads to:

List<String> list1 = new LinkedList<String> (new ArrayList<String>(colors));

In constructor of ArrayList:

ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
        a = array;
    }

the actual array is copied to encapsulated private array field(link is copied).

Then in constructor of LinkedList:

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
    }

Every element of passed collection is added to the LinkedList.

Upvotes: 0

Joachim Sauer
Joachim Sauer

Reputation: 308001

Actually knowledge of generics is not necessary for answering this question.

As you correctly identifier arrays are static in the sense that you can't add elements to them or remove them.

Lists, however, usually allow those operations.

The List returned by Arrays.asList() does have the add/remove methods (otherwise it would not be a valid List). However actually calling those methods will throw an UnsupportedOperationException exactly because you can't actually add elements to an array (for which this List is simply a view/wrapper).

Operations that don't structurally modify the list (i.e. that don't change the number of elements in the list) are entirely possible: set(int, E) works just fine on the List returned by Arrays.asList().

Upvotes: 3

Robin
Robin

Reputation: 3840

to Method 2, just check the Api here: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/LinkedList.html#LinkedList(java.util.Collection) For sure, Lists implement the Collections Interface so this Constructor will work here.

to Method 3, just check out the Api here: http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html#asList(T...)

Upvotes: 1

SpaceTrucker
SpaceTrucker

Reputation: 13556

Arrays.asList creates a List from an Array. Arrays in general can't be viewed as lists in Java. They can only be wrapped in a list.

So method 2 is used to have a specific list implementation LinkedList in this case.

Upvotes: 1

Marko Topolnik
Marko Topolnik

Reputation: 200148

Only your first method does anything to the LinkedList you have initially assigned into list1. The other two assign a new, unrelated list to it. The third option assigns something that isn't a LinkedList, but a special implementation of the List interface backed by your String array. In the third case you won't be able to add/remove elements from the list, but you can iterate over it and update existing slots. Basically, it does what a plain array does, just through the List interface.

Upvotes: 2

Subhrajyoti Majumder
Subhrajyoti Majumder

Reputation: 41200

Arrays.asList returns a fixed-size list backed by the specified array.

It is actually a bridge between Array and Collection framework. But returned list write through to the array.

Upvotes: 2

Related Questions