Coffee break #176. Pagkakatulad at pagkakaiba sa pagitan ng Array at ArrayList. Paano Sumulat ng isang Effective equals() Method

Pagkakatulad at pagkakaiba sa pagitan ng Array at ArrayList

Source: Medium Nakatuon ang artikulong ito sa pag-unawa sa mga konsepto ng Array at ArrayList at ang mga pagkakaiba sa pagitan ng mga ito.

Java Array

Ang Array ay isang istraktura ng data na nagbibigay-daan sa iyo upang mag-imbak ng isang nakaayos na pagkakasunud-sunod ng mga halaga ng parehong uri. Halimbawa, maaari kang lumikha ng hanay ng mga character, numero, at iba pa. Nalalapat ito sa lahat ng primitive na uri at maging sa mga bagay tulad ng String . Kapag nalikha na ang array, hindi na natin mababago ang laki nito. Narito ang isang pangkalahatang halimbawa ng pagdedeklara ng array reference variable at paglalaan ng array:

dataType[] arrayName = new dataType[numElements];

Kung susubukan naming magdagdag ng higit sa laki ng array, makakakuha kami ng ArrayIndexOutOfBoundsException .

Array Deklarasyon

Upang magdeklara ng array, gumamit ng [ ] mga character pagkatapos ng uri ng data. Ipinapahiwatig nila na ang variable ay isang sanggunian sa isang array. Ang isang array reference variable ay maaaring sumangguni sa mga array na may iba't ibang laki. Ang bagong keyword ay lumilikha ng espasyo sa memorya upang mag-imbak ng array na may tinukoy na bilang ng mga elemento. Ang isang array reference variable ay itinalaga upang sumangguni sa bagong inilaan na array na ito. Ang sumusunod na halimbawa ay nagdedeklara ng array reference variable gameScores , naglalaan ng array ng apat na integer, at nagtatalaga ng gameScores na sumangguni sa inilalaan na array.

int[] gameScores = new int[4];

Ang mga elemento ng array ay awtomatikong sinisimulan sa mga default na halaga kapag ginamit mo ang bagong keyword upang simulan ang isang sanggunian ng array. Ang default na halaga para sa mga elemento ng integer at floating-point na mga uri ng data ay zero, at ang default na halaga para sa mga elemento ng Boolean ay false . Maaari ka ring magdeklara ng array reference variable nang hindi agad inilalaan ang array, at pagkatapos ay italaga ang variable na may inilalaan na array.

int[] gameScores;

gameScores = new int[4];

Pagsisimula ng Array na may Mga Non-Default na Value

Maaari mong simulan ang mga elemento ng array na may mga hindi default na halaga sa pamamagitan ng pagtukoy sa mga paunang halaga sa mga kulot na brace {} na pinaghihiwalay ng mga kuwit.

int [] myArray = { 5 , 7 , 11 };

Ang halimbawa sa itaas ay lumilikha ng array ng tatlong integer na elemento na may mga value na 5, 7, at 11. Ang array initialization na ito ay hindi nangangailangan ng paggamit ng bagong keyword dahil ang laki ng array ay awtomatikong nakatakda sa bilang ng mga elemento sa Kulot na braces. Para sa malalaking array, ang pagsisimula ay maaaring magawa sa pamamagitan ng unang pagtukoy sa array at pagkatapos ay paggamit ng loop upang italaga ang mga elemento ng array. Maaaring ma-access ang mga elemento ng array gamit ang kanilang zero-based na mga indeks.

Int[ ] intArray = new int [ ] {2};
intArray [0] = 1;
intArray [1] = 2;

ArrayList

Ang ArrayList ay isang nakaayos na listahan ng mga elemento ng isang resizable na uri ng sanggunian . Isa rin itong klase mula sa java.util package na kabilang sa Java Collection Framework. Ang ArrayList ay nagbibigay sa amin ng mga dynamic na array at awtomatikong pinangangasiwaan ang pagbabago ng laki ng mga ito. Habang nagdaragdag ka ng mga elemento sa ArrayList, awtomatikong tumataas ang laki ng memorya nito . Maaari kang gumamit ng ArrayList gamit ang import java.util.ArrayList; . Maaari rin kaming lumikha ng isang ArrayList na halimbawa gamit ang sumusunod na pahayag:

