Mga array sa Java

Isipin ang mga cell sa isang storage room. Ang bawat isa ay may sariling numero, at ang bawat isa ay naglalaman ng ilang uri ng bagay na "Luggage". O isang listahan ng alak, kung saan ang lahat ng uri ng alak ay binibilang at kapag nag-order ka, kailangan mo lamang ibigay ang numero ng inumin. O isang listahan ng mga mag-aaral sa isang grupo, kung saan ang mag-aaral na "Andreev" ay isusulat sa unang cell, at "Yakovlev" sa huling cell. O isang listahan ng mga pasahero ng eroplano, na ang bawat isa ay nakatalaga ng upuan na may partikular na numero. Sa Java, upang gumana sa mga katulad na istruktura, iyon ay, maraming homogenous na data, ang mga array sa Java ay madalas na ginagamit.

Ano ang array?

Ang array ay isang istraktura ng data na nag-iimbak ng mga elemento ng parehong uri. Maaari itong isipin bilang isang hanay ng mga may bilang na mga cell, na ang bawat isa ay maaaring maglaman ng ilang data (isang elemento ng data bawat cell). Ang pag-access sa isang partikular na cell ay isinasagawa sa pamamagitan ng numero nito. Ang bilang ng isang elemento sa isang array ay tinatawag ding index . Sa kaso ng Java, ang array ay homogenous, iyon ay, lahat ng mga cell nito ay mag-iimbak ng mga elemento ng parehong uri. Kaya, ang isang hanay ng mga integer ay naglalaman lamang ng mga integer (halimbawa, ng uri int ), isang hanay ng mga string ay naglalaman lamang ng mga string, isang hanay ng mga elemento ng klase ng Aso na aming nilikha ay maglalaman lamang ng mga bagay na Aso . Iyon ay, sa Java hindi tayo maaaring maglagay ng integer sa unang cell ng isang array, isang String sa pangalawa , at isang "aso" sa pangatlo.

Array Deklarasyon

Paano magpahayag ng isang array?

Tulad ng anumang variable, dapat ideklara ang isang array sa Java. Magagawa mo ito sa isa sa dalawang paraan. Ang mga ito ay katumbas, ngunit ang una ay mas pare-pareho sa estilo ng Java. Ang pangalawa ay ang legacy ng wikang C (maraming C programmer ang lumipat sa Java, at para sa kanilang kaginhawahan ay may naiwan na alternatibong paraan). Ipinapakita ng talahanayan ang parehong mga paraan upang magdeklara ng array sa Java: Sa parehong mga kaso, ang dataType ay ang uri ng mga variable sa array. Sa mga halimbawa, ipinahayag namin ang dalawang array. Ang isa ay mag-iimbak ng mga integer ng uri ng int , ang isa ay mag-iimbak ng mga bagay na may uri ng Bagay . Kaya, kapag ang isang array ay ipinahayag, ito ay may isang pangalan at isang uri (ang uri ng array variable). arrayName ay ang pangalan ng array.

Paglikha ng Array

Paano lumikha ng isang array?

Tulad ng anumang iba pang bagay, maaari kang lumikha ng isang Java array, iyon ay, magreserba ng memory space para dito, gamit ang bagong operator . Ginagawa ito tulad nito:

new typeOfArray [length];

Kung saan ang typeOfArray ay ang uri ng array, at ang haba ay ang haba nito (iyon ay, ang bilang ng mga cell), na ipinahayag sa mga integer ( int ). Gayunpaman, dito lamang kami naglaan ng memorya para sa array, ngunit hindi naiugnay ang nilikhang array sa anumang naunang ipinahayag na variable. Karaniwan ang isang array ay unang ipinahayag at pagkatapos ay nilikha, halimbawa:

int[] myArray; // array declaration
myArray = new int[10]; // creation, that is, allocation of memory for an array of 10 elements of type int

