Java generics, list of lists

not every List<MyType> (Animal) is MyList (Cow)

you are adding animals to list of cows

I would suggest some parameters :

public class MyClass{
    private List<List<MyType>> bigList = new ArrayList<List<MyType>>();

    public <E extends List<MyType>> void doStuff(E list)
    {
        bigList.add(list);
    }
}

When you retrieve an element from your bigList however you cannot specialize the element as it comes from a generic list. If you absolutely need to cast it, maybe your class architecture is not correct. Or you could abusively do this :

public class MyClass{
    private List<List<MyType>> bigList = new ArrayList<List<MyType>>();

    public <E extends List<MyType>> void doStuff(E list)
    {
        bigList.add(list);
    }

    public <E extends List<MyType>> E getStuff(Class<E> myType,int i)
    {
        List<MyType> obj = bigList.get(i);
        if(myType.isInstance(obj)) return (E) obj;
        throw new SomeErrorHere("invalid type for index");
    }
}

From what I recall the proper way to typecast list is with the use of generics. Something like:

bigList.add((List<MyList>)(List<?>)list);

However I am not sure of the theory behind this code.

Why is this error occurring

The code is formally correct. You can cast almost any object to any other object and the code will compile. If the cast is invalid, there will be a runtime ClassCastException thrown.

Your IDE can detect unsure casts and complain about them during compile time. Either as a warning or as an error. It is a matter of configuration. Apparently OPs IDE is configured to make such code smells a compile error

Why is this cast unsafe

You can answer your question by answering this:

Can you create a List<MyType> that is not a SpecialList?

You can not cast a List<MyType> to SpecialList because there may be objects which will be List<MyType> and will really not be SpecialList.

Solutions

Change your app architecture

There are two things you can do - either use the class SpecialList all accross your code, or use the generic List<MyType>.

In other words, either change:

doStuff(List<MyType> list) to doStuff(SpecialList list)

or change the

private List<SpecialList> bigList to private List<List<MyType>> bigList

You have to decide whether you want a generic interface list or your own class used everywhere. Remember, that you can alaways cast SpecialList to List<MyType>, because all SpecialList instances are also instances of List<MyType>. It does not work the other way around.

Make sure the cast will always be valid

If you absolutely HAVE TO make this design work, use instanceof to check if the list is really a SpecialList. Like that:

public void doStuff(List<MyType> list)
{
    if (list instanceof SpecialList) {
        bigList.add((SpecialList)list);
    } else {
        SpecialList sl = new SpecialList(list); // I hope you have that constructor
        bigList.add(sl);
    }
}

This works in my Eclipse , this is class SpecialList , Hello is MyType kind of class

package a;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class SpecialList implements List<Hello> {

    //Overridden methods
    }

This one is Myclass

package a;

import java.util.ArrayList;
import java.util.List;

public class MyClass {
    private List<SpecialList> bigList = new ArrayList<SpecialList>();

    public void doStuff(List<Hello> list)
    {
        bigList.add((SpecialList)list);  //compiles good
    }
    public static void main(String[] args) {
        new MyClass().doStuff(null);
    }
}

No compile time error or Runtime Exception

List <MyList> is not same as List <MyType>.

Lets make it simple ,look at the next few lines :

 *List<MyList> myList = new ArrayList<MyList>(); //1
  myList.add(new MyType);//2 ......Compile ERROR*

If you try to add MyType instance into List<MyList> it will give ERROR.

Why :

• Generics means parameterized type.
• Generic adds the TYPE SAFETY.
• That means ,With generic all cast are automatic and implicit ,
  they dont require typecasting while adding and retriving the object
  from list explictly.

Real Time Scenario:

If the department of motor vehicles supplies a list of drivers. We think that a List<Driver> is a List<Person>,assuming that Driver is a subtype of Person.

If that the case , We could add new people who are NOT drivers into the list.

That is All Person are NOT Drivers .

Solution to above problem :

You can use Wildcards with Generics . Check this link from doc http://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html