Convert generic ArrayList to array of specific type

[Sudhir Srinivasan]

Hi,

My program generates object array from the toArray method on a generic ArrayList and converts to string array. While alternative 1 successfully returns the result,

package testEvenMore.myPrograms;

import java.util.*;

public class Collections1 {
    public static void main(String[] args) {

    ArrayList al = new ArrayList();//list 1
    al.add(100);c
    al.add(200);
    al.add(300.300);
    al.add(400.400);
    al.add("Michael");
    al.add(500);
    al.add(600);
    al.add("David");

    System.out.println("List 1:");
    System.out.println("---------");
    System.out.println(al);

    //Alternative 1
    Object[] ob = al.toArray();
    String[] str = new String[ob.length];

    System.out.println("List 1 converted to array:");
    System.out.println("-----------------------------");
    for(int x = 0; x < str.length; x++)
    {
        str[x] = ob[x].toString();
        System.out.print(str[x]+" ");
    }
    System.out.println("\n");

    //Alternative 2
   System.out.println("List 2:");
    System.out.println("-----------");
    ArrayList al2 = new ArrayList();//list 2
    al2.add("Alex");
    al2.add("Simon");
    al2.add("John");
    al2.add(1000);
    al2.add(100);
    System.out.println(al2);

    Object[] ob1 = al2.toArray();

    String[] str1 = Arrays.copyOf(ob1, ob1.length, String[].class);
    System.out.println("List 2 converted to array:");
    System.out.println("------------------------------");
    for(int x = 0; x < str1.length; x++)
    {
    str1[x] = ob1[x].toString();
    System.out.print(str1[x]+" ");
    }
     System.out.println("\n");
  }

}

alternative 2 does not. Here, the code snippet

String[] str1 = Arrays.copyOf(ob1, ob1.length, String[].class);

attempts to clone the original object array 'ob1' by creating a copy, returning its length and casting to string array class. However, throws a

init:
Deleting: C:\Documents and Settings\Admin\My Documents\NetBeansProjects\CoreJava7\build\built-jar.properties
deps-jar:
Updating property file: C:\Documents and Settings\Admin\My Documents\NetBeansProjects\CoreJava7\build\built-jar.properties
compile-single:
run-single:
List 1:
---------
[100, 200, 300.3, 400.4, Michael, 500, 600, David]
List 1 converted to array:
-----------------------------
100 200 300.3 400.4 Michael 500 600 David 

List 2:
-----------
[Alex, Simon, John, 1000, 100]
         Exception in thread "main" java.lang.ArrayStoreException
         at java.lang.System.arraycopy(Native Method)
        at java.util.Arrays.copyOf(Arrays.java:2763)
        at testEvenMore.myPrograms.Collections2.main(Collections2.java:60)
Java Result: 1
BUILD SUCCESSFUL (total time: 0 seconds)

As per the javadoc, the java.lang.ArrayStoreException is raised if an element copied from the original array (in my case ob1) is not of a run-time type that can be stored in an array of class (str1 in the program). Given that the copy should contain the same elements (& their types) and be of same size as the original, why is this exception thrown? Shouldn't this work with generics or does the ArrayList
have to be of specific type for cloning to be effective??

Is there a way to work around this and find a solution.

Any help from the forum experts / members is much appreciated.

Many thanks,
Sudhir

[Jeff Verdegan]

1000 and 100 are not Strings.

[Rob Spoor]

The proper way to create a List (or any Collection) into an array is to use the other toArray method, and to use generics properly:

List<String> al = new ArrayList<String>(); // will cause compiler errors when you try to add the Integers
...
String[] str = al.toArray(new String[al.size()]);
// or:
// String[] str = new String[al.size()];
// str = al.toArray(str);

If you want to still use a List<Object>, you will need to iterate manually. I see two ways:
1) Create a List<String> to which you first add all String elements, then convert that into a String as shown above
2) Create a String[] as large as the List. Then add all String elements, using a counter variable. Afterwards, if the counter is less than the array size, use Arrays.copyOf to trim the array.

[Sudhir Srinivasan]

Hi Rob,

Thank you for your suggestions and

Rob Spoor wrote:The proper way to create a List (or any Collection) into an array is to use the other toArray method, and to use generics properly:

List<String> al = new ArrayList<String>(); // will cause compiler errors when you try to add the Integers
...
String[] str = al.toArray(new String[al.size()]);
// or:
// String[] str = new String[al.size()];
// str = al.toArray(str);

the sample code.....was of great help!

I tried out both ways

Rob Spoor wrote:
If you want to still use a List<Object>, you will need to iterate manually. I see two ways:
1) Create a List<String> to which you first add all String elements, then convert that into a String as shown above
2) Create a String[] as large as the List. Then add all String elements, using a counter variable. Afterwards, if the counter is less than the array size, use Arrays.copyOf to trim the array.

and was successful.

Suggestion 1:

