LinkedList vs ArrayList sa Java: Alamin ang mga pangunahing pagkakaiba

Listahan sa Java ay isang sub-interface ng na nagbibigay ng pinakamainam na mga solusyon sa mga konsepto tulad ng posisyonal na pag-access, pag-ulit at iba pa. Sa artikulong ito, tatalakayin ko ang mga pangunahing pagkakaiba sa pagitan ng interface ng listahan na LinkedList vs ArrayList sa Java.

Nasa ibaba ang mga paksang sakop sa artikulong ito:

• Ano ang isang LinkedList?
• Ano ang ArrayList?
• Mga pagkakatulad sa pagitan ng LinkedList at ArrayList
• Mga pagkakaiba sa pagitan ng LinkedList at ArrayList

Magsimula na tayo!

Ano ang LinkedList?

Pagkatapos arrays , ang pangalawang pinakapopular na istraktura ng data ay tiyak na a . Ang isang naka-link na listahan ay isang linear na istraktura ng data na binubuo ng akadena ng mga node kung saan ang bawat node ay naglalaman ng isang halaga at apointersa susunod na node sa kadena.Gayundin, thuling nag-link siya sa isang naka-link na listahan na tumuturo sa null, na nagpapahiwatig ng pagtatapos ng kadena.Ang isang elemento sa isang naka-link na listahan ay tinatawag na a node .Ang unang node sa listahan ay tinawag na ulo .Ang huling node ay tinawag na buntot .

Hayaan akong bigyan ka ng isang simpleng halimbawa nito: Mag-isip ng isang kadena ng mga paperclips na magkakaugnay. Madali kang makakapagdagdag ng isa pang paperclip sa itaas o ibaba. Madali din na ipasok ang isa sa gitna. Ang kailangan mo lang gawin ay masira lang ang kadena sa gitna, magdagdag ng isang bagong paperclip, pagkatapos ay ikonekta muli ang iba pang kalahati. Ang isang naka-link na listahan ay katulad nito.

Halimbawa:

package MyPackage import java.util.LinkedList import java.util.ListIterator pampublikong klase na naka-link na listahan {public static void main (String args []) {/ * Declaration ng Listahan ng naka-link * / LinkedListl_list = bagong LinkedList () / * add (String Item) ay ginamit para sa pagdaragdag * ng Mga Item sa naka-link na listahan * / l_list.add ('Java') l_list.add ('Python') l_list.add ('Scala') l_list.add ('Swift') System.out.println ( 'Nilalaman ng Listahang Na-link:' + l_list) / * Magdagdag ng Mga Item sa tinukoy na posisyon * / l_list.add (2, 'JavaScript') l_list.add (3, 'Kotlin') System.out.println ('l_list Nilalaman pagkatapos i-edit: '+ l_list) / * Magdagdag ng Una at Huling Item * / l_list.addFirst (' Unang Kurso ') l_list.addLast (' Huling Kurso ') System.out.println (' l_list na Nilalaman pagkatapos ng pagdaragdag: '+ l_list) / * Kumuha at itakda ang Mga item sa listahan * / Object firstvar = l_list.get (0) System.out.println ('First Item:' + firstvar) l_list.set (0, 'Java9') System.out.println ('l_list Nilalaman pagkatapos i-update ang unang Item: '+ l_list) / * Alisin mula sa isang posisyon * / l_list.remove (1) l_list.remove (2) System.out.println ('LinkedList pagkatapos ng pagtanggal ng Item sa ika-2 at ika-3 posisyon' + l_list) / * Alisin ang una at huling Item * / l_list.removeFirst () l_list.removeLast () System.out.println ('Pangwakas na Nilalaman pagkatapos alisin ang una at huling Item : '+ l_list) / * Iterating ang naka-link na listahan * / ListIteratoritrator = l_list.listIterator () System.out.println (' Ipinapakita ang listahan gamit ang iterator: ') habang (itrator.hasNext ()) {System.out.println (itrator .susunod ())}}}

Output:

Naka-link na Nilalaman ng Listahan = {Java, Python, Scala, Swift} Nilalaman pagkatapos ng pag-edit = {Java, Python, JavaScript, Kotlin, Scala, Swift} Nilalaman pagkatapos ng pagdaragdag = {Unang Kurso, Java, Python, JavaScript, Kotlin, Scala, Swift, Huling Kurso} Unang Item = {Unang Kurso} Nilalaman pagkatapos i-update ang unang item = {Java9, Java, Python, JavaScript, Kotlin, Scala, Swift, Huling Kurso} Nilalaman pagkatapos ng pagtanggal ng item sa ika-2 at ika-3 posisyon = {Java9, Python, Kotlin, Scala, Swift, Huling Kurso} Pangwakas na Nilalaman pagkatapos alisin ang una at huling Item = {Python, Kotlin, Scala, Swift} Ipinapakita ang listahan gamit ang iterator = Python Kotlin Scala Swift

