Mga array ng Java

Mga array

Ang array ay isang istraktura ng data na nag-iimbak ng mga halaga ng parehong uri. Ang isang indibidwal na elemento ng array ay ina-access gamit ang isang integer index. Halimbawa, kung ang a ay isang array ng mga integer, kung gayon ang value ng expression na a[i] ay katumbas ng i-th integer sa array. Ang isang array ay ipinahayag tulad ng sumusunod: una, ang uri ng array ay ipinahiwatig, iyon ay, ang uri ng mga elemento na nilalaman sa array, na sinusundan ng isang pares ng walang laman na square bracket, at pagkatapos ay ang pangalan ng variable. Halimbawa, narito kung paano magdeklara ng array na binubuo ng mga integer:

int[] a;

Gayunpaman, ang pahayag na ito ay nagdedeklara lamang ng isang variable а, nang hindi ito sinisimulan ng isang aktwal na array. Upang lumikha ng isang array, kailangan mong gamitin ang operator new.

int[] a = new int [100];

Lumilikha ang operator na ito ng array ng 100 integer. Ang mga elemento ng array na ito ay binibilang mula 0 hanggang 99 (hindi mula 1 hanggang 100). Kapag nalikha na, maaaring punan ang array, halimbawa, gamit ang isang loop.

int[] а = new int[100];
for (int i = 0; i < 100; i++)
 a[i] = i; //Заполняет массив числами от 0 до 99

Kung susubukan mong i-access ang isang elemento а [100](o anumang iba pang elemento na ang index ay nasa labas ng hanay na 0 hanggang 99) sa pamamagitan ng paglikha ng isang hanay ng 100 elemento, ang program ay magwawakas dahil ang isang array index na wala sa saklaw ay magaganap . Upang bilangin ang bilang ng mga elemento sa isang array, gamitin ang Array name method .length. Halimbawa,

for (int i = 0; i < a.length; i++, System.out.println(a[i]));

Kapag nalikha ang isang array, imposibleng baguhin ang laki nito (bagaman maaari mong, siyempre, baguhin ang mga indibidwal na elemento nito). Kung kailangan mong baguhin ang laki ng isang array nang madalas sa panahon ng pagpapatupad ng programa, mas mahusay na gumamit ng isa pang istraktura ng data na tinatawag na isang listahan ng array. Ang isang array ay maaaring ideklara sa dalawang paraan:

int[] a;
or
int a[];

Karamihan sa mga Java programmer ay mas gusto ang unang istilo dahil mas malinaw nitong pinaghihiwalay ang uri ng array int [](integer array) mula sa variable na pangalan.

Array initializers at unnamed arrays

Ang Java ay may pasilidad para sa sabay-sabay na paglikha ng isang array at pagsisimula nito. Narito ang isang halimbawa ng tulad ng isang syntactic na istraktura:

int[] smallPrimes = {2, 3, 5, 7, 11, 13};

Tandaan na sa kasong ito ay hindi na kailangang gamitin ang operator new. Bilang karagdagan, maaari mo ring simulan ang isang hindi pinangalanang array:

new int[] {16, 19, 23, 29, 31, 37}

Ang expression na ito ay naglalaan ng memorya para sa isang bagong array at pinupuno ito ng mga numerong tinukoy sa mga curly braces. Sa kasong ito, ang kanilang numero ay kinakalkula at, nang naaayon, ang laki ng array ay tinutukoy. Ang syntactic construction na ito ay maginhawang gamitin upang muling simulan ang isang array nang hindi gumagawa ng bagong variable. Halimbawa, ang expression

smallPrimes = new int{17, 19, 23, 29, 31, 37};

ay isang pinaikling ekspresyon

int[] anonymous = {17, 19, 23, 29, 31, 37};
smallPrimes = anonymous;

Maaari kang lumikha ng array ng zero size. Ang ganitong array ay maaaring maging kapaki-pakinabang kapag nagsusulat ng isang paraan na sinusuri ang isang array na lumalabas na walang laman. Ang isang zero-length array ay ipinahayag tulad ng sumusunod:

new тип Элементов[]

Tandaan na ang naturang array ay hindi katumbas ng isang bagay null.

Pagkopya ng mga array

Ang isang array ay maaaring kopyahin sa isa pa, ngunit ang parehong mga variable ay tumutukoy sa parehong array.

int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; //Теперь элемент smallPrimes[5]также equals 12

Ang resulta ay ipinapakita sa Fig. 3.1. Kung kailangan mong kopyahin ang lahat ng mga elemento ng isang array sa isa pa, dapat mong gamitin ang arraycopy method mula sa class System. Ang tawag nito ay ganito:

System.arraycopy(from, fromlndex, to, tolndex, count);

Ang array toay dapat na sapat na malaki upang maglaman ng lahat ng mga elemento na makokopya. Fig.3.1. Pagkopya ng array Halimbawa, ang mga operator na ipinapakita sa ibaba, ang mga resulta nito ay ipinapakita sa Fig. 3.2, lumikha ng dalawang array at pagkatapos ay kopyahin ang huling apat na elemento ng unang array sa pangalawa. Ang pagkopya ay nagsisimula sa pangalawang posisyon sa source array, at ang mga kinopyang elemento ay inilalagay sa destination array simula sa ikatlong posisyon.

int[] smallPrimes = {2, 3, 5, 7, 11, 13};
int[] luckyNumbers = {1001, 1002, 1003, 1004, 1005, 1006, 1007};
System.аrrаусору(smallPrimes, 2, luckyNumbers, 3, 4);
for (int i = 0; i < luckyNumbers.length; i++)
System.out.println(i + ": " + luckyNumbers[i]);

Ang pagpapatupad ng mga pahayag na ito ay nagbubunga ng sumusunod na resulta.

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13

kanin. 3.2. Pagkopya ng Mga Elemento ng Array Ang isang array sa Java ay makabuluhang naiiba mula sa isang array sa C++. Gayunpaman, ito ay halos kapareho ng isang pointer sa isang dynamic na array. Nangangahulugan ito na ang operator

int[] a = new int[100]; //Java

ay katumbas ng operator

int* = new int[100]; //C++,
а не
int a[100]; //C++

Sa Java, []sinusuri ng default na operator ang hanay ng mga pagbabago sa index. Bilang karagdagan, ang Java ay walang pointer arithmetic-hindi mo maaaring dagdagan ang isang pointer upang ma-access ang susunod na elemento ng isang array. Link sa pinagmulan: Java arrays