Mga array sa Java

Isipin ang mga cabinet sa isang storage room. Ang bawat isa sa kanila ay may sariling numero, at bawat isa sa kanila ay nag-iimbak ng ilang bagay sa Baggage. O isang listahan ng alak kung saan ang bawat uri ng alak ay binibilang at nag-order ka sa pamamagitan ng pagbibigay ng numero ng iyong inumin. O isang listahan ng mga mag-aaral kung saan ang "Adams" ay naitala sa unang posisyon at "Zimmer" ang huli. O isang listahan ng mga pasahero sa isang eroplano, na ang bawat isa ay itinalaga ng isang numerong upuan. Sa Java, ang mga array ay kadalasang ginagamit upang gumana sa mga ganitong istruktura, ibig sabihin, mga set ng homogenous na data.

Ano ang array?

Ang array ay isang istraktura ng data na nag-iimbak ng mga elemento ng parehong uri. Maaari mong isipin ito bilang isang hanay ng mga may bilang na mga cell. Maaari kang maglagay ng ilang data sa bawat cell (isang elemento ng data bawat cell). Ang isang partikular na cell ay ina-access gamit ang numero nito. Ang numero ng elemento sa array ay tinatawag ding index . Sa Java, ang isang array ay homogenous, ibig sabihin, lahat ng mga cell nito ay naglalaman ng mga elemento ng parehong uri. Kaya, ang hanay ng mga integer ay naglalaman lamang ng mga integer ( int ), isang hanay ng mga string — mga string lamang, at isang hanay ng mga pagkakataon ng klase ng Aso na nilikha namin ay maglalaman lamang ng mga bagay na Aso . Sa madaling salita, hindi tayo papayagan ng Java na maglagay ng integer sa unang cell ng array, String sa pangalawa, at Aso sa pangatlo.

Pagdedeklara ng array

Paano mo idedeklara ang isang array?

Tulad ng anumang variable, ang isang array ay dapat ideklara sa Java. Magagawa ito sa isa sa dalawang paraan. Ang mga ito ay katumbas, ngunit ang unang paraan ay mas pare-pareho sa estilo ng Java. Ang pangalawa ay isang legacy ng wikang C: maraming C programmer ang lumipat sa Java, at isang alternatibong paraan ang itinago para sa kanilang kaginhawahan. Ipinapakita ng talahanayan ang parehong paraan ng pagdedeklara ng array sa Java: Sa parehong mga kaso, ang dataType ay ang uri ng mga variable sa array. Sa mga halimbawa, nagdeklara kami ng dalawang array. Ang isa ay mag-iimbak ng int s, at ang isa pa - Mga bagay na bagay . Kaya, ang isang array declration ay may pangalan at uri (ang uri ng mga elemento ng array). Ang ArrayName ay ang pangalan ng array.

Paglikha ng array

Paano ka gumawa ng array?

Tulad ng anumang iba pang bagay, maaari kang lumikha ng isang Java array, ibig sabihin, magreserba ng isang lugar sa memorya para dito, gamit ang bagong operator. Ito ay kung paano ito ginawa:

new typeOfArray[length]; 

kung saan ang typeOfArray ay ang uri ng array at ang haba ay ang haba nito (ibig sabihin, ang bilang ng mga cell) na ipinahayag bilang isang buong numero ( int). Ngunit tandaan na dito lamang kami naglaan ng memorya para sa array - hindi namin naiugnay ang ipinahayag na array sa anumang naunang ipinahayag na variable. Karaniwan, ang isang array ay unang ipinahayag at pagkatapos ay na-instantiate, halimbawa:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Dito lumikha kami ng isang hanay ng mga integer na tinatawag na myArray , na nagpapaalam sa compiler na ito ay binubuo ng 10 mga cell (bawat isa ay naglalaman ng isang integer). Gayunpaman, mas karaniwan na gamitin ang sumusunod na pinaikling syntax upang lumikha kaagad ng array kapag ito ay idineklara:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Paalala:Pagkatapos gumawa ng array gamit ang bagong operator, naglalaman ang mga cell nito ng mga default na value. Para sa mga uri ng numero (tulad ng sa aming halimbawa), ang default na halaga ay 0, para sa uri ng boolean , ito ay false , at para sa mga uri ng sanggunian, ito ay null . Kaya, pagkatapos isagawa ang pahayag na ito

