Generics in Java 1.5 ( or is it java 5.0 ?... I always haveconfusion)

Discussion in 'Java' started by Vikram, Jun 12, 2008.

  1. Vikram

    Vikram Guest

    Hi,
    Looking at the signature of the following method in
    java.util.List

    public interface List<E> extends Collection<E> {
    .........
    ........
    ......

    <T> T[] toArray(T[] a);
    }

    I wrote a small program as below:

    ArrayList<String> c = new ArrayList<String>();
    c.add("Vikram");
    c.add("Pyati");
    Integer[] i = new Integer[20];
    c.toArray(i);

    This did not give me a compilation error, though it fails at runtime
    giving java.lang.ArrayStoreException, which is perfect.

    My question is , why did the above mentioned method be declared as
    <E> E[] toArray(E[] a);
    which will force the method to take only the array of formal type ( in
    this case a String[] ) at the compile time
     
    Vikram, Jun 12, 2008
    #1
    1. Advertising

  2. On 12-6-2008 10:37, Vikram wrote:
    > Hi,
    > Looking at the signature of the following method in
    > java.util.List
    >
    > public interface List<E> extends Collection<E> {
    > ........
    > .......
    > .....
    >
    > <T> T[] toArray(T[] a);
    > }
    >
    > I wrote a small program as below:
    >
    > ArrayList<String> c = new ArrayList<String>();
    > c.add("Vikram");
    > c.add("Pyati");
    > Integer[] i = new Integer[20];
    > c.toArray(i);
    >
    > This did not give me a compilation error, though it fails at runtime
    > giving java.lang.ArrayStoreException, which is perfect.
    >
    > My question is , why did the above mentioned method be declared as
    > <E> E[] toArray(E[] a);


    You probably mean
    E[] toArray(E[] a);
    without the formal type parameter. Now E refers to the type parameter E
    of class List.

    > which will force the method to take only the array of formal type ( in
    > this case a String[] ) at the compile time


    In that case you could only convert the list to an array of E, and not
    to an array of a superclass / interface of E.

    There may be cases where it's useful to convert a list to an array of
    Objects. With your proposal that's not possible (it would generating a
    compile time error).

    Modified example:

    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;


    public class ToArray {
    public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("Vikram");
    list.add("Pyati");

    // The following is OK
    Object[] arrO = new Object[list.size()];
    Object[] resArrO = list.toArray(arrO);
    System.out.println(Arrays.deepToString(resArrO));

    // The following is OK; String implements Serializable
    Serializable[] arrS = new Serializable[list.size()];
    Serializable[] resArrS = list.toArray(arrS);
    System.out.println(Arrays.deepToString(resArrS));

    // The following is OK at compile time, but toArray causes an
    // ArrayStoreException at runtime
    Integer[] arrI = new Integer[list.size()];
    Integer[] resArrI = list.toArray(arrI);
    System.out.println(Arrays.deepToString(resArrI));
    }
    }





    --
    Regards,

    Roland
     
    Roland de Ruiter, Jun 12, 2008
    #2
    1. Advertising

  3. Vikram

    Daniel Pitts Guest

    Vikram wrote:
    > Hi,
    > Looking at the signature of the following method in
    > java.util.List
    >
    > public interface List<E> extends Collection<E> {
    > .........
    > ........
    > ......
    >
    > <T> T[] toArray(T[] a);
    > }
    >
    > I wrote a small program as below:
    >
    > ArrayList<String> c = new ArrayList<String>();
    > c.add("Vikram");
    > c.add("Pyati");
    > Integer[] i = new Integer[20];
    > c.toArray(i);
    >
    > This did not give me a compilation error, though it fails at runtime
    > giving java.lang.ArrayStoreException, which is perfect.
    >
    > My question is , why did the above mentioned method be declared as
    > <E> E[] toArray(E[] a);
    > which will force the method to take only the array of formal type ( in
    > this case a String[] ) at the compile time

    So, first off, Generics and Arrays don't always mix well.

    Second, I think you're attempting to express this:
    <T super E> toArray(T[] a);

    Although, that breaks this:
    List<Number> c = new ArrayList<Number>();
    c.add(new Integer(3));
    c.add(new Integer(15));

    Integer[] i = c.toArray(new Integer[0]);

    the toArray(Object[]) method is inherently a run-time only method,
    because it can be used to create any type of array.

    --
    Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
     
    Daniel Pitts, Jun 12, 2008
    #3
  4. Vikram

    d Guest

    > >       Object[] arrO = new Object[list.size()];
    > >       Object[] resArrO = list.toArray(arrO);

    >
    > Alternative idiom, purely a matter of style as the net result is the same:
    >
    >   Object[] resArrO = list.toArray( new Object[0] );
    >
    > I point this out not to recommend it, although personally I like it, but to
    > alert those who may run across it from time to time.


    I much prefer the 2nd example simply because you do not need the arr0
    reference (which to me is syntactic clutter).
     
    d, Jun 12, 2008
    #4
  5. Vikram

    Vikram Guest

    On Jun 12, 8:42 pm, Lew <> wrote:
    > d wrote:
    > >>>       Object[] arrO = new Object[list.size()];
    > >>>       Object[] resArrO = list.toArray(arrO);
    > >> Alternative idiom, purely a matter of style as the net result is the same:

    >
    > >>   Object[] resArrO = list.toArray( new Object[0] );

    >
    > >> I point this out not to recommend it, although personally I like it, but to
    > >> alert those who may run across it from time to time.

    >
    > > I much prefer the 2nd example simply because you do not need the arr0
    > > reference (which to me is syntactic clutter).

    >
    > You don't need it in the first idiom, really:
    >
    >    Object[] resArrO = list.toArray( new Object[list.size()] );
    >
    > Difference eliminated.
    >
    > --
    > Lew


    Thanks very much to everyone... Now I am clear
     
    Vikram, Jun 13, 2008
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Juergen Berchtel
    Replies:
    1
    Views:
    6,008
    John C. Bollinger
    May 20, 2005
  2. Deryck
    Replies:
    4
    Views:
    519
    derek giroulle
    Jun 22, 2004
  3. joes
    Replies:
    2
    Views:
    1,013
    Daniel Pitts
    May 25, 2007
  4. Royan
    Replies:
    8
    Views:
    756
    Patricia Shanahan
    Feb 15, 2008
  5. Soul
    Replies:
    0
    Views:
    524
Loading...

Share This Page