The compiler understands that since A and B are two different types, a list of A cannot be a list of B. A list of bicycles cannot be a list of persons or vice versa. Therefore the cast is forbidden.

Every list is an object. So you can always cast a list to Object. And once you’ve got an object, all the compiler knows is that it’s an object, so when you say it’s really a list of B, all the compiler knows is that this might be true, so it trusts you and allows the cast. Next thing you may be putting persons into your bicycle list or making other trouble for yourself. This is no longer the compiler’s problem.

You may cast a list to Object, but you cannot cast a List<A> to List<Object> either. Why not? Because this would allow you to put any kinds of objects into a list that was supposed to hold only A objects. See the related question linked to at the bottom.

> If we can ensure each item in aList is a B, I think it should work.

No, it won’t. After the cast you would still be able to use aList.add(something) to add something that is not a B and thus violating the claim that bList is a list of B. How to convert your aList to List<B> in this case, see the linked question, the answers there do explain it, in particular the answer by fracz.

> In my opinion, Java Designer can allow us to cast list to list, but
> they don't. …

You are free to disagree about the language design, of course, and you certainly won’t be alone.

> … A a = (A) b, if b is not an A, it will throw an Exception. And
> we can find which Object results this. if List<A> aList = (List<A>
> bList) can work, each item's Exception will result List cast error,
> and we even don't know which item throw Exception. …

There’s a fundamental difference here. If an object is an A, it will always be an A. There is no way in Java that it could ever become anything else than an A. So once you have successfully made the cast, you can rest assured that the type holds no further unpleasant surprises for you. A list, on the other hand, even if it currently holds only A objects, it may at some time in the future hold B, C or D objects or all of them and more. So if java allowed the cast, you would risk all kinds of negative surprises further down the road. I think that this is the reason why they chose to forbid it. I am not saying that they made the perfect decision, just trying to explain that at least there is some reason behind it.

> … So Java Designer don't allow us to do this. This is my current
> understanding, …

Your understanding is correct.

If you want to convert a list that currently holds, say, only F objects, to a List<F>, I suggest that you copy all of the lements into a new List<F> (for example a new ArrayList<F>. There’s no stopping you from doing that, and Java helps you control that the list copy will always hold F objects only.

Link: Related question: How do you cast a List of supertypes to a List of subtypes? My own favourite answer for your situation is the one by fracz.

Nope, both List are not Object arrays. They contain an array containing objects of class A or B which have to be specified and which are probably incompatible.

If your classes are incompatible, your second line will only work for the compiler but not on runtime.

But you could also define that B extends A, then your cast should work.

Generic type in Java is invariant. Java doesn't allow us to do things like above because it can lead to run time exceptions. For example:

List<String> listOfStrings = new ArrayList<String>();
//we all know that String is sub-type of Object, but Compiler prohibits below line of code even though the line looks ok.
List<Object> listOfObjects = (List<Object>) listOfStrings;
//The reason is... If Java Compiler compiles the line above, run-time exceptions could appears
listOfObjects.add(new Integer(6));
String str = listOfStrings.get(0); //Run-time exception goes here ---> we expect a String, but the item at index 0 is actually an Integer object.

I hope the code above is clear enough to demonstrate why you can not cast your lists.