Dito ay nagpahayag kami ng isang hanay ng mga integer na tinatawag na myArray , at pagkatapos ay ipinahayag na ito ay binubuo ng 10 mga cell (bawat isa ay mag-iimbak ng isang integer). Gayunpaman, mas karaniwan na gumawa ng array kaagad pagkatapos ng deklarasyon gamit ang shorthand syntax na ito:

int[] myArray = new int[10]; // declaration and allocation of memory "in one bottle"

Tandaan:Pagkatapos gumawa ng array gamit ang new , ang mga cell nito ay puno ng mga default na value. Para sa mga uri ng numero (tulad ng sa aming halimbawa) ito ay magiging 0, para sa boolean - false , para sa mga uri ng sanggunian - null . Kaya, pagkatapos ng operasyon

int[] myArray = new int[10];

nakakakuha kami ng hanay ng sampung integer, at hanggang sa magbago ito sa panahon ng programa, ang bawat cell ay naglalaman ng 0.

Haba ng array sa Java

Tulad ng sinabi namin sa itaas, ang haba ng isang array ay ang bilang ng mga elemento kung saan ang array ay dinisenyo. Hindi na mababago ang haba ng isang array kapag nalikha na ito. Tandaan:Sa Java, ang mga elemento ng array ay binibilang simula sa zero. Ibig sabihin, kung mayroon tayong array ng 10 elemento, ang unang elemento ng array ay magkakaroon ng index 0, at ang huli ay magkakaroon ng index 9. Maa-access mo ang haba ng array gamit ang length variable . Halimbawa:

int[] myArray = new int[10]; // created an array of integers with 10 elements and named it myArray
System.out.println(myArray.length); // printed to the console the length of the array, that is, the number of elements that we can put in the array

Output ng programa:

Pagsisimula ng array at pag-access sa mga elemento nito

Kung paano lumikha ng isang array sa Java ay malinaw na. Pagkatapos ng pamamaraang ito, hindi kami nakakakuha ng isang walang laman na array, ngunit isang array na puno ng mga default na halaga. Halimbawa, sa kaso ng int ang mga ito ay magiging 0, at kung mayroon kaming array na may data ng isang uri ng sanggunian, kung gayon bilang default, ang null ay nakasulat sa bawat cell . Ina-access namin ang isang elemento ng array (iyon ay, nagsusulat kami ng isang halaga dito o ipinapakita ito sa screen o nagsasagawa ng ilang operasyon dito) sa pamamagitan ng index nito. Ang pagsisimula ng isang array ay pinupuno ito ng partikular na data (hindi bilang default). Halimbawa: gumawa tayo ng array ng 4 na season at punan ito ng mga string value - ang mga pangalan ng mga season na ito.

String[] seasons  = new String[4]; /* declared and created an array. Java allocated memory for an array of 4 strings, and now each cell is null (because the string is a reference type)*/

seasons[0] = "Winter"; /* in the first cell, that is, in the cell with a zero number, we wrote the string Winter. Here we get access to the zero element of the array and write a specific value there */
seasons[1] = "Spring"; // do the same procedure with cell number 1 (second)
seasons[2] = "Summer"; // ...number 2
seasons[3] = "Autumn"; // and with the last one, number 3

Ngayon lahat ng apat na cell ng aming array ay naglalaman ng mga pangalan ng mga season. Ang pagsisimula ay maaari ding gawin sa ibang paraan, na pinagsasama ang pagsisimula at deklarasyon:

String[] seasons  = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Bukod dito, ang bagong operator ay maaaring tanggalin:

String[] seasons  = {"Winter", "Spring", "Summer", "Autumn"};

Paano magpakita ng array sa Java sa screen?

Maaari kang magpakita ng mga elemento ng array sa screen (iyon ay, sa console), halimbawa, gamit ang isang for loop . Ang isa pang mas maikling paraan upang magpakita ng array sa screen ay tatalakayin sa talata na "Mga kapaki-pakinabang na pamamaraan para sa pagtatrabaho sa mga array" sa ibaba. Sa ngayon, tingnan natin ang isang halimbawa na may cyclic na output ng isang array:

