Isang bagay tungkol sa mga array sa Java

Kamusta! Noong nakaraan, sa panahon ng pagsasanay, nagtrabaho kami sa mga solong bagay (o mga primitive na uri). Ngunit paano kung kailangan nating magtrabaho hindi sa isang bagay, ngunit sa isang buong grupo? Halimbawa, gusto naming gumawa ng listahan ng mga kaarawan ng lahat ng empleyado sa aming kumpanya. Dapat itong maglaman, sabihin, 30 linya sa format na: "Andrey Petrov, Enero 25." Ang isang espesyal na istraktura ng data, isang array, ay makakatulong sa amin dito. Kung ihahambing mo ang array sa mga bagay mula sa totoong buhay, ang istraktura nito ay halos kapareho sa isang bank vault na may mga cell: Ang array ay binubuo din ng mga cell. Maaari kang maglagay ng isang bagay sa bawat cell. Sa kasong ito, upang ma-access ang nilalaman kailangan mong malaman ang numero ng cell. Ang array ay nilikha tulad nito:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10]; // array of Java strings

   }
}

Dito nakagawa kami ng hanay ng 10 mga cell. Maaari mong agad na bigyang-pansin ang ilang mga tampok ng array:

1. Nag-iimbak ito ng data ng isang mahigpit na tinukoy na uri. Kung una kaming gumawa ng string array String, hindi na kami makakapag-imbak ng kahit ano pa dito. Tinukoy ang uri ng data kapag lumilikha ng array. Ito ang pinagkaiba nito sa isang safe deposit box, kung saan maaaring iimbak ng kliyente ang anumang gusto niya.
2. Ang isang array ay maaaring mag-imbak ng data ng mga primitive na uri (halimbawa, int), string ( String), o mga bagay ng parehong klase. Mas tiyak, hindi kahit ang mga bagay mismo, ngunit nag-uugnay sa mga bagay na ito.
3. Dapat tukuyin ang laki ng array sa panahon ng paggawa. Hindi mo magagawang tukuyin ito sa ibang pagkakataon o baguhin ang laki nito pagkatapos gawin.

Ipinapahiwatig ng Java na ang isang array ay ginagawa sa pamamagitan ng paggamit ng mga square bracket []sa magkabilang panig ng expression. Maaari silang tukuyin bago ang pangalan ng reference na variable o pagkatapos - ito ay gagana sa alinmang paraan:

//Java arrays of strings, two syntaxes
String [] birthdays = new String[10];
String birthdays [] = new String[10];

Kung gusto mong magsulat ng isang bagay sa isang array, kailangan mong tukuyin ang bilang ng cell kung saan isusulat ang halaga. Ang mga numero ng array ng cell ay nagsisimula sa 0. Ang simula sa zero ay isang karaniwang kasanayan sa programming. Kung mas mabilis kang masanay, mas mabuti :) Iyon ay, kung gusto mong maglagay ng ilang halaga sa unang cell ng array , ito ay ginagawa tulad nito:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
   }
}

Ngayon ang unang cell ng aming array, na naglalaman ng mga kaarawan ng mga kasamahan, ay naglalaman ng isang string na may kaarawan ni Lena. Sa pamamagitan ng pagkakatulad, maaari kang magdagdag ng iba pang mga halaga:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";
   }
}

Pakitandaan: idinagdag namin ang kaarawan ni Olesya sa ikawalong cell (nakalimutan mo na ba kung bakit ang cell No. 7 ang ikawalo?). Kahit na ang lahat ng iba pang mga cell ay hindi napunan. Hindi kinakailangang isulat ang mga halaga sa array sa pagkakasunud-sunod - walang ganoong paghihigpit. Sa kabilang banda, kung sumulat ka sa pagkakasunud-sunod, magiging mas madaling subaybayan ang bilang ng mga libre at inookupahan na mga cell, at walang "butas" na natitira sa array. Kung nais mong makuha ang mga nilalaman ng isang array cell, tulad ng sa kaso ng isang bank cell, kailangan mong malaman ang numero nito. Ginagawa ito tulad nito:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";

       String olesyaBirthday = birthdays[7];
       System.out.println(olesyaBirthday);
   }
}

Output ng console:

Олеся Остапенко, 3 января

Gumawa kami ng variable Stringat sinabi sa compiler: "Hanapin ang cell na may index 7 sa array birthdaysat italaga ang value na nakaimbak doon sa variable String olesyaBirthday." Ganyan talaga ang ginawa niya.

