Isang bagay tungkol sa mga array

Hi! Dati sa iyong pagsasanay, nagtrabaho kami sa mga solong bagay (at mga primitive na uri). Ngunit paano kung kailangan nating magtrabaho kasama ang isang buong pangkat ng mga bagay sa halip na isa lamang? Halimbawa, sabihin nating gusto naming gumawa ng listahan ng mga kaarawan ng lahat ng empleyado sa aming kumpanya. Dapat itong maglaman ng 30 string na naka-format tulad ng sumusunod: "Sarah Huffman, Enero 25" Makikinabang kami mula sa isang espesyal na istraktura ng data na tinatawag na array . Kung ihahambing natin ang isang array sa isang tunay na bagay, ito ay halos kapareho sa isang bank vault na may mga safety deposit box: Ang array ay binubuo din ng "mga kahon". Maaari kang maglagay ng isang bagay (isang elemento) sa bawat kahon. Upang ma-access ang isang elemento, kailangan mong malaman ang numero ng kahon nito (index). Ito ay kung paano nilikha ang isang array:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

Dito kami lumikha ng isang array na mayroong 10 elemento. Maaari mong agad na tandaan ang ilang mga tampok ng array:

1. Nag-iimbak ito ng mga elemento ng isang mahusay na tinukoy na uri ng data . Kung gagawa kami ng String array, hindi na kami makakapag-imbak ng kahit ano pa dito. Ang uri ng data ay tinukoy kapag ang array ay ginawa . Ito ay kung saan ito ay naiiba sa isang safety deposit box (kung saan ang isang customer ay maaaring mag-imbak ng kung ano ang gusto niya).


2. Dapat tukuyin ang laki nito kapag ginawa ang array . Hindi mo ito maaaring ipahiwatig sa ibang pagkakataon o baguhin ang laki nito pagkatapos magawa ang array .

Ang katotohanan na tayo ay lumilikha ng isang array ay ipinahiwatig ng mga square bracket sa magkabilang panig ng expression. Maaari silang tukuyin bago o pagkatapos ng pangalan ng reference variable. Alinmang paraan ay gagana:

String [] birthdays = new String[10];
String birthdays [] = new String[10];

Kung gusto mong magsulat ng isang bagay sa isang array, kailangan mong tukuyin ang index ng kahon kung saan isusulat ang halaga. Ang mga kahon sa isang array ay binibilang simula sa 0. Ang pagbibilang simula sa zero ay isang pangkaraniwang kasanayan sa programming. Kung mas mabilis kang masanay, mas mabuti :) Ibig sabihin, kung gusto mong maglagay ng ilang halaga sa unang kahon , gagawin mo ito:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
   }
}

Ngayon ang kaarawan ni Jana ay naka-imbak sa unang cell ng aming hanay ng mga kaarawan ng empleyado: Maaari kang magdagdag ng iba pang mga halaga sa katulad na paraan:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

Tandaan na idinagdag namin ang kaarawan ni Rosie sa ikawalong kahon (hindi mo nakalimutan kung bakit ang Box No. 7 ang ikawalong kahon, hindi ba?) . Makikita mo na hindi pa namin napuno ang lahat ng iba pang mga cell. Hindi namin kailangang magsulat ng mga halaga sa isang array sa pagkakasunud-sunod. Walang ganoong pangangailangan. Siyempre, ang pagsusulat ng mga elemento sa pagkakasunud-sunod ay ginagawang mas madaling subaybayan kung gaano karaming mga kahon ang libre at kung gaano karami ang inookupahan, at pinipigilan nito ang array na magkaroon ng "mga butas". Kung gusto mong makuha ang mga nilalaman ng isa sa mga kahon, kung gayon (tulad ng isang safety deposit box) kailangan mong malaman ang numero nito. Ito ay kung paano ito ginawa:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

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

Output ng console: Rosie Mills, Enero 3 Gumawa kami ng Stringvariable at sinabi sa compiler: "Hanapin ang kahon na may index 7 sa array ng mga kaarawan , at italaga ang value na nakapaloob doon sa Stringvariable na rosieBirthday ". At iyon nga ang ginawa nito. Kapag nagtatrabaho sa mga array, madali nating mahahanap ang haba ng mga ito gamit ang isang espesyal na property: length .

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

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

Output ng console: 10 Tandaan: lengthIniimbak ng property ang laki ng array, hindi ang bilang ng mga kahon na puno. Ang aming array ay nag-iimbak lamang ng 3 mga halaga, ngunit ipinahiwatig namin ang laki nito bilang 10 noong ginawa namin ito. At ito mismo ang halaga na lengthibinabalik ng field. Bakit ito magiging kapaki-pakinabang? Well, ipagpalagay na gusto mong magpakita ng isang listahan ng lahat ng mga kaarawan (upang i-verify 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] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

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

Sa loop, ipinapahayag namin ang variable i, na sinisimulan sa zero. Sa bawat pass, nakukuha namin ang elementong may index i mula sa aming array at ipinapakita ang halaga nito. Ang loop ay gagawa ng 10 pag-ulit, at ako ay tataas mula 0 hanggang 9—at ang mga numero ay nangyayari na ang mga indeks ng mga elemento ng aming array! Bilang resulta, ipapakita namin ang lahat ng value mula sa mga kaarawan[0] hanggang sa mga kaarawan[9] Sa totoo lang, may isa pang paraan upang makagawa ka ng array. Halimbawa, maaari kang lumikha ng isang hanay ng intmga s 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 "shortcut initialization". Ito ay medyo maginhawa, dahil sabay-sabay kaming lumikha ng isang array at punan ito ng mga halaga. Hindi namin kailangang tahasang tukuyin ang laki ng array: sa pagsisimula ng shortcut, lengthawtomatikong itinatakda ang field.

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 Ngayon, kaunti tungkol sa kung paano iniimbak ang mga array sa memorya. Sabihin nating mayroon tayong hanay ng tatlong Catbagay:

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("Behemoth");
       cats[2] = new Cat("Lionel Messi");
   }
}