String[] seasons  = new String[] {"Winter", "Spring", "Summer", "Autumn"};
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]);
}

Bilang resulta, ilalabas ng programa ang sumusunod na resulta:

Isang-dimensional at multidimensional na mga array ng Java

Paano kung gusto nating lumikha ng hindi isang array ng mga numero, isang array ng mga string, o isang array ng ilang mga bagay, ngunit isang array ng mga arrays? Pinapayagan ka ng Java na gawin ito. Ang pamilyar na array int[] myArray = new int[8] ay isang tinatawag na one-dimensional array. At ang isang hanay ng mga array ay tinatawag na two-dimensional. Ito ay tulad ng isang talahanayan na may isang row number at isang column number. O, kung natutunan mo ang simula ng linear algebra, sa isang matrix. Bakit kailangan ang mga ganitong array? Sa partikular, para sa pagprograma ng parehong mga matrice at talahanayan, pati na rin ang mga bagay na kahawig ng mga ito sa istraktura. Halimbawa, ang playing field para sa chess ay maaaring tukuyin bilang isang 8x8 array. Ang isang multidimensional array ay ipinahayag at nilikha tulad ng sumusunod:

int[][] myTwoDimentionalArray = new int [8][8];

May eksaktong 64 na elemento sa array na ito: myTwoDimentionalArray[0][0], myTwoDimentionalArray[0][1], myTwoDimentionalArray[1][0], myTwoDimentionalArray[1][1]at iba pa hanggang sa myTwoDimentionalArray[7][7]. Kaya kung gagamitin natin ito upang kumatawan sa isang chessboard, kakatawanin ng cell A1 ang myTwoDimentionalArray[0][0], at kakatawanin ng E2 ang myTwoDimentionalArray[4][1]. Kung saan mayroong dalawa, mayroong tatlo. Sa Java, maaari mong tukuyin ang isang array ng mga arrays... isang array ng mga arrays ng mga arrays, at iba pa. Totoo, ang tatlong-dimensional at higit pang mga array ay bihirang ginagamit. Gayunpaman, gamit ang isang three-dimensional array, maaari kang mag-program, halimbawa, isang Rubik's cube.

Mga kapaki-pakinabang na pamamaraan para sa pagtatrabaho sa mga array

Upang gumana sa mga array sa Java mayroong isang klase na java.util.Arrays (ang mga array sa Ingles ay nangangahulugang "mga array"). Sa pangkalahatan, ang mga sumusunod na operasyon ay madalas na ginagawa sa mga array: pagpuno ng mga elemento (pagsisimula), pagkuha ng isang elemento (ayon sa numero), pag-uuri at paghahanap. Ang paghahanap at pag-uuri ng mga array ay isang hiwalay na paksa. Sa isang banda, napaka-kapaki-pakinabang na magsanay at magsulat ng ilang mga algorithm sa paghahanap at pag-uuri sa iyong sarili. Sa kabilang banda, ang lahat ng pinakamahuhusay na kagawian ay naisulat na at naisama na sa mga aklatan ng Java, at maaaring legal na gamitin. Narito ang tatlong kapaki-pakinabang na pamamaraan ng klase na ito

Pagbukud-bukurin ang isang array

Ang pamamaraan void sort(int[] myArray, int fromIndex, int toIndex)ay nag-uuri ng isang hanay ng mga integer o ang subarray nito sa pataas na pagkakasunud-sunod.

Naghahanap ng array para sa gustong elemento

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key). Hinahanap ng pamamaraang ito ang pangunahing elemento sa isang nakaayos na array myArray o subarray, simula fromIndex at nagtatapos sa toIndex . Kung natagpuan ang elemento, ibabalik ng pamamaraan ang index nito, kung hindi - (-fromIndex)-1.

Pag-convert ng array sa isang string