Haba ng array ng Java

Kapag nagtatrabaho sa isang array, madali mong malalaman ang haba nito gamit ang isang espesyal na ari-arian - length.

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

Output ng console:

10

Tandaan:Iniimbak ng property lengthang laki ng array, hindi ang bilang ng mga napunong cell. Ang aming array ay nag-iimbak lamang ng 3 mga halaga, ngunit noong nilikha namin ito, tinukoy namin ang laki = 10 para dito. Ito ang halaga na ibinalik ng field length. Bakit ito maaaring maging kapaki-pakinabang? Well, halimbawa, kung gusto mong mag-print ng isang listahan ng lahat ng mga kaarawan sa console (upang suriin na walang nakalimutan), magagawa mo ito sa isang simpleng loop:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[2] = "Vika Ignatova, July 12";
       birthdays[3] = "Denis Kozlov, September 7";
       birthdays[4] = "Maxim Maslennikov, November 9";
       birthdays[5] = "Roman Baranov, August 14";
       birthdays[6] = "Valery Pyatkina, April 1";
       birthdays[7] = "Olesya Ostapenko, January 3";
       birthdays[8] = "Kostya Gurko, October 19";
       birthdays[9] = "Seryozha Naumov, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

Sa loop lumikha kami ng isang variable ina sa una ay katumbas ng zero. Sa bawat pass, kukunin namin ang cell na may index i mula sa aming array at i-print ang halaga nito sa console. Ang loop ay gagawa ng 10 pag-ulit, at ang mga halaga ng i ay tataas mula 0 hanggang 9 - ayon lamang sa mga indeks ng mga cell ng aming array! Sa ganitong paraan, ipi-print namin ang lahat ng value mula birthdays[0]hanggang hanggang sa console birthdays[9] . Sa katunayan, may mga paraan upang makagawa ng array nang iba. Halimbawa, ang isang hanay ng mga numero intay maaaring gawin tulad nito:

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

Ang pamamaraang ito ay tinatawag na "mabilis na pagsisimula". Ito ay medyo maginhawa dahil agad kaming lumikha ng isang array at punan ito ng mga halaga. Hindi na kailangang tahasang tukuyin ang laki ng array - lengthawtomatikong mapupunan ang field sa panahon ng mabilis na pagsisimula.

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

Output ng console:

9

Java Object Array

Narinig mo na na ang mga array ng mga object at array ng mga primitive ay nakaimbak sa memorya sa ibang paraan. Kunin natin, halimbawa, ang isang hanay ng tatlong bagay Cat:

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");
   }
}

Mayroong ilang mga bagay na dapat maunawaan dito:

1. Sa kaso ng mga primitive, ang mga array ng Java ay nag-iimbak ng maraming partikular na halaga (tulad ng mga numero int). Sa kaso ng mga bagay, ang isang array ay nag-iimbak ng maraming mga sanggunian. Ang array catsay binubuo ng tatlong mga cell, bawat isa ay naglalaman ng isang reference sa isang bagay Cat. Ang bawat isa sa mga link ay tumuturo sa isang address sa memorya kung saan naka-imbak ang bagay na iyon.
2. Ang mga elemento ng array ay nakaimbak sa memorya sa isang bloke. Ginagawa ito para sa mas mahusay at mabilis na pag-access sa kanila. Kaya, ang link catsay tumuturo sa isang bloke sa memorya kung saan ang lahat ng mga bagay - ang mga elemento ng array - ay naka-imbak. A cats[0]- sa isang tiyak na address sa loob ng block na ito.

Mahalagang maunawaan na ang isang array ay hindi lamang maaaring mag-imbak ng mga bagay, ito mismo ay isang bagay.

Array ng mga array o two-dimensional array

Batay dito, nahaharap tayo sa tanong - maaari ba tayong lumikha, halimbawa, hindi isang hanay ng mga string o numero, ngunit isang hanay ng mga array? At ang sagot ay - oo, kaya natin! Ang isang array ay maaaring mag-imbak ng anumang mga bagay sa loob nito, kabilang ang iba pang mga array. Ang ganitong array ay tatawaging two-dimensional. Kung ilarawan mo ito sa isang larawan, ito ay magmumukhang halos kapareho sa isang regular na mesa. Halimbawa, gusto naming gumawa ng array na mag-iimbak ng 3 array ng mga numero intna may 10 cell bawat isa. Ito ay magiging ganito: Ang bawat linya ay kumakatawan sa isang hanay ng mga numero int. Ang unang hanay ay naglalaman ng mga numero mula 1 hanggang 10, ang pangalawa - mula -1 hanggang -10, ang pangatlo - isang hanay ng mga random na numero. Ang bawat isa sa mga array na ito ay naka-imbak sa isang cell ng aming two-dimensional array. Ang pagsisimula ng isang two-dimensional na array sa code ay ganito ang hitsura:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

