Mga array sa ay magkakatulad na istruktura ng data na ipinatupad sa Java bilang mga object. Nag-iimbak ang mga array ng isa o higit pang mga halaga ng isang tukoy na uri ng data at nagbibigay ng na-index na pag-access upang maiimbak ang pareho. Ang isang tukoy na elemento sa isang array ay na-access ng index nito. Sa artikulong ito, tatalakayin namin ang Dynamic Array sa Java sa sumusunod na pagkakasunud-sunod:
- Panimula sa Dynamic Array sa Java
- Laki vs Kapasidad
- Nagdaragdag ang pagdodoble
- Pagtanggal ng isang Elemento
- Pagbabago ng laki ng isang Dynamic Array sa Java
Panimula sa Dynamic Array sa Java
Ang pabagu-bagong array ay isang uri ng isang array na may malaking pagpapabuti para sa awtomatikong pagbabago ng laki. Ang tanging limitasyon lamang ng mga arrays ay isang nakapirming sukat. Isinalin ito sa isang kahulugan na maaari mo lamang tukuyin ang bilang ng mga elemento na maaaring hawakan ng iyong array nang maaga. Sa kabilang banda, maaaring mapalawak ang mga dynamic na array habang nagdaragdag kami ng maraming mga elemento sa real-time. Samakatuwid, ang coder ay hindi kailangang matukoy ang laki ng array nang maaga. Mayroon ding ilang mga lakas din:
Mabilis na paghanap . Parehas tulad ng mga arrays, kapag nakuha ang elemento sa isang naibigay na index, tumatagal ng O (1) na oras.
Laki ng variable . Maaari naming ipasok ng maraming mga elemento na gusto namin at isang dynamic na array ay naaayon palawakin upang i-hold ang mga ito.
Cache-friendly . Katulad ng mga arrays, maaaring maglagay ng mga item sa tabi-tabi ang memorya ng mga item, sa gayon ay gumagawa ng mabisang paggamit ng mga cache.
dumaan sa halaga sa java
Mayroong ilang mga kabiguan sa paggamit ng mga dynamic na array sa aming code. Bagaman, gumagamit kami ng mga dinamikong array nang higit pa sa anupaman sa karamihan ng mga aplikasyon may ilang mga kaso kung saan hindi sila ang naging pinakapiniling pagpipilian dahil sa mga limitasyon nito.
Mabagal ang pinakamasamang kaso na nadugtong . Karaniwan, habang ang pagdaragdag ng isang bagong elemento sa dulo ng isang pabagu-bagong array, tumatagal ng O (1) sa isang pagkakataon. Gayunpaman, kung ang dynamiko na array ay wala nang mga indeks para sa isang bagong item, kung gayon kakailanganin itong palawakin, na tumatagal ng O (n) sa bawat oras.
Ang mga mamahaling pagsingit at pagtanggal. Katulad ng mga arrays, ang mga elemento ay nakaimbak na katabi ng bawat isa. Kaya't habang nagdaragdag o nag-aalis ng isang item sa gitna ng isang array nangangailangan ito ng pagtulak ng iba pang mga elemento, na tumatagal ng O (n) nang paisa-isa.
Ipinapakita ng mga diagram sa ibaba kung paano gumagana ang mga array sa real-time at naglalarawan kung paano nakasalansan ang mga elemento. Ipinapakita rin nito kung paano nagbabago ang mga tagubilin para sa isang average na kaso at ang pinakapangit na kaso ng mga pag-andar ng array.
Laki kumpara sa Kapasidad
Kapag pinasimulan namin ang isang pabagu-bagong array, ang pagpapatupad ng pabagu-bagong array ay lumilikha ng isang naiintindihan na nakapirming laki ng array. Ang paunang laki ay tumutugma sa pagpapatupad. Halimbawa, gawin natin ang aming hanay ng pagpapatupad upang magamit ang 10 mga indeks. Ngayon ay idinagdag namin ang apat na mga item sa aming pabagu-bagong hanay. Ngayon, ang aming dynamic na array ay may haba na apat. Gayunpaman, ang aming pinagbabatayan na array ay may haba na 10. Samakatuwid, maaari naming sabihin na ang laki ng pabagu-bagong array ay apat at ang kapasidad nito ay 10. Ang isang pabago-bagong array ay nag-iimbak ng isang tukoy na end Index upang subaybayan ang pagtatapos na punto ng pabagu-bagong array at ang pagsisimula ituro mula sa kung saan nagsisimula ang sobrang kapasidad.
gamit ang namespace c ++
Nagdaragdag ang pagdodoble
Maaaring may mga kaso kung saan susubukan naming idagdag ang isang item sa isang array kung saan puno na ang kapasidad. Samakatuwid, upang lumikha ng mga room dinamis na arrays awtomatikong lumikha ng bago, mas malaki at napapailalim na array. Karaniwan, nagiging doble ang laki nito upang mahawakan ang anumang mga bagong karagdagan, na hindi nito inaasahan nang mas maaga. Samakatuwid, ang pagkopya ng bawat item ay walang kinakain na oras. Sa tuwing ang pagdaragdag ng isang item sa aming pabagu-bagong array ay awtomatikong gumagawa ng isang bagong dobleng sukat na pinagbabatayan na array, na ang pagdugtong ay walang oras.
Pagtanggal ng isang Elemento
Habang tinatanggal ang isang elemento mula sa isang array, ang default na pamamaraan na 'alisin ()' ay aalisin ang isang elemento mula sa dulo at awtomatikong nag-iimbak ng zero sa huling index. Tatanggalin din nito ang mga elemento sa isang tukoy na index sa pamamagitan ng pagtawag sa alisin na paraan (i) kung saan ang index ng 'I'. Ang pamamaraan ng pagtanggalAt (i) ay naglilipat ng lahat ng mga tamang elemento sa kaliwang bahagi mula sa ibinigay na index.
Nagbabago ng laki ng Array
Kapag ang mga array ay walang data sa kanang bahagi ng array na kung saan kaysa kumuha ng hindi kinakailangang memorya, ang pamamaraang srinkSize () ay nagpapalaya ng labis na memorya. Kapag natupok ang lahat ng mga puwang at idinagdag ang mga karagdagang elemento, ang pinagbabatayan ng nakapirming sukat ng array ay dapat dagdagan ang laki. Ang aktwal na pagbabago ng laki ay mahal, dahil kailangan naming maglaan ng isang mas malaking array at kopyahin ang lahat ng mga elemento mula sa isang array na napalaki mo bago nito tuluyang maidugtong ang isang bagong item.
Nasa ibaba ang isang halimbawa ng isang programa kung saan ang laki ng array ay napuno at ang mga bagong elemento ay kinopya sa isang bagong array na doble laki. Ang elemento na kung saan ay isang elemento ng string na tinatawag na 'Mahavir' ay isang karagdagan sa buong hanay ng laki ng 3.
import java.util.ArrayList import java.util.Arrays import java.util.Scanner pampublikong klase AddingItemsDynamically {public static void main (String args []) {Scanner sc = new Scanner (System.in) System.out.println (' Ipasok ang laki ng array :: ') int size = sc.nextInt () String myArray [] = bagong String [size] System.out.println (' Ipasok ang mga elemento ng array (Strings) :: ') para sa (int ako = 0 i Output:
Sa pamamagitan nito, nakarating kami sa dulo ng artikulo ng Dynamic Array sa Java. Inaasahan kong nakakuha ka ng isang ideya kung paano gumana sa mga dynamic na array.
pag-convert ng binary sa decimal sa java
Suriin 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. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Dynamic Array in Java' at babalikan ka namin sa lalong madaling panahon.