Nuances ng pagtatrabaho sa mga arrays

1. Mga array sa memorya

Sa mga nakaraang halimbawa, ang mga ilustrasyon ay medyo hindi tumpak.

Kapag lumilikha ng mga array (tulad ng kapag lumilikha ng mga string), dalawang magkahiwalay na bloke ng memorya ang inilalaan: isa para sa pag-iimbak ng array (lalagyan) mismo at isang pangalawang bloke para sa variable na nag-iimbak ng address nito . Ang larawan sa ibaba ay kumakatawan sa paglilinaw na ito:

Ang memorya na inilaan para sa hanay ng 10 intmga elemento at ang int[]variable na nag-iimbak ng address ng intarray, ay ipinapakita sa berde.

Para sa paghahambing, ang isang ordinaryong intvariable na nag-iimbak ng halaga 199ay ipinapakita sa asul.

Ito ay isang maliit na nakapagpapaalaala sa pag-iimbak ng mga string sa memorya, hindi ba?

Tama yan, strings. At tulad ng kapag nagtatrabaho ka sa mga string, maaari kang magtalaga ng mga variable ng array sa isa't isa:

int[] a = new int[10];
a[2] = 4;
a[7] = 9;
int[] b = a;

a[9] = b[2] + a[7];

Ang array object ay nananatili sa mismong lugar kung saan ito naroroon, at ang aat bmga variable ay nag-iimbak ng parehong address (reference) sa parehong bagay. Tingnan ang larawan:

2. Higit pang mga detalye tungkol sa pagtatrabaho sa mga array

Maaari kang lumikha ng isang hanay ng mga elemento ng ganap na anumang uri. Upang gawin ito, isulat lamang ang mga square bracket pagkatapos ng pangalan ng uri. Sa pangkalahatan, ang paglikha ng isang array ay ganito ang hitsura:

type[] name = new type[number];

Kung saan ang uri ay ang uri ng mga elemento na aming iimbak sa array. Ang pangalan ay ang pangalan ng variable na gagamitin namin upang sumangguni sa array, at ang numero ay ang bilang ng mga cell sa array.

Ang halimbawa sa itaas ay ang canonical form para sa paglikha ng array variable at array object. Sa katotohanan, ito ay dalawang magkahiwalay na entity.

Maaari kang lumikha ng isang array variable nang hiwalay mula sa isang array object:

type[] name;
name = new type[number];

At isa pang punto na hindi gaanong mahalaga:

Mga halimbawa:

int n = 100;
int[] a = new int[n];

int n = 100;
int[] a = new int[n * 2 + 3];

int n = 100;
int[] a = new int[n];
a[n-1] = 2;
a[n-2] = 3;
a[n/5] = a[n-1] + a[n-2]

// a[99] = 2;
// a[98] = 3;
// a[20] = a[99] + a[98];

3. Haba ng array

Tulad ng nakita mo sa nakaraang halimbawa, maaari kang lumikha ng isang array variable nang mag-isa at pagkatapos ay magtalaga ng isang halaga (isang reference sa isang array object) dito sa isang lugar sa code. Maaari mo ring gawin ito:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];

At ngayon ano pa ang maaari mong gawin sa ganoong array? Paano mo malalaman kung ilang elemento ang nasa loob nito?

Upang makatulong dito, ang mga array ay may espesyal na property (variable) na pinangalanang length. Maaari mong mahanap ang haba ng isang array gamit ang expression na ito:

array.length;

Narito arrayang pangalan ng array variable at lengthang pangalan ng property ng array. Ang halaga ng lengthari-arian ay hindi mababago: ang lengthari-arian mismo ay maaaring italaga sa iba pang mga variable, ngunit walang maaaring italaga dito (kung susubukan mong gawin ito, ang programa ay hindi mag-compile).

Maaari tayong magpatuloy sa nakaraang halimbawa tulad nito:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];
for (int i = 0; i < array.length; i++)
{
   System.out.println(array[i]);
}

4. Buod ng mga katotohanan tungkol sa mga array sa Java

Recap natin ang alam natin tungkol sa mga array:

Katotohanan 1. Ang array ay binubuo ng maraming cell.

Katotohanan 2. Ina-access mo ang isang partikular na cell sa pamamagitan ng paggamit ng numero nito (index).

Katotohanan 3. Ang lahat ng mga cell ay may parehong uri.

Katotohanan 4. Ang paunang halaga ng lahat ng mga cell ay 0 (kung ang mga cell ay nag-iimbak ng mga numero), null(kung ang mga cell ay nag-iimbak ng mga sanggunian ng bagay), o false(kung ang mga cell ay nag-iimbak booleanng mga halaga). Matututo ka pa tungkol sa mga default na halaga sa kabanatang ito .

Ang katotohanan 5. String[] list ay deklarasyon lamang ng isang variable. Hindi nito ginagawa ang container (array object) mismo. Para magamit ang variable, kailangan mo munang gumawa ng array (container) at italaga ito sa variable. Tingnan ang halimbawa sa ibaba.

Katotohanan 6. Kapag gumawa tayo ng array object (container), dapat nating ipahiwatig kung gaano ito kalaki, ibig sabihin, kung gaano karaming mga cell ang nilalaman nito. Ginagawa ito sa isang pahayag tulad ng: new TypeName[n];

Katotohanan 7. Ang haba ng isang array ay matatagpuan gamit ang .lengthproperty.

Katotohanan 8. Pagkatapos gumawa ng array, hindi mo mababago ang uri ng mga elemento nito o ang bilang ng mga elemento na iniimbak nito.

String s;
String[] list;

list = new String[10];
int n = list.length;

list = new String[0];

list = null;
System.out.println(list[1]);

list = new String[10];
System.out.println(list[10]);