Perhaps a bit misleading title, but not sure how to word it.
In the example of an ArrayList, what are the differences between these two list-objects:
ArrayList list = new ArrayList<Integer>();
and
ArrayList<Integer> list = new ArrayList();
Note: I know about the list hierarchy, interfaces and inheritance, but I am not sure how it applies in this situation. Can anyone please help me clear this up?
ArrayList list = new ArrayList<Integer>();
will give a warning about using the raw ArrayList object since you are not specifing the list is of a generic ArrayList type.
ArrayList<Integer> list = new ArrayList();
will give an unchecked conversion warning since you are assigning a non-generic ArrayList to a typed ArrayList
ArrayList<Integer> list = new ArrayList<>();
will work in java7+. The diamond operator tells the compiler to infer the generic type.
List<Integer> list = new ArrayList<Integer>();
is the standard way of using an ArrayList even it is more long winded than the new java7 syntax.
Related
Is there any difference between these 3 lines?
List list2 = new ArrayList<String>();
List list2 = new ArrayList<>();
List list2 = new ArrayList();
As I understand, all information about generics is erased in runtime. Consequently, only type of veriable is important. So the above lines of code mean the same thing to me. If I am wrong can anybody give me some exapmle that shows the difference?
p.s. sorry for my english
While it is true that generic data is erased at compile-time, that doesn't mean they are totally useless. The only line that would compile in your example is the last one, but you would get a warning that you are using RawTypes. A RawType is a generic class that does not have a generic object. The first two lines are only half-built.
The reason you pretty much have to use generics is that the list is type-safe. If you use generics, you could use something like this:
List<String> list = new ArrayList<>();
String out = list.get(0);
If you use raw types, you would have to do this:
List list = new ArrayList();
String out = (String) list.get(0);
This may seem OK, but what if you add a value to the list that is not a String? The program crashes. For example:
List unsafe = new ArrayList();
List<String> safe = new ArrayList<>();
unsafe.add("hi");
unsafe.add(new Tree());
safe.add("hi");
safe.add(new Tree()); // This line would throw an exception.
String out = (String) unsafe.get(0);
String out1 = safe.get(0);
String out2 = (String) unsafe.get(1); // This line would throw an exception.
If you still don't quite see why to use generic types, the final nail in the coffin for raw types is this: If my (String) unsafe.get(1) is in a separate class, on the hundredth line, I know that that line is the problematic line. I, however, don't know where the non-string object is being added, only where it's being accessed.
If you use generic types, you know exactly where the problematic addition is made, and you can prevent it.
The below line gives me error :
Incompatible Types.
List<List<Integer>> output = new ArrayList<ArrayList<Integer>>();
What is the reason?
EDIT
I understand if I change my second ArrayList to List, it does not give me error. I want to know the reason of error though. Thanks
The correct writing should be:
List<List<Integer>> ret = new ArrayList<List<Integer>>();
Since in this way, you can add not only ArrayList but also LinkedList to ret
If you had a List<List<Integer>> then you'd be able to add a LinkedList<Integer> to it. But you can't do this for an ArrayList<ArrayList<Integer>>, so the latter can't possibly be a type of List<List<Integer>>.
From Generics, Inheritance, and Subtypes
This is a common misunderstanding when it comes to programming with
generics, but it is an important concept to learn.
Box<Integer> is not a subtype of Box even though Integer is a subtype of Number.
The reason is that generics are not covariant.
Consider simpler case:
List<Integer> integers = new ArrayList<Integer>();
List<Number> numbers = integers; // cannot do this
numbers.add(new Float(1337.44));
Now List holds a Float, which is certainly bad.
Same for your case.
List<ArrayList<Integer>> al = new ArrayList<ArrayList<Integer>>();
List<List<Integer>> ll = al; // cannot do this
ll.add(new LinkedList<Integer>())
Now you have a list ll which holds LinkedList, but the al is declared as a List of ArrayLists.
It is clearly stated in Java Doc
In general, if Foo is a subtype (subclass or subinterface) of Bar, and
G is some generic type declaration, it is not the case that G<Foo> is
a subtype of G<Bar>. This is probably the hardest thing you need to
learn about generics, because it goes against our deeply held
intuitions.
Same thing happens here it's Bar = List<Integer> and Foo = ArrayList<Integer> as ArrayList<ArrayList<Integer>> is not sub type of List<List<Integer>>
Less text more fixes:
List<List<Integer>> lists = new ArrayList<>();
or
List<List<Integer>> lists = new ArrayList<List<Integer>>();
Before you use generics, you should know 2 principles.
1. The generics parameter should be the same like:
LinkedList<String> res = new LinkedList<String>();
2. The parameter should directly inherit from class Object like Integer, Character, and List or Array. (LinkedList is the subclass of List, so cannot be the parameter of generics)
Here is a correct demonstrations:
LinkedList<List<Integer>> res = new LinkedList<List<Integer>>();
Why can't I create an array of List ?
List<String>[] nav = new List<String>[] { new ArrayList<String>() };
Eclipse says "Cannot create a generic array of List"
or
ArrayList<String>[] nav = new ArrayList<String>[] { new ArrayList<String>() };
Eclipse says "Cannot create a generic array of ArrayList"
or
List<String>[] getListsOfStrings() {
List<String> groupA = new ArrayList<String>();
List<String> groupB = new ArrayList<String>();
return new List<String>[] { groupA, groupB };
}
But I can do this:
List[] getLists() {
return new List[] { new ArrayList(), new ArrayList() };
}
Eclipse says that List and ArrayList are raw types but it compiles...
Seems pretty simple, why won't it work?
Well, generics tutorial give the answer to your question.
The component type of an array object
may not be a type variable or a
parameterized type, unless it is an
(unbounded) wildcard type.You can
declare array types whose element type
is a type variable or a parameterized
type, but not array objects.
This is
annoying, to be sure. This restriction
is necessary to avoid situations like:
// Not really allowed.
List<String>[] lsa = new List<String>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Unsound, but passes run time store check
oa[1] = li;
// Run-time error: ClassCastException.
String s = lsa[1].get(0);
If arrays of parameterized type were
allowed, the previous example would
compile without any unchecked
warnings, and yet fail at run-time.
We've had type-safety as a primary
design goal of generics.
You can't create arrays of generic types, generally.
The reason is that the JVM has no way to check that only the right objects are put into it (with ArrayStoreExceptions), since the difference between List<String> and List<Integer> are nonexistent at runtime.
Of course, you can trick the compiler by using the raw type List or the unbound wildcard type List<?>, and then cast it (with a unchecked cast) to List<String>. But then it is your responsibility to put only List<String> in it and no other lists.
No exact answer, but a tip:
Last example has a raw type warning because you omitted the typization of the list; it is generally a better (type safe) approach to specify which object types are contained in the list, which you already did in the previous examples (List<String> instead of List).
Using arrays is not best practice, since their use contains errors most times; Using Collection classes (List, Set, Map,...) enables use of typization and of convenient methods for handling their content; just take a look at the static methods of the Collections class.
Thus, just use the example of the previous answer.
Another solution is to extend LinkedList<String> (or ArrayList<String>, etc.), then create an array of the subclass.
private static class StringList extends LinkedList<String> {}
public static void main(String[] args)
{
StringList[] strings = new StringList[2];
strings[0] = new StringList();
strings[1] = new StringList();
strings[0].add("Test 1");
strings[0].add("Test 2");
strings[1].add("Test 3");
strings[1].add("Test 4");
System.out.println(strings[0]);
System.out.println(strings[1]);
}
In normal array list initialization,
We used to define generic type as follows,
List<String> list1 = new ArrayList<String>();
But in case of ArrayList of ArrayLists, How can we define its generic type?
The code for array list of array lists is as follows:
ArrayList[] arr=new ArrayList[n];
for(int i=0;i<n;i++)
{
arr[i]=new ArrayList();
}
Just share the syntax, if anybody have idea about it..!
You can simply do
List<List<String>> l = new ArrayList<List<String>>();
If you need an array of Lists, you can do
List<String>[] l = new List[n];
and safely ignore or suppress the warning.
If you (really) want a list of lists, then this is the correct declaration:
List<List<String>> listOfLists = new ArrayList<List<String>>();
We can't create generic arrays. new List<String>[0] is a compiletime error.
Something like this:
List<List<Number>> matrix = new ArrayList<List<Number>>();
for (int i = 0; i < numRows; ++i) {
List<Number> row = new ArrayList<Number>();
// add some values into the row
matrix.add(row);
}
Make the type of the inner List anything you want; this is for illustrative purposes only.
You are Right: This looks insane. (May its an Bug...)
Instead of Using
ArrayList<String>[] lst = new ArrayList<String>[]{};
Use:
ArrayList<String>[] list1 = new ArrayList[]{};
will work for the declaration, even if you dont describe an congrete generic!
You are talking about an array of lists (ArrayLists to be more specific). Java doesn't allow generic array generation (except when using wildcards, see next paragraph). So you should either forget about using generics for the array, or use a list instead of an array (many solutions proposed for this).
Quote from IBM article:
Another consequence of the fact that arrays are covariant but generics are not is that you cannot instantiate an array of a generic type (new List[3] is illegal), unless the type argument is an unbounded wildcard (new List< ?>[3] is legal).
What is the syntax for making a List of arrays in Java?
I have tried the following:
List<int[]> A = new List<int[]>();
and a lot of other things.
I need to be able to reorder the int arrays, but the elements of the int arrays need not to be changed. If this is not possible, why?
Thank you.
Firstly, you can't do new List(); it is an interface.
To make a list of int Arrays, do something like this :
List<int[]> myList = new ArrayList<int[]>();
P.S. As per the comment, package for List is java.util.List and for ArrayList java.util.ArrayList
List<Integer[]> integerList = new ArrayList<Integer[]>();
Use the object instead of the primitive, unless this is before Java 1.5 as it handles the autoboxing automatically.
As far as the sorting goes:
Collections.sort(integerList); //Sort the entire List
and for each array (probably what you want)
for(Integer[] currentArray : integerList)
{
Arrays.sort(currentArray);
}
List is an interface, not a class. You have to choose what kind of list. In most cases an ArrayList is chosen.
List a = new ArrayList();
You've mentioned that you want to store an int array in it, so you can specify the type that a list contains.
List<int[]> a = new ArrayList<int[]>();
While you can have a collection (such as a list) of "int[]", you cannot have a collection of "int". This is because arrays are objects, but an "int" is a primitive.