int[] myArray = new int[10];

nakakakuha kami ng isang hanay ng sampung integer at, hanggang sa gumawa ang programa ng isang bagay upang baguhin ang mga halaga, 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 na idinisenyo upang hawakan ng array. Ang haba ng isang array ay hindi na mababago pagkatapos itong malikha. Paalalana ang mga elemento ng array ay binibilang simula sa zero sa Java. Kaya, kung mayroon tayong hanay ng 10 elemento, kung gayon ang index ng unang elemento ay 0 at ang index ng huli ay 9. Makukuha mo ang haba ng array gamit ang variable na haba . Halimbawa:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Output:

10

Pagsisimula ng array at pag-access sa mga elemento nito

Ngayon alam na natin kung paano gumawa ng array sa Java. Ang proseso ay hindi nagbibigay sa amin ng isang walang laman na array, ngunit isang array na puno ng mga default na halaga. Halimbawa, para sa isang int array, ito ay 0, at kung mayroon kaming array ng anumang uri ng reference, ang default sa bawat cell ay null . Ina-access namin ang isang elemento ng array (halimbawa, upang itakda ang halaga nito, ipakita ito sa screen, o magsagawa ng ilang operasyon kasama nito) sa pamamagitan ng index nito. Ang pagsisimula ng array ay ang proseso ng pagpuno sa isang array ng mga partikular na halaga (maliban sa default). Halimbawa: gumawa tayo ng string array para sa 4 na season at punan ito ng mga pangalan ng season.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Ngayon ang mga pangalan ng mga panahon ay nakasulat sa apat na mga cell ng aming array. Maaari naming simulan ang array sa ibang paraan, pagsasama-sama ng deklarasyon at pagsisimula:

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

Higit pa rito, maaaring alisin ang bagong operator:

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

Paano mo ipapakita ang isang array sa screen sa Java?

Maaari kang magpakita ng mga elemento ng array sa screen (ibig sabihin, sa console) gamit ang for loop. Ang isa pang mas maikling paraan upang magpakita ng array ay tatalakayin sa talata na pinamagatang " Mga kapaki-pakinabang na pamamaraan para sa pagtatrabaho sa mga arrays ". Pansamantala, tingnan ang halimbawang ito kung saan ipinapakita ang isang array gamit ang isang loop:

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

Ipapakita ng programa ang sumusunod:

Winter 
Spring 
Summer 
Autumn

One-dimensional at multidimensional arrays sa Java

Ngunit paano kung gusto nating lumikha ng hindi isang hanay ng mga numero, string, o iba pang mga bagay, ngunit sa halip ay isang hanay ng mga array? Hinahayaan ka ng Java na gawin ito. Ang uri ng array na pamilyar na sa atin ( int[] myArray = new int[8] ) ay kilala bilang one-dimensional array. Ngunit ang isang array ng mga array ay tinatawag na isang two-dimensional array. Parang table na may row number at column number. O, kung natutunan mo ang mga pangunahing kaalaman sa linear algebra, maaari mong isipin ito bilang isang matrix. Bakit kailangan natin ng ganitong mga array? Well, upang i-program ang mga matrice at talahanayan, pati na rin ang iba pang mga bagay na may katulad na istraktura. Halimbawa, ang isang chessboard ay maaaring katawanin ng isang 8x8 array. Ang isang multidimensional array ay ipinahayag at nilikha tulad ng sumusunod:

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

Ang array na ito ay may eksaktong 64 na elemento: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] at iba pa hanggang myTwoDimentionalArray[7][7] . Kaya kung gagamitin natin ito upang kumatawan sa isang chessboard, ang A1 ay tumutugma sa myTwoDimentionalArray[0][0] at E2 ay tumutugma sa myTwoDimentionalArray[4][1] . Ngunit hanggang saan natin ito maitutulak? Sa Java, maaari mong tukuyin ang isang array ng mga arrays... isang array ng mga arrays ng mga arrays, at iba pa. Siyempre, ang mga three-dimensional at higher-dimensional na array ay bihirang ginagamit. Iyon ay sinabi, maaari kang gumamit ng isang three-dimensional array upang mag-program ng isang Rubik's cube, halimbawa.

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

Ang Java ay may java.util.Arrays na klase para sa pagtatrabaho sa mga array. Sa pangkalahatan, ang pinakakaraniwang mga operasyon na ginagawa sa mga array ay ang pagsisimula (pagpuno ng mga elemento), pagkuha ng isang elemento (sa pamamagitan ng index), pag-uuri, at paghahanap. Ang paghahanap at pag-uuri ng mga array ay mga paksa para sa isa pang araw. Sa isang banda, magandang kasanayan na ikaw mismo ang magsulat ng ilang algorithm sa paghahanap at pag-uuri. Sa kabilang banda, ang lahat ng pinakamahusay na mga algorithm ay naipatupad na at kasama sa karaniwang mga library ng Java, at maaari mong legal na gamitin ang mga ito. Narito ang tatlong kapaki-pakinabang na pamamaraan sa klase na ito.

Pag-uuri ng array

Ang paraan ng void sort(int[] myArray, int fromIndex, int toIndex) ay nag-uuri ng integer array o subarray sa pataas na pagkakasunod-sunod.

Naghahanap ng isang elemento sa isang array

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key) . Hinahanap ng pamamaraang ito ang pangunahing elemento sa isang pinagsunod-sunod na myArray array o subarray, mula fromIndex hanggang toIndex . Kung natagpuan ang item, ibabalik nito ang index nito. Kung hindi, ito ay nagbabalik (-fromIndex)-1 .

Pag-convert ng array sa isang string

Ang String toString(int[] myArray) na paraan ay nagko-convert ng array sa isang string. Sa Java, ang mga array ay hindi nag-o-override toString() . Nangangahulugan ito na kung susubukan mong ipakita ang isang buong array nang sabay-sabay (System.out.println(myArray)) sa halip na isang elemento sa isang pagkakataon tulad ng sa talata na pinamagatang " Magpakita ng array sa screen ", makakakuha ka ng pangalan ng klase at ang hexadecimal hash ng array (tinukoy ng Object.toString() ). Kung baguhan ka, maaaring hindi mo maintindihan ang paliwanag tungkol sa paraan ng toString . Sa una, hindi mo na kailangan, ngunit ang paggamit ng paraang ito ay nagpapadali sa pagpapakita ng isang array. Hinahayaan ka ng Java na madaling magpakita ng array nang hindi gumagamit ng loop. Ang halimbawa sa ibaba ay nagpapakita nito.

Isang halimbawa gamit ang sort, binarySearch, at toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Output:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

Ang unang string ay isang pagtatangka na ipakita ang array nang hindi gumagamit ng toString . Ang pangalawa ay ang array na ipinapakita gamit ang toString . Ang pangatlo ay ang pinagsunod-sunod na hanay. Ang ikaapat ay ang index ng numerong hinanap namin (5) sa pinagsunod-sunod na array (tandaan na nagbibilang kami mula sa zero, kaya ang index ng ikaapat na elemento ng array ay 3). Sa ikalimang string, makikita natin -1. Ito ay isang di-wastong array index. Ito ay nagpapahiwatig na ang numerong hinanap namin (sa kasong ito, 0) ay wala sa array.

Arrays sa maikling salita

• Mahahalagang katangian ng isang array: ang uri ng data na inilagay dito, pangalan nito, at haba nito.
  Ang huling pag-aari ay tinutukoy kapag ang array ay nilikha (kapag ang memorya ay inilalaan para sa array). Ang unang dalawang katangian ay tinutukoy kapag ang array ay idineklara.

• Ang laki ng array (bilang ng mga cell) ay dapat na isang int

• Imposibleng baguhin ang haba ng isang array pagkatapos itong malikha.

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

• Ang mga elemento sa mga array, tulad ng lahat ng iba pa sa Java, ay binibilang simula sa zero.

• Pagkatapos malikha ang isang array, ito ay puno ng mga default na halaga.

• Ang mga array sa Java ay hindi katulad ng array sa C++. Ang mga ito ay halos tulad 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? Tingnan ang mga artikulo sa ibaba. Mayroong maraming kawili-wili at kapaki-pakinabang na materyal sa paksang ito.