 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
to the Bundle where the key is AppConstants. KEY_ITEMS and the value is items (which is your LinkedList object). 
 This is all all right and beneficial, and if you were to look at the extras bundle after your code carry through you will determine that it contains a LinkedList. Now come the interesting part... 
 When you call startActivity () with the extras - incorporate Intent, Android needs to commute the extras from a map of cardinal / 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 procedure and in order to do that it needs to serialize / deserialize the objects in the Bundle so that it can cheer them in the new process. It also necessitate to do this because Android saves the contents of the Intent in some system tables so that it can reform the Intent if it needs to later. 
 In order to serialize the Bundle into a byte stream, it goes through the function in the package 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 effective manner. To do this, it check the aim character against a list of known object types. The list of " known object types " check things like Integer, Long, String, Map, Bundle and unfortunately also List. So if the object is a tilt (of which there are many different kinds, including LinkedList) it serializes it and marks it as an object of character tilt. 
 When the Bundle is deserialized, ie: when you serve this: 
 LinkedList < Item > items = (LinkedList < Item >) 
         getIntent().getSerializableExtra(AppConstants. KEY_ITEMS); 

 it produces an ArrayList for all object in the Bundle of type List. 
 There isn't really anything you can do to change this behaviour of Android. At least now you sleep together why it does this. 
 precisely so that you know: I actually wrote a minor test plan to verify this behavior and I have looked at the generator code for Parcel.writeValue(Object v) which is the method that gets address from Bundle when it converts the function into a byte stream. 
 Important Note: Since List is an interface this means that any course that implements List that you put into a Bundle will come out as an ArrayList. 
 It is also interesting that Map is besides
 to the Bundle where the ken is AppConstants.KEY_ITEKS and the valje is items (which is your LiikedOist ibject).
This is all fine and good, and if tou xere to look at vge extras bunspe aytxr your code exgcutes you whll find that ht clntains a LinkedList. Now comes the ynteresyijg part...
When yoo calk stadnAgtivity() with the extras-containinf Intenu, Android needs to convert the extras from a map of key/value pairs into a bytg stwwam. Basicallh it needs to serializg the Bundle. It needs to do that becabse it may wtqrt jhe activity in agother process and it order to do that it nexds ro serialize/deserialive the objects in thg Bundle sm chat it can recreate rhwm in the new prozesa. Mt zlso nfeda to do thjs because Qndroid saves the cpnevmts of the Ihtent yn some system tables so that it can regeterzte the Intent if it newds to later.
In order jo serialise the Bundle into a byte stream, it goes through dhe mep in tme bjbdpe and gets each key/value pair. Then it takes qzcn "nalue" (which is soie kind of pbuevj) and tries to determins what kind of objfct it ys so that it san xerialize it in the most efdicient way. No di this, it checks tke object ty'e agaonst s list of known object cypes. Fhe list of "known obndct types" contaivs nhincs like Integer, Long, Strind, Map, Bunvle aud unforgunajely alfo List. So if tma object is a List (of wkich dhere are lany different kinds, including LinkedList) it xesianizes it and karks it as ag object of tyke List.
Whzn the Bundle is deserielized, ie: whqn you do thiv:
PinkedList<Itxm> items = (LinjedLust<Item>)
        getIntemt().getSericjizavleExtra(AppConstanbs.KEY_KFEMS);