Ang aming two-dimensional cats array ay nag-iimbak ng 3 array ng 5 cell bawat isa. Kung gusto naming ilagay ang aming object sa ikatlong cell ng pangalawang array, ginagawa namin ito tulad nito:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluff");
}

[1]tumuturo sa pangalawang array, at [2]tumuturo sa ikatlong cell ng array na ito. Dahil ang isang dalawang-dimensional na array ay binubuo ng ilang mga array, upang madaanan ito at mai-print ang lahat ng mga halaga sa console (o punan ang lahat ng mga cell), kailangan namin ng double, nested loop:

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

Sa panlabas na loop (variable i), kami ay nagpapalitan sa pagtawid sa lahat ng arrays na bumubuo sa aming two-dimensional array. Sa inner loop (variable j) inuulit namin ang lahat ng mga cell ng bawat array. Bilang resulta, ang object cats[0][0](unang array, unang cell) ay unang ipapakita sa console, at ang pangalawang object ay cats[0][1](unang array, pangalawang cell). Kapag naubos na ang unang array, , cats[1][0], cats[1][1]at cats[1][2]iba pa ang magiging output. Sa pamamagitan ng paraan, ang mabilis na pagsisimula ay magagamit din para sa mga two-dimensional na array:

int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};

Karaniwan, magsusulat kami ng dalawang-dimensional na array numbersbilang int[3][3], ngunit pinapayagan kami ng paraang ito na agad na tukuyin ang mga halaga. Bakit maaaring kailanganin ang isang two-dimensional array? Well, halimbawa, sa tulong nito madali mong muling likhain ang sikat na larong "Battleship": Ang istraktura ng playing field sa "Battleship" ay tulad na madali itong mailarawan: isang two-dimensional na hanay ng 10 array, 10 cell bawat isa . Lumilikha ka ng dalawang ganoong array - para sa iyong sarili at sa iyong kalaban:

int [][] seaBattle = new int[10][10];
int [][] seaBattle2 = new int[10][10];

Pinupunan mo ng ilang halaga (halimbawa, mga numero o senyales *) ang mga cell kung saan matatagpuan ang iyong mga barko, at pagkatapos ay ikaw at ang iyong kalaban ay humalili sa pagtawag sa mga numero ng cell:

• seaBattle[6][5]!
• nakaraan! seaBattle2[6][6]!
• nasugatan!
• seaBattle2[6][7]!
• nasugatan!
• seaBattle2[6][8]!,
• pinatay!

Mga karagdagang mapagkukunan tungkol sa mga array

Gustong malaman ang higit pa tungkol sa mga array? Mangyaring tingnan ang mga artikulo sa ibaba. Mayroong maraming kawili-wili at kapaki-pakinabang na impormasyon sa paksang ito.

1. Mga Array sa Java - isang detalyadong artikulo tungkol sa mga array, ang kanilang paglikha, pagsisimula at paggamit. Sa mga halimbawa.
2. Ang klase ng Arrays at ang paggamit nito - inilalarawan ng artikulo ang ilang pamamaraan ng klaseArray
3. Ang Arrays ay ang unang JavaRush lecture na nakatuon sa mga array.
4. Multidimensional arrays - isang detalyadong artikulo tungkol sa multidimensional arrays na may mga halimbawa.
5. Ibalik ang isang zero-length na array, hindi null - Ang may-akda ng Effective Programming na si Joshua Bloch ay nagsasalita tungkol sa kung paano mas mahusay na ibalik ang mga walang laman na array.

Ito ay nagtatapos sa aming unang pagkakakilala sa mga array, ngunit ito ay simula lamang ng pakikipag-ugnayan sa kanila. Sa mga sumusunod na lektura makikita natin ang mga kagiliw-giliw na paraan upang magamit ang mga ito, at malalaman din kung anong mga built-in na function ang mayroon ang Java para sa mas maginhawang pagtatrabaho sa istruktura ng data na ito :)