Paggalugad ng mga tanong at sagot mula sa isang job interview para sa isang Java developer position. Bahagi 10

Hi! Ilang oras ang kailangan para maging master sa isang bagay? Madalas kong narinig ang isang bagay tulad ng: "Upang maging isang master sa anumang bagay, kailangan mong gumastos ng 10,000 oras dito." Iyan ay isang nakakatakot na numero, hindi ba? Gayunpaman, iniisip ko kung ito ay totoo. At patuloy kong sinisikap na malaman kung ilang oras na akong namuhunan sa pag-master ng sining ng programming. At kapag tumawid ako sa espesyal na linyang iyon ng 10,000 oras at naging master, mararamdaman ko ba ang pagkakaiba? O matagal ko na bang nalampasan ang linyang iyon nang hindi ko namamalayan? Sa alinmang paraan, hindi mo kailangang mamuhunan ng napakalaking oras upang maging isang programmer. Ang mahalaga ay gamitin ang iyong oras nang matalino. Ang iyong pangunahing layunin ay makakuha ng isang pakikipanayam. At sa mga panayam, tatanungin muna ang mga magiging software developer tungkol sa teorya, kaya kailangang maging lakas iyon. Sa katunayan, habang naghahanda ka para sa isang pakikipanayam, ang iyong trabaho ay tuklasin ang lahat ng mga kakulangan sa kaalaman sa pangunahing teorya ng Java at pagkatapos ay punan ang mga ito. Ngayon ay narito ako upang tulungan kang gawin iyon, dahil ngayon ay ipagpapatuloy namin ang aming pagsusuri sa mga pinakasikat na tanong sa panayam. Well, magpatuloy tayo!

89. Paano naiiba ang ArrayList kaysa sa LinkedList?