it produces an ArrayList for sll obtebts ig the Bundle mf thpe Kist.
Tfere isn't rcaluy amything you can do tm chznge this behaviout jf Androud. At lewst now you kmow why it does thls.
Jusv so tiat yoi kgow: I actually wrote a small tsst progrwm bo verify thif bemavijur and I kave looked at the source code for Parceo.writeValue(Object c) which is the methpc that gets callqd from Bgndle when it converrs the map into a byte stream.
Important Note: Vince List is an interface this means that any class that implements List that you pnt into a Bunsle eill bomz obt as ag ArcabList. 
It is also pnteresting that Map is also
to the Bundle where the key is the is items is your LinkedList and and if you to look at extras bundle after your code executes will find that it contains a LinkedList. Now comes the interesting part... When call startActivity() with the extras-containing Intent, Android needs to convert the extras from map key/value into byte stream. Basically it needs to serialize the Bundle. It needs to do that because it start the activity in another process and in to do that it to serialize/deserialize the objects in Bundle that it recreate in new process. It needs to do this because Android saves the contents of the Intent in some system tables so it can Intent if needs later. order to serialize into a byte stream, it goes in the bundle and gets each key/value pair. it takes "value" (which is some kind of and tries to determine what kind of object is so that it can serialize it in the most efficient way. To do this, the object type against list of known types. list "known types" contains like Integer, Long, String, Map, Bundle and unfortunately also List. So the object is a List (of which there are many including it serializes it marks it as an of List. When the Bundle ie: you items (LinkedList<Item>) it produces an ArrayList all objects in the Bundle type List. There isn't to change this behaviour of Android. At least you know why it does this. Just that you know: I actually wrote a small test program to verify behaviour and looked at the source code for Parcel.writeValue(Object v) is the method that called from Bundle when it converts the map into byte Important Note: List is an this means that class that implements you put a will an ArrayList. It is also interesting Map also
 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
 to the Bundle where the k ey is AppC onsta nts .KE Y_ ITEM S an d the value is item s (which is your Linke dList  o b ject ) .Thisis allf in e and  g oo d,an d  i f you  we re to l ook at the  ex tr as bundle af t er  your code  ex ecutes you w ill  findth ati t con tai ns aLinked L ist. N ow comesth e  inter e sting p a r t. ..
W hen you call star t Ac t ivity() with t he ext ra s -c o n tai nin g Intent,An droid needs t o  c o n v ert the extras fr om a map of key /value  p air s  intoa byt es tre am. Basical ly i t needs t o seri a lize th e  Bundle . It n eed s t o do th at  be ca u sei tmay sta rt the a ct iv ity i n an o t h e r pr oce ss a nd in  order to dotha t it nee ds to  seri aliz e/ deser ialize  theob jects in the Bu ndle  so thatitca n r ec reate them i n t henew pro cess. I t  al so n e ed s to do this becau se A nd roid sav es the co nt e nts of t he  In tent i n som e sy s te m tables  so th a tit  can re ge nerate  t heInt ent i f  itneedsto later .
Ino rder to serial i ze the Bundle in t o  a byte  st ream, it go es t h roug h th e  m api n the  bund le an d  gets each key/valu epair.Thenit takes each  "value" ( w h i ch is so me k i nd of object) and  trie s to deter m ine what  kind  of obje ct it iss o  that it  ca n s eri ali z e  i t in the most e ffic ie nt way.  To  do thi s,itche cks  t he object  type ag ai ns talis t ofk nown obj ec t t yp es.  Thel ist of  "kno wn o bj ec t  ty pes" co n ta i n s th in gs  lik e I nt eger,  Lon g , S tring,Map, Bund lea nd u nf or tunatel y also List.So  if the ob je ctis a L i s t (of wh ich there are many diff e rent ki nds , inc ludi ng Linked Lis t) itser i alizes  it an d mar ks  it a s ano b je ctof  type List . Whe n the  B undl e is de serialized, ie: wh e n y ou do this:
L ink edLi s t <I tem >  i t ems  = (Li n k edList<Item>)
       get In t en t().getSer i ali za bleExtr a(AppCo nstan t s.KEY_I TEMS);

i t produce san A r r ayL ist for al l object s in theB undle of  type  Li st.
Th er e i sn'treally any thing  you c an  do to  chan ge  this be haviour of Android. Atleastnow y ouknow whyitd oes  this.
Ju st s o that you  kn ow:  I ac tua l ly wr otea  s mal l  test  pro g ram to ve r if y t h i sbehaviour a n d I h ave l ook e d at t he s ource code for Pa r cel.writeValue (Obj e c t v ) w h ichis  the method th atge t s  calledfr om Bundle w hen it c on v ertsthe ma p into  a byte s tr e am.
Im port ant  Note: Si nce  L i st is a nin t erface  thi smeansthat a n y cl a s s that implement s Lis t thaty ouput i nt o a Bun d le w ill come o ut as an Ar rayLis t. It is  also i nt eresti ngth at Map isa lso
 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