ArrayList<Type> arrayList = new ArrayList<Type>();

Ang ArrayList ay maaaring lumaki sa laki upang mapaunlakan ang mga elementong kailangan nito. Hindi sinusuportahan ng ArrayList ang mga primitive na uri tulad ng int , ngunit sa halip ay mga uri ng reference tulad ng Integer . Ang isang karaniwang pagkakamali sa mga nagsisimula ay ang pagdeklara ng ArrayList ng isang primitive na uri gaya ng int , tulad ng sa ArrayList<int> myVals . Nagreresulta ito sa isang error sa compilation: "hindi inaasahang uri, natagpuan : int, kinakailangan: reference". Halimbawa: Gumawa tayo ng ArrayList object na pinangalanang cars , na mag-iimbak ng mga string:

import java.util.ArrayList;

ArrayList<String> cars = new ArrayList<String>();

Upang magdagdag ng mga elemento sa isang ArrayList , gamitin ang add() method . Upang ma-access ang isang elemento ng isang ArrayList , ginagamit ang get() method .

cars.add("Tesla");
cars.add("BMW");
cars.add("Kia");
cars.get(0);

Ang pagkakaiba sa pagitan ng isang built-in na array at isang ArrayList sa Java ay na sa unang kaso, ang laki ng array ay hindi mababago (kung gusto mong magdagdag o mag-alis ng mga elemento sa/mula sa array, kailangan mong lumikha ng bago ). Samantalang sa isang ArrayList , ang mga elemento ay maaaring idagdag at alisin anumang oras.

Pagkakatulad sa pagitan ng Array at ArrayList

• Array at ArrayList ay ginagamit upang mag-imbak ng mga elemento.
• Ang Array at ArrayList ay maaaring mag-imbak ng mga null na halaga.
• Ang parehong mga proseso ay nangyayari sa pare-parehong oras.
• Maaaring mayroon silang mga dobleng halaga.
• Hindi ginagarantiya ng Array at ArrayList ang pagkakaroon ng mga nakaayos na elemento.

Mga Pangunahing Pagkakaiba sa pagitan ng Array at ArrayList

Ang pangunahing pagkakaiba sa pagitan ng isang array ( Array ) at isang ArrayList ay ang static na katangian ng isang array at ang dynamic na katangian ng isang ArrayList . Kapag nalikha na, hindi mo na mababago ang laki ng array, samantalang maaaring baguhin ng ArrayList ang laki nito kung kinakailangan. Ang isa pang mahalagang pagkakaiba ay ang isang array ay isang pangunahing pag-andar na ibinigay ng Java. Sa kabilang banda, ang ArrayList ay bahagi ng balangkas ng mga koleksyon sa Java. Maaari naming ma-access ang mga elemento ng isang array gamit ang isang square bracket kung saan maaari naming tukuyin ang isang index. Habang mayroong isang hanay ng mga pamamaraan upang ma-access ang mga elemento ng ArrayList at baguhin ang mga ito. Kahit na magkaiba sila, pareho silang maihahambing sa ibang aspeto. Pareho sa mga istruktura ng data na ito sa Java ay batay sa mga index at nagbibigay-daan sa iyong mag-imbak ng mga bagay. Bilang karagdagan, pinapayagan nila ang mga null na halaga at mga duplicate. Kung alam mo ang laki ng mga bagay nang maaga, pagkatapos ay mas mahusay na gumamit ng isang array. Ngunit kung hindi ka sigurado sa laki, dapat mong gamitin ang ArrayList sa halip .

Paano Sumulat ng isang Effective equals() Method