Isa ito sa mga pinakasikat na tanong, kasama ang tanong tungkol sa panloob na istraktura ng isang HashMap . Walang panayam na kumpleto kung wala ito, kaya ang iyong sagot ay dapat na agad na lumabas sa iyong dila. Bilang karagdagan sa halata (mayroon silang iba't ibang mga pangalan), naiiba sila sa kanilang panloob na istraktura. Mas maaga, tinalakay namin ang panloob na istraktura ng parehong ArrayList at LinkedList , kaya hindi ko susuriin ang kanilang mga detalye ng pagpapatupad. Ipapaalala ko lang sa iyo na ang ArrayList ay ipinatupad gamit ang isang panloob na array na ang laki ay tumataas nang pabago-bago ayon sa formula na ito:

<size of the current array> * 3 / 2 + 1

Bilang karagdagan, ang pagpapatupad ng isang LinkedList ay gumagamit ng isang panloob na dobleng naka-link na listahan, iyon ay, ang bawat elemento ay may reference sa nakaraan at susunod na mga elemento, maliban sa mga elemento sa simula at dulo ng listahan. Gustong itanong ng mga tagapanayam ang ganitong tanong, "Alin ang mas maganda, ArrayList o LinkedList ?" umaasang mahuli ka. Pagkatapos ng lahat, kung sasabihin mo ang isa o ang isa ay mas mahusay, pagkatapos ay nagbigay ka ng maling sagot. Sa halip, dapat mong linawin ang partikular na sitwasyon na iyong pinag-uusapan: pag-access sa mga elemento sa pamamagitan ng index o pagpasok sa gitna ng listahan. Pagkatapos, depende sa kanilang sagot, maaari mong ipaliwanag kung alin ang mas mahusay. Inilarawan ko dati kung paano gumagana ang ArrayList at LinkedList sa bawat sitwasyon. Ibuod natin ito sa pamamagitan ng paglalagay ng mga ito sa isang hilera para sa paghahambing: Pagdaragdag ng isang elemento (idagdag)

1. Kung ang isang index ay hindi tinukoy, pagkatapos ay isang bagong item ay awtomatikong idaragdag sa dulo para sa parehong mga uri ng mga listahan. Sa isang LinkedList , ang bagong elemento ay magiging bagong buntot (isang pares lamang ng mga sanggunian ang muling isusulat, kaya ang algorithmic complexity ay O(1) ).

   Ang paraan ng pagdaragdag ay nagdaragdag ng isang elemento sa huling walang laman na cell sa array ( O(1) ).

2. Ang pagdaragdag ng isang item sa pamamagitan ng index ay karaniwang nangangahulugan ng pagpasok nito sa isang lugar sa gitna ng listahan. Sa isang LinkedList , hahanapin muna ng pamamaraan ang nais na lokasyon sa pamamagitan ng pag-ulit sa mga elemento mula sa buntot at ulo ( O(n/2) ) at pagkatapos ay ipapasok ang halaga sa pamamagitan ng pag-overwrite sa mga sanggunian ng mga elemento sa magkabilang panig kung saan ang bagong elemento ay ipinasok ( O(1) ). Ang pangkalahatang algorithmic complexity ng operasyong ito ay magiging O(n/2) .

   Sa parehong sitwasyon (pagdaragdag sa pamamagitan ng index), hinahanap ng isang ArrayList ang nais na lokasyon ( O(1) ) at pagkatapos ay inilipat ang lahat ng mga elemento na matatagpuan sa kanan (kabilang ang elemento na nakaimbak na sa tinukoy na index) sa kanan ng isa (na kung saan maaaring mangailangan ng paglikha ng isang bagong panloob na hanay at pagkopya ng mga elemento dito) ( O(n/2) ). Ang pangkalahatang kumplikado ay O(n/2) .

3. Ang pagdaragdag ng elemento sa simula ng LinkedList ay katulad ng pagdaragdag ng elemento sa dulo: ang bagong elemento ay nagiging bagong ulo ( O(1) ). Ngunit para sa isang ArrayList, ang operasyong iyon ay nangangailangan ng paglipat ng lahat ng mga elemento sa kanan ( O(n) ).

Ang bottom line ay para sa isang LinkedList ang algorithmic complexity ay mula sa O(1) hanggang O(n/2) . Ang isa pang obserbasyon ay kung mas malapit ang pagpasok sa dulo o simula ng listahan, mas mabilis ito. Para sa ArrayList , ang algorithmic complexity ay mula sa O(1) hanggang O(n) , at kung mas malapit ang pagpasok sa dulo ng listahan, mas mabilis ito. Pagtatakda ng isang elemento (set) Ang operasyong ito ay nagsusulat ng isang elemento sa tinukoy na posisyon sa listahan, na pinatungan ang anumang umiiral na elemento. Sa isang LinkedList , ang operasyong ito ay katulad ng pagdaragdag, dahil ang pinakamalaking hamon dito ay ang paghahanap ng lokasyon ng elemento. Ang umiiral na elemento ay na-overwrite sa pamamagitan ng pag-update ng isang pares ng mga sanggunian, kaya muli mayroon kaming algorithmic complexity na nag-iiba mula O(1) hanggang O(n/2) , depende sa distansya ng gustong posisyon mula sa dulo o simula ng listahan. Ngunit para sa isang ArrayList , hinahanap ng operasyong ito ang ninanais na cell ayon sa index at isinusulat ang bagong elemento doon. Tulad ng set na operasyon, ang paghahanap sa pamamagitan ng index ay may algorithmic complexity ng O(1) . Ang pagkuha ng elemento sa pamamagitan ng index (get) Ang pagkuha ng elemento mula sa isang LinkedList ay sumusunod sa parehong prinsipyo sa paghahanap na ginagamit sa ibang mga operasyon. Ang pagiging kumplikado ay nakasalalay sa distansya mula sa dulo o sa simula, ibig sabihin, ito ay nag-iiba mula sa O(1) hanggang O(n/2) . Gaya ng nabanggit kanina, para sa isang ArrayList , ang paghahanap ng elemento ayon sa index sa panloob na hanay ay may kumplikadong O(1) . Pag-alis ng elemento sa pamamagitan ng index (alisin) Para sa LinkedList , nalalapat muli ang parehong prinsipyo. Una, matatagpuan ang elemento, at pagkatapos ay muling isinulat ang mga sanggunian, ang mga kapitbahay ng tinanggal na elemento ay tumutukoy na ngayon sa isa't isa, inaalis ang mga sanggunian sa tinanggal na elemento, na pagkatapos ay lilinisin ng kolektor ng basura. Sa madaling salita, pareho pa rin ang algorithmic complexity — nag-iiba ito mula O(1) hanggang O(n/2) . Para sa ArrayList , ang operasyong ito ay mas katulad ng pagdaragdag ng bagong elemento (add). Una, hinahanap ng pamamaraan ang nais na elemento ( O(1) ), inaalis ito, at pagkatapos ang lahat ng mga elementong matatagpuan sa kanan ay inilipat ng isang hakbang sa kaliwa upang isara ang puwang na nilikha ng pagtanggal. Ang pag-alis ng elemento ay may parehong algorithmic complexity gaya ng add operation — mula O(1) hanggang O(n). Kung mas malapit ang tinanggal na elemento sa dulo ng listahan, mas mababa ang algorithmic complexity ng operasyong ito. At ngayon nasaklaw na namin ang lahat ng pangunahing operasyon. Hayaan mong ipaalala ko sa iyo na kapag inihahambing ang dalawang uri ng listahang ito, kailangan mong linawin ang partikular na sitwasyon kung saan ginagamit ang mga ito. Pagkatapos lamang ay maaari mong sagutin nang walang pag-aalinlangan ang tanong ng tagapanayam.

90. Paano naiiba ang ArrayList sa isang HashSet?

Kung maihahambing namin ang ArrayList at LinkedList sa isang operation-by-operation na batayan upang matukoy kung alin ang mas mahusay, hindi namin mahahanap na ganoon kadaling gumawa ng ganoong paghahambing sa pagitan ng ArrayList at HashSet , dahil ang mga ito ay ganap na magkakaibang mga koleksyon. Maaari mong ihambing ang isang dessert sa isa pa, ngunit ang paghahambing ng isang dessert at isang masarap na ulam ay isang hamon — masakit na naiiba ang mga ito. Gayunpaman, susubukan kong ituro ang ilan sa mga pagkakaiba sa pagitan nila:

• Ipinapatupad ng ArrayList ang interface ng Listahan habang ipinapatupad ng HashSet ang interface ng Set .

• Hinahayaan ka ng ArrayList na ma-access ang isang elemento sa pamamagitan ng index: ang get operation ay may O(1) algorithmic complexity, ngunit hinahayaan ka lang ng HashSet na ma-access ang isang gustong elemento sa pamamagitan ng pag-ulit, na nagbubunga ng algorithmic complexity mula sa O(1) hanggang O(n) .

• Pinapayagan ng ArrayList ang mga dobleng elemento. Sa isang HashSet , ang lahat ng mga elemento ay natatangi: anumang pagtatangka na magdagdag ng isang elemento na naroroon na sa isang HashSet ay mabibigo (ang mga duplicate ay sinusuri ng hashcode, kaya ang pangalan ng koleksyon na ito).

• Ang ArrayList ay ipinatupad gamit ang isang panloob na hanay, ngunit ang HashSet ay ipinatupad gamit ang isang panloob na HashMap .

• Pinapanatili ng ArrayList ang pagkakasunud-sunod ng pagpapasok ng mga elemento, ngunit ang HashSet ay isang hindi nakaayos na hanay at hindi pinapanatili ang pagkakasunud-sunod ng mga elemento.

• Pinapayagan ng ArrayList ang anumang bilang ng mga null na halaga, ngunit maaari ka lamang magdagdag ng isang null na halaga sa isang HashSet (pagkatapos ng lahat, ang mga elemento ay dapat na natatangi).

91. Bakit ang Java ay may napakaraming iba't ibang mga dynamic na pagpapatupad ng array?

Ito ay higit pa sa isang pilosopikal na tanong. Maaari din nating itanong kung bakit sila nagkakaroon ng napakaraming bago at iba't ibang teknolohiya? Para sa kaginhawahan. At ang parehong bagay ay totoo tungkol sa isang malaking bilang ng mga dynamic na pagpapatupad ng array. Wala sa mga ito ang matatawag na pinakamahusay o perpektong pagpapatupad. Ang bawat isa ay may sariling mga pakinabang sa mga tiyak na sitwasyon. Ang aming trabaho ay alamin ang kanilang mga pagkakaiba at ang kanilang mga kalakasan/kahinaan upang magamit ang koleksyon na pinakaangkop para sa anumang partikular na sitwasyon.

92. Bakit ang Java ay may napakaraming iba't ibang mga pagpapatupad ng imbakan ng key-value?

Narito ang sitwasyon ay kapareho ng sa mga dynamic na pagpapatupad ng array. Tiyak na walang mas mahusay sa pangkalahatan kaysa sa iba: bawat isa ay may mga kalakasan at kahinaan. At dapat nating sulitin ang kanilang mga lakas, siyempre. Halimbawa: ang concurrent package, na maraming multithreaded na klase, ay may sarili nitong Concurrent na koleksyon. Ang klase ng ConcurrentHashMap ay may kalamangan kaysa sa karaniwang HashMap sa mga tuntunin ng kaligtasan kapag nagtatrabaho sa data sa isang multi-threaded na kapaligiran, ngunit ito ay dumating sa halaga ng mas mabagal na pagganap. At ang mga pagpapatupad na hindi ang pinakamahusay na pagpipilian sa anumang sitwasyon ay unti-unting humihinto sa paggamit. Halimbawa: Ang Hashtable , na orihinal na nilayon upang maging isang thread-safe HashMap , ay nakalimutan at hindi na ginagamit, dahil ang ConcurrentHashMap ay mas mahusay kaysa sa Hashtable kapag nagtatrabaho sa isang multi-threaded na kapaligiran.

93. Paano ko pag-uuri-uriin ang isang koleksyon ng mga elemento?

Ang unang bagay na sasabihin ay ang klase na kumakatawan sa mga elemento ng koleksyon ay dapat magpatupad ng Comparable interface, na binubuo ng compareTo method. O kailangan mo ng klase na nagpapatupad ng interface ng Comparator , kasama ang paraan ng paghahambing nito . Ang parehong mga pamamaraan ay nagpapahiwatig kung paano ihambing ang mga bagay ng isang naibigay na uri. Ito ay kritikal kapag nag-uuri, dahil ang algorithm ng pag-uuri ay kailangang maunawaan kung anong prinsipyo ang gagamitin upang ihambing ang mga elemento. Pangunahing ginagawa ito sa pamamagitan ng direktang pagpapatupad ng Comparable sa klase na gusto mong ayusin. Ang paggamit ng Comparator ay hindi gaanong karaniwan. Ipagpalagay na gumagamit ka ng isang klase mula sa ilang library at hindi ito nagpapatupad ng Comparable , ngunit kailangan mong pag-uri-uriin ang isang koleksyon ng mga bagay nito. Dahil hindi mo mababago ang code ng klase na ito (maliban sa pagpapalawak nito), maaari kang magsulat ng pagpapatupad ng Comparator na nagpapahiwatig kung paano ihambing ang mga bagay ng klase. At isa pang halimbawa. Kung kailangan mong pag-uri-uriin ang mga bagay na may parehong uri sa iba't ibang paraan, maaari kang sumulat ng maraming pagpapatupad ng Comparator na gagamitin sa iba't ibang sitwasyon. Bilang isang patakaran, maraming mga out-of-the-box na klase, hal String , ay nagpapatupad na ng Comparable interface. Nangangahulugan iyon na hindi mo kailangang mag-alala tungkol sa kung paano ihambing ang mga klase na ito. Maaari mo lamang magpatuloy at gamitin ang mga ito. Ang una at pinaka-halatang paraan ay ang paggamit ng klase ng TreeSet o TreeMap . Ang mga klaseng ito ay nag-iimbak ng mga elemento sa pinagsunod-sunod na pagkakasunud-sunod batay sa comparator na ipinatupad ng mga elemento ng klase. Huwag kalimutan na ang TreeMap ay nag-uuri ng mga susi, hindi mga halaga. Kung gumagamit ka ng Comparator sa halip na Comparable , kailangan mong magpasa ng object ng Comparator sa constructor ng koleksyon kapag nilikha mo ito:

TreeSet treeSet = new TreeSet(customComparator);

Ngunit paano kung mayroon kang ibang uri ng koleksyon? Paano mo ito ayusin? Sa kasong ito, ang pangalawang paraan ng klase ng utility ng Collections — ang sort() method — ay angkop. Ang pamamaraan ay static, kaya ang kailangan mo lang ay i-prepend ang pangalan ng klase at pagkatapos ay ipasa sa listahan na pag-uri-uriin. Halimbawa:

Collections.sort(someList);

Kung gumagamit ka ng pagpapatupad ng Comparator sa halip na Comparable , kailangan mong ipasa ito bilang pangalawang argumento:

Collections.sort(someList, customComparator);

Babaguhin ng operasyong ito ang panloob na pagkakasunud-sunod ng mga elemento sa naipasa na listahan: pag-uuri-uriin ang listahan gamit ang comparator. Tandaan na ang naipasa na listahan ay dapat na nababago, kung hindi, ang pamamaraan ay mabibigo at magtapon ng UnsupportedOperationException . Ang pangatlong opsyon ay ang paggamit ng pinagsunod-sunod na paraan ng klase ng Stream , na nag-uuri ng mga elemento ng koleksyon. Kung gumagamit kami ng Comparable :

someList = someList.stream().sorted().collect(Collectors.toList());

Kung gumagamit kami ng Comparator :

someList = someList.stream().sorted(customComparator).collect(Collectors.toList());

Ang ikaapat na paraan ay ang manu-manong pagpapatupad ng algorithm ng pag-uuri, halimbawa, bubble sort o pagsamahin ang sort .

Klase ng bagay. katumbas ng() at hashCode()

94. Magbigay ng maikling paglalarawan ng klase ng Object sa Java.

Sa ikalawang bahagi ng pagsusuri, napag-usapan na natin ang mga pamamaraan ng klase ng Bagay . Dito ay ipapaalala ko sa iyo na ang Object class ay isang ninuno ng bawat klase sa Java. Mayroon itong 11 pamamaraan, na minana naman ng lahat ng klase.

95. Ano ang equals() at hashCode() na ginagamit sa Java?

hashCode() ay isang paraan ng Object class na minana ng lahat ng klase. Ang trabaho nito ay bumuo ng isang numero na kumakatawan sa isang partikular na bagay. Ang isang halimbawa ng pagkilos na pamamaraang ito ay makikita sa HashMap , kung saan tinatawag ito sa mga pangunahing bagay upang makuha ang lokal na hashcode, na tutukuyin kung aling bucket (cell ng panloob na array) ang pares ng key-value ay iimbak. Gayundin, ang pamamaraang ito ay karaniwang ginagamit sa equals() na pamamaraan bilang isa sa mga pangunahing paraan nito upang makilala ang mga bagay. equals() ay isang paraan ng klase ng Object na ang trabaho ay ihambing ang mga bagay at matukoy kung pantay ang mga ito. Ang pamamaraang ito ay ginagamit saanman kailangan nating ihambing ang mga bagay, dahil ang karaniwang == paghahambing operator ay hindi angkop para sa mga bagay, dahil ito ay naghahambing lamang ng mga sanggunian sa bagay.

96. Sabihin sa amin ang tungkol sa kontrata sa pagitan ng equals() at hashCode() sa Java?

Una, hayaan mong sabihin ko na para gumana nang tama ang equals() at hashCode() , dapat itong ma-override nang tama. Ang kanilang mga bagong pagpapatupad ay dapat sumunod sa mga panuntunang ito:

• Ang mga magkaparehong bagay kung saan ang katumbas ay nagbabalik ng true ay dapat na may parehong mga hash code.
• Ang mga bagay na may parehong mga hash code ay hindi kinakailangang pantay.

Ngayon ay tila isang magandang lugar upang i-pause hanggang sa susunod na bahagi ng pagsusuri!