Ang pamamaraan String toString(int[] myArray)ay nagko-convert ng array sa isang string. Ang bagay ay na sa Java arrays ay hindi override toString() . Nangangahulugan ito na kung susubukan mong ipakita ang buong array (sa halip na elemento sa pamamagitan ng elemento, tulad ng sa “ Pag-print ng Array sa Screen ”) sa screen nang direkta ( System.out.println(myArray)), makukuha mo ang pangalan ng klase at ang hexadecimal hash code ng array (ito ay tinukoy ng Object.toString() ). Kung ikaw ay isang baguhan, maaaring hindi mo maintindihan ang paliwanag ng pamamaraan toString. Sa unang yugto hindi ito kinakailangan, ngunit gamit ang pamamaraang ito ang output ng array ay pinasimple. Pinapadali ng Java ang pagpapakita ng array nang hindi gumagamit ng loop. Higit pa tungkol dito sa halimbawa sa ibaba.

Halimbawa sa pag-uuri, binarySearch at toString

Gumawa tayo ng hanay ng mga integer, ipakita ito sa screen gamit ang toString , pag-uri-uriin ito gamit ang paraan ng pag-uuri , at maghanap ng ilang numero dito.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; //declaring and initializing the array
        System.out.println(array);//trying to display our array on the screen without the toString method - we get a hexadecimal number
        System.out.println(Arrays.toString(array));//печатаем массив "правильно"
        Arrays.sort(array, 0, 4); // sort the entire array from zero to the fourth member
        System.out.println(Arrays.toString(array));//print the sorted array to the screen
        int key = Arrays.binarySearch(array, 5); // ищем key - число 5 в отсортированном массиве.
        //binarySearch method will return the index of the sorted array element, in which the required number is "hidden"
        System.out.println(key);//распечатываем индекс искомого числа
System.out.println(Arrays.binarySearch(array, 0));//а теперь попробуем найти число, которого в массиве нет,
        // and immediately display the result on the screen

    }
}

Output ng programa: Ang unang linya ay isang pagtatangka na magpakita ng array nang walang toString , ang pangalawa ay nagpapakita ng array gamit ang toString , ang pangatlo ay isang sorted array, ang pang-apat ay ang index ng nais na numero 5 sa isang sorted array (tandaan na tayo ay nagbibilang mula sa zero, kaya ang ikaapat na elemento ng array ay may index 3). Sa ikalimang linya nakikita natin ang halaga -1 . Ang isang array ay walang ganoong index. Ang output ay nagpapahiwatig na ang gustong elemento (sa kasong ito, 0) ay wala sa array.

Ang pangunahing bagay tungkol sa mga arrays

• Ang mga pangunahing katangian ng isang array: ang uri ng data na inilagay dito, pangalan at haba.
  Ang huli ay napagpasyahan sa panahon ng pagsisimula (paglalaan ng memorya para sa array), ang unang dalawang parameter ay tinutukoy kapag nagdedeklara ng array.

• Ang laki ng array (bilang ng mga cell) ay dapat tukuyin sa int

• Hindi mo mababago ang haba ng isang array pagkatapos itong magawa.

• Maaaring ma-access ang isang elemento ng array sa pamamagitan ng index nito.

• Sa mga array, tulad ng sa ibang lugar sa Java, ang mga elemento ay binibilang simula sa zero.

• Pagkatapos ng pamamaraan ng paglikha ng array, ito ay puno ng mga default na halaga.

• Ang mga array sa Java ay iba ang pagkakaayos kaysa sa C++. Ang mga ito ay halos kapareho ng mga pointer sa mga dynamic na array.

Mga kapaki-pakinabang na materyales 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. Something About Arrays - Magandang detalyadong artikulo sa array

2. Ang klase ng Arrays at ang paggamit nito - inilalarawan ng artikulo ang ilang pamamaraan ng klase ng Array

3. Multidimensional arrays - isang detalyadong artikulo tungkol sa multidimensional arrays na may mga halimbawa.

4. Ibalik ang isang zero-length 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