Source: Medium Tutulungan ka ng post na ito na mas maunawaan ang paggamit ng equals() method kapag nagtatrabaho sa Java code. Kung pinag-uusapan natin ang default na equals() na pamamaraan at walang anumang pagpapatupad, kung gayon ito ay sa maraming paraan katulad ng == operasyon . Iyon ay, ang pamamaraang ito ay naghahambing ng mga bagay. Halimbawa, ang equals() ay naghahambing ng dalawang string at nagbabalik ng true kung ang mga string ay pantay at false kung hindi. Pakitandaan na ang == operator ay hindi inirerekomenda para sa paghahambing ng mga bagay sa Java. Ang dahilan ay kapag naghahambing ng mga bagay, ang == ay babalik lamang ng true kung ang mga sanggunian ay tumuturo sa parehong bagay. Ang pinakamadaling paraan upang maiwasan ang mga problema ay huwag i-override ang equals method , kung saan ang bawat instance ng klase ay pantay lamang sa sarili nito. Kailangan mo lang i-override ang mga katumbas kapag ang klase ay may konsepto ng lohikal na pagkakapantay-pantay na iba sa simpleng pagkakakilanlan ng bagay, at ang superclass ay hindi pa na-override ang pagkakapantay-pantay. Kaya, kapag ginagamit ang equals() method , kailangan mong malaman kung ang mga object reference ay lohikal na katumbas at kung ang mga ito ay tumutukoy sa parehong bagay.

Mga katangian ng katumbas na pamamaraan

Ang bawat katumbas na pamamaraan ay nagpapatupad ng katumbas na ugnayan . Ito ay may mga sumusunod na katangian:

• Reflexive : Para sa anumang hindi null na reference na value na x, x.equals (x) ay dapat magbalik ng true .

• Symmetric : Para sa anumang hindi null na reference na mga valuex at y , x.equals(y) ay dapat na bumalik ng true lamang kung ang y.equals(x) ay nagbabalik ng true .

• Transitive : Para sa anumang hindi null na reference na halaga x , y , z , kung ang x.equals(y) ay nagbabalik ng true at ang y.equals(z) ay nagbabalik ng true , ang x.equals(z) ay dapat ding magbalik ng true .

• Pare-pareho : Para sa anumang hindi null na reference na mga value x at y, maraming tawag sa x.equals(y) ay dapat na pare-parehong magbabalik ng true o pare-parehong magbabalik ng false .

• Non-nullity : Para sa anumang hindi null na reference na value x, x.equals (null) ay dapat magbalik ng false .

Tingnan natin ang bawat pag-aari:

Reflexivity:

Ang isang bagay ay dapat na katumbas ng sarili nito. Upang i-verify ito, magdagdag ng isang instance ng iyong klase sa koleksyon. Ang pamamaraang naglalaman ay maaaring magpahiwatig na ang koleksyon ay hindi naglalaman ng halimbawa na iyong idinagdag.

Symmetry:

Dalawang bagay (maaari silang mula sa magkaibang klase) ay dapat na pantay sa isa't isa.

Kasunod:

Huwag magsulat ng katumbas na pamamaraan na nakasalalay sa hindi mapagkakatiwalaan/pabagu-bagong mga mapagkukunan.

Non-zero:

Palaging nagbabalik ng true kung ang bagay na ipinasa sa equals ay null .

Ibuod natin:

Narito ang isang recipe para sa isang paraan na katumbas ng kalidad :

1. Gamitin ang == operator upang subukan kung ang isang argumento ay isang sanggunian sa bagay na ito.

2. Gamitin ang instanceof operator upang suriin kung ang isang argument ay nasa tamang uri.

3. I-cast ang argumento sa tamang uri.

4. Para sa bawat "makabuluhang" field sa isang klase, suriin kung tumutugma ang field ng argumento sa kaukulang field ng object na iyon:

   • Para sa mga primitive na field: na ang uri ay hindi float o double , gamitin ang == operator para sa mga paghahambing.
   • Para sa mga field ng object reference: tawagan ang equals method nang paulit-ulit; para sa mga patlang ng floating point gamitin ang static na paraan Float.compare(float, float); at para sa double field gamitin ang Double.compare(double, double) .
   • Para sa mga field ng array: Ilapat ang mga alituntuning ito sa bawat elemento. Kung ang bawat elemento sa isang array field ay makabuluhan, gamitin ang isa sa mga Arrays.equals() method .
   • Ang ilang mga field ng object reference ay maaaring maglaman ng mga null value . Upang maiwasan ang paghahagis ng NullPointerException , suriin ang mga naturang field para sa pagkakapantay-pantay gamit ang static na paraan Objects.equals(Object, Object) .

5. Kapag natapos mo nang isulat ang iyong equals method , tanungin ang iyong sarili ng tatlong tanong: Symmetric ba ito? Palipat ba ito? Consistent ba siya?

At tandaan, palaging i-override ang hashCode kapag ang overriding ay katumbas ng .