ArrayList<String> al2 = new ArrayList<String>();
    al2.add("Alex");
    al2.add("Simon");
    al2.add("John");
    al2.add("1000");
    al2.add("100");
    al2.add("55.55");
    al2.add("40.75");
    System.out.println(al2);

String[] str1 = al2.toArray(new String[al2.size()]);

System.out.println("List 2 converted to array:");
    System.out.println("------------------------------");
    for(String s:str1)
    {
      System.out.print(s+" ");
    }
     System.out.println("\n");
  }
}

Your second suggestion answers my question.

To recap:
1. Create object array from the toArray method on a generic ArrayList
2. Create a string array dimensioned to length of object array
3. for...loop to convert each element toString & store in String[] and
4. Arrays.copyOf method should take parameters whose run-time type is understood by the jvm

str1 = Arrays.copyOf(str1, str1.length, String[].class);

instead of

String[] str1 = Arrays.copyOf(ob1, ob1.length, String[].class);//ob1 references object array, not understood by the jvm thereby failing the type checking

In other words - if I've understood your response correctly - String[] is an Object[] and not the other way.

Thanks and regards,
Sudhir

[Rob Spoor]

Sudhir Srinivasan wrote:

str1 = Arrays.copyOf(str1, str1.length, String[].class);

Almost correct. str1 is already a String[]. You're copying that into a new String[] of exactly the same size. You need to use a different value instead of str1.length. Also, because str1 is already a String[], you can omit the String[].class. The third argument is only necessary in the following scenario:
- You have a reference of type X[] (e.g. X[] == Object[]).
- You know that every element is actually an instance of type Y, with Y extends X (e.g. Y == String).
- You want to get an Y[] out of that.

If you have an X[] and want to get another X[] (e.g. String[] -> String[]), the third argument can be omitted. copyOf will then use the actual class of the first argument (String[]) to create the copy.

In other words - if I've understood your response correctly - String[] is an Object[] and not the other way.

100% correct.

[Sudhir Srinivasan]

Rob Spoor wrote:]Almost correct. str1 is already a String[]. You're copying that into a new String[] of exactly the same size. You need to use a different value instead of str1.length. Also, because str1 is already a String[], you can omit the String[].class.

You are right. str1 being the original array, to be copied into another String[] str2

String[] str2 = new String[ob.length];

of the same size as str1.

Use for...loop to convert each element of str1 toString and

finally,

str2 = Arrays.copyOf(str1, str2.length);//str1 being the original array and length of copy str2 being returned

Rob Spoor wrote:The third argument is only necessary in the following scenario:
- You have a reference of type X[] (e.g. X[] == Object[]).
- You know that every element is actually an instance of type Y, with Y extends X (e.g. Y == String).
- You want to get an Y[] out of that.

Got it! I tried the same and it works. Here's how

List al2 = new ArrayList();
    al2.add("Alex");
    al2.add("Simon");
    al2.add("John");
    al2.add(1000);
    al2.add(100);
    al2.add(55.55);
    al2.add(40.75);

Create an object array ob from the toArray method on a generic ArrayList (shown above)

Contents of al2 to be dumped into the newly allocated object array whose size is identical to the size of al2

for...loop to convert each element of the object array to String & store in ob and

Create String[] and use Arrays.copyOf method, by passing the third argument, to get String[] from ob

and the output

init:
Deleting: C:\Documents and Settings\Admin\My Documents\NetBeansProjects\CoreJava7\build\built-jar.properties
deps-jar:
Updating property file: C:\Documents and Settings\Admin\My Documents\NetBeansProjects\CoreJava7\build\built-jar.properties
compile-single:
run-single:
List 2:
-----------
[Alex, Simon, John, 1000, 100, 55.55, 40.75]

List 2 converted to array:
------------------------------
Alex Simon John 1000 100 55.55 40.75 

BUILD SUCCESSFUL (total time: 1 second)

Rob Spoor wrote:If you have an X[] and want to get another X[] (e.g. String[] -> String[]), the third argument can be omitted. copyOf will then use the actual class of the first argument (String[]) to create the copy.

I'm intrigued by the String[].class and here's my (wild) guess on its working:
- Define the Array class (being entity class) having a property, say obj, of java type String
- Generate getters and setters within this class to populate and return the String value
- String class (being component class to Array) has property, say data, of type char[]
- String class mapped to STRING table with unique ID (being primary key, foreign key in CHAR table) assigned to each object obj
- Each char in turn converted to charset and/or bytes understood by jvm and stored in corresponding CHAR table
- From this internal representation, java retrieves & returns (thru getters) the Class, in this case the String[].class

Again, its a wild guess and so kindly excuse me if its a load of gibberish. Could you please, therefore, explain its working briefly and suggest any link - that deals with how the Class object of an Array (be it of type int, char, String etc.) is obtained - as reference.

Many thanks,
Sudhir