Ngayon, magpatuloy tayo sa susunod na paksa.

Ano ang ArrayList?

ay ang pagpapatupad ng Listahan ng Listahan kung saan ang mga elemento ay maaaring ma-dinamiko maidagdag o matanggal mula sa kaukulang listahan. Dito, ang laki ng listahan ay nadagdagan nang pabagu-bago kung ang mga elemento ay idinagdag nang higit pa sa pauna o tunay na laki. Bagaman maaaring mas mabagal kaysa sa karaniwang mga pag-array, maaari itong maging kapaki-pakinabang sa mga programa kung saan kinakailangan ng maraming pagmamanipula sa array.

Ginagamit ang ArrayList para sa mga hangaring ito:

• Ang ArrayList sa Java ay dati nang tindahan isang dynamic na laki ng koleksyon ng mga elemento.
  
• Pinasimulan ito ng isang sukat. Gayunpaman, ang laki ay maaaring tumaas kung ang koleksyon ay lumalaki at lumiit kung ang mga bagay ay tinanggal mula sa .
• Gayundin, pinapayagan ka ng ArrayList na random na ma-access ang listahan.

Tayo ay magpatuloy at ituro ang mga pagkakatulad sa pagitan ng LinkedList at ArrayList sa Java.

Mga pagkakatulad sa pagitan ng LinkedList at ArrayList

Ito ang mga kapansin-pansin na pagkakatulad sa pagitan ng LinkedList at ArrayList sa Java.

• Ang ArrayList at LinkedList ay ang pagpapatupad ng mga Listahan ng interface .
• Parehong pinapanatili ng ArrayList at LinkedList ang pagkakasunud-sunod ng pagpasok ng mga elemento. Nangangahulugan ito na, habang ipinapakita ang mga elemento ng Listahan, ang hanay ng resulta ay magkakaroon ng parehong pagkakasunud-sunod kung saan ang mga elemento ay naipasok sa Listahan.
• Ang mga klase ngArrayList at LinkedList na ito ay hindi na-synchronize at maaaring gawin nang malinaw na na-synchronize sa pamamagitan ng paggamit ng Mga KoleksyonSinkronipikadong Listahan paraan
• Ang iterator at ListIterator na ibinalik ng mga klase ay mabilis na mabilis. Nangangahulugan ito na, kung ang listahan ay nabago sa istruktura sa anumang naibigay na oras pagkatapos malikha ang iterator, maliban sasariling pag-alis o pagdaragdag ng mga iterator, magtatapon ang iterator a Kasabay na PagbabagoException .

Mga pagkakaiba sa pagitan ng LinkedList at ArrayList

Una, tingnan natin ang mga parameter upang ihambing ang LinkedList vs ArrayList sa Java.

Mga Parameter upang ihambing ang LinkedList at ArrayList sa Java:

• Pagpapatakbo
• Pagpapatupad
• Proseso
• Memorya

1. Mga operasyon

Ang pagpasok, pagdaragdag at pag-aalis ng mga operasyon ng isang item ay mas mabilis sa a LinkedList sapagkat hindi natin kailangang baguhin ang laki tulad ng ginagawa natin sa Listahan ng Array.

2. Pagpapatupad

Listahan ng Array ay batay sa konsepto ng isang pabagu-bagong resizable na array, habang LinkedList ay batay sa pagpapatupad ng listahan ng doble na naka-link

3. Proseso

SA LinkedList ang klase ay maaaring magamit bilang isang listahan at isang pila dahil nagpapatupad ito ng mga interface ng List at Deque samantalang ang ArrayList ay maaari lamang ipatupad ang Mga Listahan.

Apat. Memorya

SA LinkedList kumakain ng higit na memorya kaysa sa isang Listahan ng Array dahil ang bawat node sa a LinkedList nag-iimbak ng dalawang sanggunian, samantalang Listahan ng Array humahawak lamang ng data at ang index nito

LinkedList vs ArrayList sa Java

Iyon lang mga kaibigan! Dinadala tayo nito sa pagtatapos ng artikulong ito sa LinkedList vs ArrayList sa Java. Inaasahan kong malinaw kayo sa itinuro sa artikulong ito.

aling pamamaraan ng klase ng scanner ang nagbabasa ng isang string

Kung nakita mo ang artikulong ito sa 'LinkedList vs ArrayList sa Java', tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay, at nakakakuha kami ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer.