What is the difference between the two data structures defined below?
The second one is an ArrayList, whose elements have type 'String'. But what is the first data structure?
The initializations would also be different. Can anyone give an example here?
ArrayList<String>[] temp1;
ArrayList<String> temp2;
ArrayList<String>[] temp1;: This is an Array of ArrayList's that are containing Strings
ArrayList<String> temp2;: This is an ArrayList containing Strings
If you want an ArrayList of Arrays of Strings, you would have to do a ArrayList<String[]> temp3;. Note the position of the different brackets.
To initialize:
// create an array with 10 uninitialized ArrayList<String>
ArrayList<String>[] temp1 = new ArrayList[10];
// create empty lists that can be filled
for (int i=0; i<temp1.length; i++)
temp1[i] = new ArrayList<String>();
// create an empty list of Strings
ArrayList<String> temp2 = new ArrayList<String>();
// create an empty list of String arrays
ArrayList<String[]> temp3 = new ArrayList<String[]>();
I provide some example to differentiate the Array of ArrayList and ArrayList of String
public class ArrayOfArrayList {
public static void main(String[] args) {
// Declare the Array of ArrayList
List<String>[] arrayOfList = new ArrayList[2];
// Declare the Object of ArrayList
for(int i = 0; i < arrayOfList.length; i++) {
arrayOfList[i] = new ArrayList<>();
arrayOfList[i].add("" + (i + 1));
arrayOfList[i].add("" + (i + 2));
}
// Print out the result
for(List<String> list : arrayOfList) {
for(String str : list) {
System.out.println(str);
}
}
// Declare the Object of ArrayList
List<String> arrayList = new ArrayList<>();
arrayList.add("1");
arrayList.add("2");
// Print out the result
for(String str : arrayList) {
System.out.println(str);
}
}
}
The first data structure is an array of ArrayLists containing string objects
The first is an array of classes of the type ArrayList<String>. The second is simply an ArrayList<String> (ArrayList of Strings.)
In terms of initialisations:
ArrayList<String>[] lists = (ArrayList<String>[])new ArrayList[10];
ArrayList<String> temp2 = new ArrayList<String>();
The first initialisation has to specify a size for the array (note this is not a size for the ArrayList) and this is where the 10 comes from in my example. It can be any size you choose of course, 10 is just an arbitrary example. It will also generate a warning, but, if you really want an array of ArrayList<String> this is AFAIK the only way for now (the reason stems from the fact generics in Java aren't reified, but array types are.)
The second one is an ArrayList, whose elements have type 'String'. But what is the first data structure?
On the surface, it would appear to be an array of lists (containing strings). However arrays and generics don't play very well together. From the 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<String>[3] is illegal), unless the type argument is an unbounded wildcard (new List<?>[3] is legal). Let's see what would happen if you were allowed to declare arrays of generic types:
List<String>[] lsa = new List<String>[10]; // illegal
Object[] oa = lsa; // OK because List<String> is a subtype of Object
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[0] = li;
String s = lsa[0].get(0);
The last line will throw a ClassCastException, because you've managed to cram a List<Integer> into what should have been a List<String>. Because array covariance would have allowed you to subvert the type safety of generics, instantiating arrays of generic types (except for types whose type arguments are unbounded wildcards, like List<?>) has been disallowed.
Yes, first is the Array of ArrayList and will have strings value in it.
second statement is only array list of Strings value.
Related
arraylist internally uses Object[] Array which is homogeneous then how arraylist is heterogeneous
The following throws an exception when running:
Object[] array = new String[3];
array[0] = "a";
array[1] = 1; // throws java.lang.ArrayStoreException
unlike the following which compiles and runs without problem
ArrayList list = new ArrayList<String>();
list.add("a");
list.add(1); // works
list.add(new Object()); // works
The backing array of an ArrayList is an Object[] (i.e. the element type of that array is the Object class, not any sub-class of Object), so you can put any reference type (as well as primitives, which get auto-boxed to their corresponding wrapper type) in it.
The following would not throw an exception:
Object[] array = new Object[3];
array[0] = "a";
array[1] = 1;
You can see the initialization of the backing array in the ArrayList constructor:
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity]; // here
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
Generics are compile-time feature of the Java Language. At runtime, all defined generic types are considered to be of Object type. Therefore, using Object[] as the backing supporting list makes perfect sense.
Doing these two compiles to the same thing (same bytecode):
ArrayList<String> list = new ArrayList<>();
ArrayList<Integer> list = new ArrayList<>();
On the other hand, array types are consistent through compile and run time. These will produce different bytecode after compiling:
String[] arr = new String[];
Integer[] arr = new Integer[];
since it is holding Object which is parent of all classes so eventually we are make homogeneous to heterogeneous. And this is is not the ideal way to define arraylist. But technically we can do.
I have an array. For each element of the array, I want to store multiple integers. I know that in C I can make an array of integer pointers, and use that pointer to make a list.
In Java, I can make an array of object 'A', where A has a list of integers. But why can't I do something like this
List<Integer>[] arr = new ArrayList<Integer>[]();
I get:
Type mismatch: cannot convert from ArrayList to List[]
You typically want to avoid mixing collections and arrays together for this very reason; an array is covariant (that is, Integer[] is-an Object[]), but collections (and generics in general) are invariant (that is, a List<Integer> is not a List<Object>).
You can definitely create a list of lists instead, which will ensure type safety and get you around the issue of creating a generic array:
List<List<Integer>> intNestedList = new ArrayList<>();
As stated in Java's own documentation, you cannot create an array of generics.
If you want to create an array which can hold up to ten List<Integer> you must declare the array that way.
List<Integer>[] arr = new ArrayList[10];
following assignment is valid
List<Integer> intList = new ArrayList<>();
arr[0] = intList;
whereas following will fail with an compilation error
List<String> stringList = new ArrayList<>();
arr[0] = stringList;
the compilation fails with
incompatible types: java.util.List<java.lang.String>
cannot be converted to java.util.List<java.lang.Integer>
An ArrayList is a List, but an ArrayList is not a List[]
If you want an Array of Lists that hold integers, I would suggest:
List<Integer>[] xyz; // still writing code will update in a sec
It turns out you can't create arrays of parameterized types, according to the oracle docs.
Unless you know for sure you want a finite array, I suggest you do something like List<List<Integer>> arr = new ArrayList<List<Integer>>();
If you really want an array of Lists then you'll want to see this Java question about ArrayList<Integer>[] x
Creating an array of List is no different than creating an array of any other object. You can do any of the following:
List[] listsArray = new List[3];
listsArray[0] = new ArrayList();
listsArray[1] = new LinkedList();
listsArray[2] = new ArrayList();
Or:
List[] listsArray = new List[]{new ArrayList(), new LinkedList(), new ArrayList()};
Note that you are limited in what you can do with generics on arrays.
Not a very nice solution but you might try it with a cast. Something like this:
List<Integer>[] arr = (List<Integer>[]) new List[SIZE_OF_YOUR_ARRAY];
You will probably get a warning but it should still work.
As i found, you need an array of arrays.
you can do this, to make your inner arrays:
Integer[] array1 = new Integer[];
Integer[] array2 = new Integer[];
and then put them in another array like this:
Integer[][] arrays = new Integer[][] { array1, array2 };
or
Integer[][] arrays = { array1, array2 };
maybe it's better to do it like this:
List<List<Integer>> listOfLists = Lists.newArrayList();
listOfLists.add(Lists.newArrayList("123","456","789"));
after all I recommend you to read this:
How to make an array of arrays in Java
Graph Implementation using Adjacency List depicts the usage of an Array of List.
public class Graph {
int vertex;
LinkedList<Integer> list[];
public Graph(int vertex) {
this.vertex = vertex;
list = new LinkedList[vertex];
for (int i = 0; i <vertex ; i++) {
list[i] = new LinkedList<>();
}
}
}
As you can observe that the constructor of class Graph, is used to define the Array of List.
in the same constructor, Array Of List is initialized too.
Hope It would be Helpful to resolve your problem and requirement !.
I was trying create an array of a collection as follows.
ArrayList<Integer> ar[]=new ArrayList<Integer>[50];
but it gives me an error -> generic array creation
can anybody explain me why is it?
You can't create arrays of generic types. Use collection of collections instead:
ArrayList<ArrayList<Integer>> = new ArrayList<ArrayList<Integer>>();
Why can't we create an array of generic type? Array stores they exact type internally, but due to the type erasure at runtime there will be no generic type. So, to prevent you from been fooled by this (see example below) you can't create an array of generic type:
//THIS CODE WILL NOT COMPILE
ArrayList<Integer>[] arr = new ArrayList<Integer>[5];
Object[] obj = arr;
obj[0] = new ArrayList<Long>(); //no one is safe
ArrayList is internally a 1D array itself. what you need 2D array so you can create
ArrayList<Integer[]> ar=new ArrayList<Integer[]>();
or
ArrayList<ArrayList<Integer>> = new ArrayList<ArrayList<Integer>>();
The answer to you question can be found in the Java Language Specification. You are trying to create an array using Array Creation Expression. It says the following: "It is a compile-time error if the ClassOrInterfaceType does not denote a reifiable type". Because arrays in Java are created at runtime, their type information should be completely available at runtime. In other words array element type should be a reifiable type. Generics in Java are implemented using type erasure (i.e. only subset of generics compile-time type information is available at runtime) hence they are not reifiable by definition and therefore you cannot create arrays of generic types.
Actually you can have an Array of Collection, it just is not allowed that the Collection has a specific type.
You can do something like
ArrayList<?>[] ar = new ArrayList<?>[50];
// or ArrayList[] ar = new ArrayList[50];
ar[0] = new ArrayList<Integer>();
but you will not have the benefits of Generics - there is no type information for the content of the Collection, you will need to cast when reading from it
Integer i = (Integer) ar[0].get(0);
You could do something like this
ArrayList<Integer> ar[]= new ArrayList[50];
ArrayList<Integer> intArr = new ArrayList<Integer>();
ArrayList<Long> longArr = new ArrayList<Long>();
ar[0]=intArr;
ar[1]= longArr; // compile error Type mismatch: cannot convert from ArrayList<Long> to ArrayList<Integer>
You can have an array "technically" of type ArrayList but its a bit nit picky. Create it as an ArrayList<ArrayList<Integer>> list = ArrayList<ArrayList<Integer>(); and convert it using toArray(ArrayList<Integer>[list.size()]);.
Example:
ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
list.add(new ArrayList<Integer>());
list.add(new ArrayList<Integer>());
list.add(new ArrayList<Integer>());
int count = 1;
for(ArrayList<Integer> AList: list) {
for(int i = 0; i < 4; i++)
AList.add(count++);
}
ArrayList<Integer>[] check = list.toArray(new ArrayList[list.size()]);
for(ArrayList<Integer> AL : check) {
for(Integer i:AL) {
System.out.print(i + " ");
}
System.out.println();
}
Output:
1 2 3 4
5 6 7 8
9 10 11 12
Works and is an ArrayList array
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).
Run time exception-- java.lang.ClassCastingException...
Integer intArr[] = new Integer[arrList.size()];
ArrayList <Integer> arrList =new ArrayList();
intArr=(Integer[])arrList.toArray(); // returns Object class which is downcaste to Integer;
I understand down-casting is not safe but why is this happening?
I also tried to converting ArrayList to String to Integer to int, but I get the same error.
Try to do this
intArr = arrList.toArray(new Integer[arrList.size()]);
What you get is a typed Integer Array and not a Object array.
First of all, this doesn't bind the ArrayList to type Integer.
ArrayList <Integer> arrList =new ArrayList();
Instead, this is what happens, arrList is assigned to an ArrayList of raw type, but that isn't a problem.
The problem lies in,
intArr=(Integer[])arrList.toArray();
since arrList is a raw-type (due to the assignment, it gets assigned as new ArrayList<Object>() by the compiler), you're effectively getting an Object[] instead.
Try assigning arrList to new ArrayList<Integer>() and do this:
intArr = arrList.toArray(new Integer[arrList.size()]);
The problem here is that you are trying to convert an array of objects to an array of integers. Array is an object in itself and Integer[] is not a sub-class of ArrayList, nor vice versa. What you have to do in your case is cast individual items, something like this:
Integer intArr[] = new Integer[arrList.size()];
for(int i=0; i<intArr.length; i++)
{
intArr[i] = (Integer)arrList.get(i);
}
Naturally, you may get ClassCastException if individual elements in the array list are not of type Integer.
toArray(T[] a) takes a paramter:
"a - the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same runt"