Kailangan mong maunawaan ang ilang bagay dito:

1. Sa kaso ng mga primitive, ang isang array ay nag-iimbak ng isang set ng mga partikular na halaga (hal. ints). Sa kaso ng mga bagay, ang isang array ay nag-iimbak ng isang hanay ng mga sanggunian .
   Ang catsarray ay binubuo ng tatlong elemento, ang bawat isa ay isang sanggunian sa isang Catbagay. Ang bawat isa sa mga sanggunian ay tumuturo sa address ng memorya kung saan naka-imbak ang kaukulang bagay.

2. Ang mga elemento ng array ay nakaayos sa isang bloke sa memorya. Ginagawa ito upang payagan silang ma-access nang mabilis at mahusay.

Kaya, catstinutukoy ang bloke ng memorya kung saan ang lahat ng mga bagay (mga elemento ng array) ay naka-imbak. Cats[0]tumutukoy sa isang partikular na address sa loob ng bloke na ito. Mahalagang maunawaan na ang isang array ay hindi lamang nag-iimbak ng mga bagay: ito ay isang bagay mismo. Ito ay humahantong sa amin na tanungin kung maaari kaming lumikha hindi lamang ng array ng mga string o numero, ngunit din ng mga array ng mga array . At ang sagot ay oo, kaya natin! Ang isang array ay maaaring mag-imbak ng anumang mga bagay, kabilang ang iba pang mga array. Ang ganitong array ay tinatawag na two-dimensional . Kung irepresenta natin ito nang biswal, ito ay halos kapareho sa isang ordinaryong mesa. Ipagpalagay, gusto naming lumikha ng isang array ng 3 array na maaaring mag-imbak ang bawat isa ng 10 ints. Ito ay magiging ganito: Ang bawat linya ay kumakatawan sa isang intarray. Ang unang hanay ay naglalaman ng mga numero mula 1 hanggang 10, ang pangalawang hanay — mula -1 hanggang -10, at ang pangatlo — isang hanay ng mga random na numero. Ang bawat isa sa mga array na ito ay naka-imbak sa mga kahon ng aming two-dimensional array. Sa code, ganito ang hitsura ng pagsisimula ng isang two-dimensional array:

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

Ang aming two-dimensional array cats ay nag-iimbak ng 3 array na may 5 box sa bawat array. Kung nais naming maglagay ng isang bagay sa ikatlong kahon ng pangalawang hanay, gagawin namin ito:

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

[1]ay nagpapahiwatig ng pangalawang array, at [2]nagpapahiwatig ng ikatlong kahon ng array na iyon. Dahil ang isang two-dimensional na array ay binubuo ng ilang mga array, upang maulit ito at maipakita ang lahat ng value nito (o ma-populate ang lahat ng elemento nito), kailangan namin ng 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), inuulit namin ang lahat ng array sa aming two-dimensional array. Sa inner loop (variable j), dumaan kami sa lahat ng elemento ng bawat array. Bilang resulta, ang mga pusa[0][0] (unang hanay, unang elemento) ay unang ipapakita, na susundan ng mga pusa[0][1] (unang hanay, pangalawang elemento). Pagkatapos naming dumaan sa unang hanay, ipapakita namin ang mga pusa[1][0] , pusa[1][1] , pusa[1][2] , atbp. Oo nga pala, sinusuportahan din ng mga two-dimensional na array shorthand initialization:

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

Karaniwan, idedeklara namin ang two-dimensional array numbersbilang isang int[3][3], ngunit ang shorthand na ito ay nagbibigay-daan sa amin na tukuyin kaagad ang mga halaga. Bakit kailangan mo ng two-dimensional array? Well, maaari kang gumamit ng isa para madaling muling likhain ang sikat na "Battleship" na laro: Sa "Battleship", ang istraktura ng playing field ay madaling ilarawan: isang two-dimensional na hanay ng 10 array na may 10 elemento bawat isa. Lumilikha ka ng dalawa sa mga array na ito (isa para sa iyo at isa para sa iyong kalaban)

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

gumamit ng ilang mga halaga (hal. mga numero o simbolo) upang i-populate ang mga elemento na tumutugma sa lokasyon ng iyong mga barko, at pagkatapos ay magpalitan ng pagtawag sa mga coordinate para sa mga partikular na elemento:

• battleshipBoard1[0][2]!
• Miss! battleshipBoard2[2][4]!
• Hit!
• battleshipBoard2[2][5]!
• Hit!
• battleshipBoard2[2][6]!,
• Lubog!

Ito ay nagtatapos sa aming unang pagpapakilala ng mga array, ngunit ito ay simula pa lamang ng aming pakikipag-ugnayan sa kanila. Sa mga sumusunod na aralin, makikita natin ang mga kawili-wiling paraan na magagamit ang mga ito, at malalaman din kung anong mga built-in na function na mayroon ang Java upang hayaan tayong magtrabaho sa istruktura ng data na ito nang mas maginhawa :)