LinkedList put into Intent extra gets recast to ArrayList when retrieving in next activity
android, android-intent
Solution
I can tell you why this is happening, but you aren't going to like it ;-)
First a bit of background information:
Extras in an `Intent` are basically an Android `Bundle` which is basically a `HashMap` of key/value pairs. So when you do something like
intent.putExtra(AppConstants.KEY_ITEMS, items);
Android creates a new `Bundle` for the extras and adds a map entry to the `Bundle` where the key is `AppConstants.KEY_ITEMS` and the value is items (which is your LinkedList object).
This is all fine and good, and if you were to look at the extras bundle after your code executes you will find that it contains a `LinkedList`. Now comes the interesting part...
When you call `startActivity()` with the extras-containing Intent, Android needs to convert the extras from a map of key/value pairs into a byte stream. Basically it needs to serialize the Bundle. It needs to do that because it may start the activity in another process and in order to do that it needs to serialize/deserialize the objects in the Bundle so that it can recreate them in the new process. It also needs to do this because Android saves the contents of the Intent in some system tables so that it can regenerate the Intent if it needs to later.
In order to serialize the `Bundle` into a byte stream, it goes through the map in the bundle and gets each key/value pair. Then it takes each "value" (which is some kind of object) and tries to determine what kind of object it is so that it can serialize it in the most efficient way. To do this, it checks the object type against a list of known object types. The list of "known object types" contains things like `Integer`, `Long`, `String`, `Map`, `Bundle` and unfortunately also `List`. So if the object is a `List` (of which there are many different kinds, including `LinkedList`) it serializes it and marks it as an object of type `List`.
When the `Bundle` is deserialized, ie: when you do this:
LinkedList<Item> items = (LinkedList<Item>)
getIntent().getSerializableExtra(AppConstants.KEY_ITEMS);
it produces an `ArrayList` for all objects in the `Bundle` of type `List`.
There isn't really anything you can do to change this behaviour of Android. At least now you know why it does this.
Just so that you know: I actually wrote a small test program to verify this behaviour and I have looked at the source code for `Parcel.writeValue(Object v)` which is the method that gets called from `Bundle` when it converts the map into a byte stream.
Important Note: Since `List` is an interface this means that any class that implements `List` that you put into a `Bundle` will come out as an `ArrayList`. It is also interesting that `Map` is also in the list of "known object types" which means that no matter what kind of `Map` object you put into a `Bundle` (for example `TreeMap`, `SortedMap`, or any class that implements the `Map` interface), you will always get a `HashMap` out of it.
Problem
A behaviour i'm observing w.r.t passing serializable data as intent extra is quite strange, and I just wanted to clarify whether there's something I'm not missing out on. So the thing I was trying to do is that in `ActivtyA` I put a `LinkedList` instance into the `intent` I created for starting the next activity - `ActivityB`. ``` LinkedList<Item> items = (some operation); Intent intent = new Intent(this, ActivityB.class); intent.putExtra(AppConstants.KEY_ITEMS, items); ``` In the `onCreate` of `ActivityB`, I tried to retrieve the `LinkedList` extra as follows - ``` LinkedList<Item> items = (LinkedList<Item>) getIntent() .getSerializableExtra(AppConstants.KEY_ITEMS); ``` On running this, I repeatedly got a `ClassCastException` in `ActivityB`, at the line above. Basically, the exception said that I was receiving an `ArrayList`. Once I changed the code above to receive an `ArrayList` instead, everything worked just fine. Now I can't just figure out from the existing documentation whether this is the expected behaviour on Android when passing serializable List implementations. Or perhaps, there's something fundamentally wrong w/ what I'm doing. Thanks.