Panga vianzilishi na safu zisizo na majina
Java ina kituo cha kuunda wakati huo huo safu na kuianzisha. Hapa kuna mfano wa ujenzi kama huo wa kisintaksia: int smallPrimes = (2, 3, 5, 7, 11, 13); Kumbuka kwamba katika kesi hii hakuna haja ya kutumia operator mpya. Kwa kuongeza, unaweza hata kuanzisha safu isiyo na jina: int mpya ( 16 , 19 , 23 , 29 , 31 , 37 ) Usemi huu hutenga kumbukumbu kwa safu mpya na kuijaza kwa nambari zilizoainishwa katika braces curly. Katika kesi hii, idadi yao imehesabiwa na, ipasavyo, saizi ya safu imedhamiriwa. Muundo huu wa kisintaksia ni rahisi kutumia ili kuanzisha upya safu bila kuunda kigezo kipya. Kwa mfano, usemi smallPrimes = int mpya (17, 19, 23, 29, 31, 37); ni toleo fupi la usemi int anonymous = (17, 19, 23, 29, 31, 37); smallPrimes = bila majina; Unaweza kuunda safu ukubwa wa sifuri. Safu kama hiyo inaweza kuwa muhimu wakati wa kuandika njia ambayo inatathmini safu ambayo inageuka kuwa tupu. Safu ya urefu wa sifuri inatangazwa kama ifuatavyo: aina mpya ya Kipengee Kumbuka kuwa safu kama hiyo hailingani na kitu batili.Kunakili safu
Safu moja inaweza kunakiliwa hadi nyingine, lakini vigezo vyote viwili vitarejelea safu sawa. int luckyNumbers = smallPrimes; bahatiNamba[ 5] = 12; //Sasa kipengele cha smallPrimes pia ni 12 Matokeo yanaonyeshwa kwenye Mtini. 3.1. Ikiwa unahitaji kunakili vipengele vyote vya safu moja hadi nyingine, unapaswa kutumia njia ya arraycopy kutoka kwa darasa la Mfumo. Simu yake inaonekana kama hii: Mfumo. arraycopy (kutoka, fromlndex, to, tolndex, count); Safu lazima iwe kubwa vya kutosha ili kujumuisha vipengele vyote vya kunakiliwa.
Mchoro.3.1. Kunakili safu Kwa mfano, waendeshaji walioonyeshwa hapa chini, matokeo ambayo yanaonyeshwa kwenye Mtini. 3.2, unda safu mbili na kisha unakili vipengele vinne vya mwisho vya safu ya kwanza hadi ya pili. Kunakili huanza kutoka nafasi ya pili katika safu chanzo, na vipengele vilivyonakiliwa huwekwa kwenye safu lengwa kuanzia nafasi ya tatu. int smallPrimes = (2, 3, 5, 7, 11, 13); int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007); Mfumo. apparator(smallPrimes, 2, luckyNumbers, 3, 4); kwa ( int i = 0 ; i<
luckyNumbers.
length;
i++
)
System.
out.
println
(i +
": "
+
luckyNumbers[
i]
)
;
Выполнение этих операторов приводит к следующему результату.
0
:
1001
1
:
1002
2
:
1003
3
:
5
4
:
7
5
:
11
6
:
13
Mchele. 3.2. Kunakili Vipengee vya Safu Safu katika Java ni tofauti sana na safu katika C++. Walakini, inalingana na pointer kwa safu yenye nguvu. Hii ina maana kwamba opereta int a = new int [100] ; //Java sawa na opereta int * = new int [100]; //C++, si int a[ 100] ; //C++ Katika lugha Opereta wa Java kwa chaguo-msingi hukagua anuwai ya mabadiliko ya faharasa. Kwa kuongezea, Java haina hesabu ya kielekezi—huwezi kuongeza kielekezi ili kufikia kipengele kinachofuata cha safu. Unganisha kwa kwanza
Jifunze ili uwe "Msanidi wa Mchezo" + na ajira
safu za Java
Safu ni muundo wa data ambao huhifadhi thamani za aina sawa. Kipengele cha safu mahususi kinafikiwa kwa kutumia faharasa kamili. Kwa mfano, ikiwa a ni mkusanyiko wa nambari kamili, basi thamani ya usemi a[i] ni sawa na nambari kamili ya i-th katika safu.
Safu inatangazwa kama ifuatavyo: kwanza, aina ya safu imeonyeshwa, yaani, aina ya vipengele vilivyomo kwenye safu, ikifuatiwa na jozi ya mabano ya mraba tupu, na kisha jina la kutofautiana. Kwa mfano, hii ndio jinsi ya kutangaza safu inayojumuisha nambari kamili:
ndani a;
Walakini, taarifa hii inatangaza tu kutofautisha a, bila kuianzisha na safu halisi. Ili kuunda safu, unahitaji kutumia operator mpya.
Opereta huyu huunda safu ya nambari 100 kamili. Vipengele vya safu hii vimehesabiwa kutoka 0 hadi 99 (sio kutoka 1 hadi 100). Mara baada ya kuundwa, safu inaweza kujazwa, kwa mfano, kwa kutumia kitanzi.
int a = int mpya;
kwa (int i = 0; i< 100; i++)
a[i] = i; // Hujaza safu na nambari kutoka 0 hadi 99.
Ukijaribu kufikia kipengele a (au kipengele kingine chochote ambacho faharasa yake iko nje ya masafa 0 hadi 99) kwa kuunda safu ya vipengele 100, programu itakoma kwa sababu safu ya kipeo cha kutofuata mipaka itatokea.
Ili kuhesabu idadi ya vitu katika safu, tumia njia nameArray-
urefu wa va.
Kwa mfano,
kwa (int i = 0; i< a. length; i++ System.out.println (a[i]);
Mara tu safu imeundwa, haiwezekani kubadilisha ukubwa wake (ingawa unaweza, bila shaka, kubadilisha vipengele vyake vya kibinafsi). Ikiwa unahitaji kubadilisha ukubwa wa safu mara kwa mara wakati wa utekelezaji wa programu, ni bora kutumia muundo mwingine wa data unaoitwa orodha ya safu.
Safu inaweza kutangazwa kwa njia mbili:
ndani a;
au
ndani a;
Watengenezaji programu wengi wa Java wanapendelea mtindo wa kwanza kwa sababu unatenganisha kwa uwazi zaidi aina ya safu ya int kutoka kwa jina la kutofautisha.
Panga vianzilishi na safu zisizo na majina
Java ina kituo cha kuunda wakati huo huo safu na kuianzisha. Hapa kuna mfano wa muundo kama huu wa kisintaksia:
int smallPrimes = ( 2, 3, 5, 7, 11, 13);
Kumbuka kwamba katika kesi hii hakuna haja ya kutumia operator mpya. Kwa kuongeza, unaweza hata kuanzisha safu isiyo na jina:
int mpya ( 16, 19, 23, 29, 31, 37)
Usemi huu hutenga kumbukumbu kwa safu mpya na kuijaza na nambari zilizoainishwa katika brashi zilizopinda. Katika kesi hii, idadi yao imehesabiwa na, ipasavyo, saizi ya safu imedhamiriwa. Muundo huu wa kisintaksia ni rahisi kutumia ili kuanzisha upya safu bila kuunda kigezo kipya. Kwa mfano, usemi
smallPrimes = int mpya( 17, 19, 23, 29, 31, 37 );
ni usemi uliofupishwa
int anonymous = ( 17, 19, 23, 29, 31, 37);
smailPrimes = bila majina;
Unaweza kuunda safu ya ukubwa wa sifuri. Safu kama hiyo inaweza kuwa muhimu wakati wa kuandika njia ambayo inatathmini safu ambayo inageuka kuwa tupu. Safu ya urefu wa sifuri inatangazwa kama ifuatavyo:
aina mpya ya kipengele
Kumbuka kuwa safu kama hiyo sio sawa na kitu kisicho na maana.
Kunakili safu
Safu moja inaweza kunakiliwa hadi nyingine, lakini vigezo vyote viwili vitarejelea safu sawa.
int luckyNumbers = smailPrimes;
bahatiNimbers = 12; // Sasa kipengele cha smailPrimes pia ni 12.
Matokeo yanaonyeshwa kwenye Mtini. 3.14. Ikiwa unahitaji kunakili vipengele vyote vya safu moja hadi nyingine, unapaswa kutumia njia ya arraycopy kutoka kwa darasa la Mfumo. Wito wake unaonekana kama hii:
System.arraycopy(kutoka, fromlndex, to, tolndex, count);
Safu lazima iwe kubwa vya kutosha ili kujumuisha vipengele vyote vya kunakiliwa.
Mchele. 3.14. Kunakili safu
Kwa mfano, waendeshaji walioonyeshwa hapa chini, matokeo ambayo yanaonyeshwa kwenye Mtini. 3.15, unda safu mbili, na kisha unakili vipengele vinne vya mwisho vya safu ya kwanza kwenye pili. Kunakili huanza kutoka nafasi ya pili katika safu chanzo, na vipengele vilivyonakiliwa huwekwa kwenye safu lengwa kuanzia nafasi ya tatu.
int smailPrimes = (2, 3, 5, 7, 11, 13);
int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
System.aggausor(smailPrimes, 2, luckyNumbers, 3, 4);
kwa (int i = 0; i< luckyNumbers.length; i++)
System.println(i +.": " + luckyNumbersfi]);
Utekelezaji wa kauli hizi hutoa matokeo yafuatayo.
0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13
Mchele. 3.15. Kunakili Vipengee vya Safu
Safu katika Java ni tofauti sana na safu katika C++. Walakini, ni sawa na kiashiria kwa safu inayobadilika. Hii ina maana kwamba operator
int a = int mpya; // Java
ni sawa na operator
i n t * = mpya i n t [1 0 0]; // C++,
lakini sivyo
ndani a; // C++
Katika Java, chaguo-msingi hakuna opereta huangalia anuwai ya faharisi. Kwa kuongezea, Java haina hesabu ya kielekezi—huwezi kuongeza kielekezi ili kufikia kipengele kinachofuata cha safu.
Niliamua kuandika makala hii baada ya mjadala mmoja kwenye jukwaa. Itazingatia safu katika Java. Kusema kweli, siwezi kukumbuka kitabu chochote ambapo suala hili lilishughulikiwa kwa uwazi na kwa uwazi. Wakati huo huo, safu katika Java ni tofauti sana na safu katika lugha nyingine yoyote ambayo nimewahi kuona. Na ujuzi wa tofauti hizi ni muhimu sana.
Nakala hiyo imegawanywa katika sehemu tatu:
Ujumbe mdogo tangu mwanzo. Safu, bila kujali aina na ukubwa wake, ni kitu. Hii ina maana kwamba ina mali na mbinu zote za kitu.
Kwa hivyo, tutaanza na kesi rahisi zaidi, ambazo ni -
Safu zenye mwelekeo mmoja za aina za zamani
Safu hizi sio tofauti na vile watengeneza programu wanaotumia lugha zingine hutumiwa. Safu imeundwa kwa kutumia sawa mwendeshaji mpya:
// kuunda safu ya nambari na vitu 5: int safu = int mpya;
Tofauti na lugha zingine, hata hivyo, Java ina mambo kadhaa mazuri. Kwanza, saizi ya safu inaweza kuombwa kwa uwazi kupitia sifa ya .length:
int safu = int mpya; System.out.println("Ukubwa wa safu: "+array.length); // itachapisha: Ukubwa wa safu: 5Mali hii ni ya mwisho, kwa hivyo, kwa bahati mbaya, hautaweza kuweka saizi mpya ya safu ukitumia.
Kitu kidogo cha pili ni udhibiti wa kwenda zaidi ya mipaka ya safu. Hii inafanywa na mkalimani; ikiwa faharasa itapita zaidi ya safu, java.lang.ArrayIndexOutOfBoundsException itatupwa. Sio lazima kuizuia, na, ningesema, haifai, kwa sababu Hii ni RuntimeException na inaashiria kuwa programu haifanyi kazi ipasavyo. Na hakika hupaswi kuunda programu kwa kutarajia kwamba baada ya kupitia safu nzima, ubaguzi huu utatupwa, na hii itakuwa ishara ya kukomesha mzunguko wa usindikaji. Hili ni wazo mbaya sana.
Mara baada ya kuundwa, safu inaanzishwa kwa thamani chaguo-msingi kwa aina ya vipengele vyake. Hii inathibitishwa na maelezo ya lugha.
Kuna hila moja. Inapoundwa, saizi ya safu inaweza kuwekwa kuwa 0. Hii itakuwa safu kamili iliyo na vipengee 0. Sifa yake ya .length ni 0. Muundo huu unaweza kuwa muhimu sana wakati mwingine.
Maneno machache kuhusu kunakili. Njia isiyo na maana ni kuunda safu ya ukubwa sawa na kuhamisha yaliyomo kwenye kitanzi. Nzuri, ya kuaminika, lakini sio haraka sana. Kuna njia ya haraka - tumia njia ya System.arraycopy(...). Kwa njia hii, baada ya ukaguzi wote, eneo la kumbukumbu linakiliwa tu. Saini ya njia hii ni:
utupu tuli wa umma arraycopy (Kitu src, int srcPos, Uharibifu wa kitu, int desPos, int urefu)Kunakili hutokea kutoka kwa safu ya src, kuanzia kwenye nafasi srcPos, hadi safu ya dest, kuanzia kwenye position desPos. Jumla ya vipengele vya urefu vinakiliwa. Kumbuka kuwa src na dest ni za aina ya Object. Hii imefanywa ili njia hii inaweza kusindika safu za aina yoyote. Ikiwa src au dest si mkusanyiko, java.lang.ArrayStoreException itatupwa.
Kwa kweli, kuhusu safu aina za zamani hakuna la kusema zaidi. Kwa hivyo, tunaendelea vizuri kwenye sehemu inayofuata:
Safu zenye mwelekeo mmoja wa vitu
B O Mengi ya kile kinachosemwa juu ya safu za aina za zamani pia ni kweli kwa safu za vitu. Ukubwa wao unaweza kupatikana kupitia .length na overruns kudhibitiwa. Zinaundwa kwa kutumia opereta mpya:
// safu ya java.awt.Point yenye vipengele 10: pointi za java.awt.Point = mpya java.awt.Point;
Kumbuka kuwa HAKUNA simu ya mjenzi hapa. java.awt.Point baada ya opereta mpya kuonyesha tu aina ya vipengele vya mkusanyiko vinavyoundwa.
Baada ya uumbaji, safu imeanzishwa kwa njia sawa na thamani ya msingi ... Na hapa kuna shida kubwa. Swali gumu. Thamani hii chaguomsingi ni ipi? Kitu kilichoundwa kwa kumwita mjenzi asiye na vigezo? Je, ikiwa hakuna mjenzi kama huyo? Jibu liko katika jibu la swali lingine: ni nini, hasa, kilichohifadhiwa katika safu hii?
Lakini sio vitu ambavyo vimehifadhiwa katika safu hii. Viungo kwao huhifadhiwa huko. Kama tofauti yoyote aina ya kitu ni marejeleo ya kitu, na kipengele chochote cha safu pia ni marejeleo. Na kwa kiungo thamani chaguo-msingi ni null !
Hitilafu hii ni karibu ya classic. Mara nyingi hukutana na maswali "NullPointerException inatoka wapi" kuhusiana na nambari kama ifuatayo:
Java.awt.Point points = mpya java.awt.Point; pointi.x = 1; //<-- here is a NullPointerException
Sasa, nadhani ni wazi kosa hili linatoka wapi. Safu imeundwa na vipengele vyake vinaanzishwa kuwa null . Hata hivyo, vitu vyenyewe havikuumbwa. Hali ni sawa na kutumia kibadilishaji chenye thamani null . Kijisehemu sahihi kinaonekana kama hii:
Java.awt.Point points = mpya java.awt.Point; kwa(int i=0; i
Ningependa kugusa haswa juu ya suala la kunakili vitu vya safu ya vitu. Kwa kuwa ina viungo, vinakiliwa. Wale. baada ya kunakili, safu mpya itaelekeza kwa seti sawa ya vitu! Na ukibadilisha hali ya ndani ya kitu chochote, hii itaonekana wakati wa kuipata kupitia safu yoyote.
Kwa hivyo, tunakaribia polepole sehemu ya kuvutia zaidi -
Mipangilio ya multidimensional
Hili ni tabaka tofauti zaidi la safu kutoka kwa lugha zingine. Kwa kusema ukweli, sijawahi kuona kitu kama hiki mahali pengine popote. Kwa unyenyekevu, tutaanza na safu mbili-dimensional, na kisha kuendelea na wale n-dimensional.
Kwanza kabisa, nataka kutaja ukweli huu. Kwa safu mbili-dimensional hakuna kitu kama vipimo vyake. Unaweza kuamua ukubwa wa safu kwa faharasa ya kwanza pekee. Sababu iko katika shirika la safu. Ni safu ya marejeleo ya safu, ambayo kila moja ina data halisi. Na safu hizi zinaweza kuwa na urefu tofauti!
Hebu tuangalie safu hii ya pande mbili. Urefu wake kwenye faharisi ya kwanza ni 3. Inaweza kupatikana kupitia a.length . Vipengele vya safu hii ni viungo vya safu zilizo na data. Urefu wa kila safu hizi pia unaweza kupatikana kupitia .length . Kila moja ya safu hizi hupatikana kupitia fahirisi yake - faharasa ya kwanza katika safu a .
Nadhani sasa ni wazi kwamba tunaweza tu kuzungumza juu ya urefu wa safu mbili-dimensional katika index ya kwanza. Thamani ya juu ya fahirisi ya pili inaweza kupatikana tu kwa kila thamani maalum ya faharasa ya kwanza.
// safu 2d za ints zilizo na safu 10 za vitu 5 kila moja int array2d = int mpya;
Muundo huu huunda safu ya 2D ya ukubwa wa 10x5. Tunaweza kuzungumza juu ya ukubwa hapa kwa sababu saizi kwenye faharasa ya pili imebainishwa wazi wakati wa uanzishaji. Na mistari yote itakuwa ya urefu wa 5, safu itakuwa mstatili.
Kuna, hata hivyo, njia nyingine. Kwa mfano, wacha tuunde safu iliyoonyeshwa kwenye takwimu hapo juu:
int a = int mpya; // mstari wa 1 a = int mpya; // mstari wa 2 a = int mpya; // mstari wa 3 a = int mpya; // mstari wa 4Tafadhali kumbuka kuwa katika mstari wa 1, wakati wa kuanzisha safu, mwelekeo kwenye index ya pili haujaonyeshwa!
Nini kinaendelea katika kanuni hii? Mstari wa 1 huunda safu katika faharasa ya kwanza, saizi ya 3. Hii inamaanisha kuwa kumbukumbu imetengwa kwa marejeleo matatu ya safu za safu. Safu zenyewe hazijaundwa; kumbukumbu iliyotengwa imeanzishwa na maadili yasiyofaa.
Mstari wa 2 huunda safu ya urefu wa 2. Rejeleo la safu hii limehifadhiwa katika kipengele cha kwanza cha safu kwenye faharasa ya kwanza. Vile vile, mistari ya 3 na 4 huunda safu ambazo marejeleo yake yanahifadhiwa katika vipengele vya pili na vya tatu vya safu kwenye fahirisi ya kwanza.
Matokeo yake, tuna safu ya sura ya kiholela. Bila shaka, tunaweza kuunda safu zote tatu za urefu sawa, sema 5. Vitendo hivi vitakuwa sawa kabisa na ujenzi mpya wa ndani.
Inafaa kutaja tena kwamba hali wakati wa kuunda safu za kamba na aina ya kitu ni sawa na safu za sura moja (ambayo wao, kwa kweli, ni). Kumbukumbu imetengwa kwa marejeleo ya vitu, lakini vitu vyenyewe havikuundwa.
Hebu sasa tuendelee kwenye safu za n-dimensional. Hakuna jipya hapa. Kama vile safu ya pande mbili ni safu ya marejeleo ya safu ya mwelekeo mmoja, safu ya pande tatu ni orodha ya marejeleo, lakini kwa safu mbili-dimensional. Kanuni ya jumla ni:
Safu ya N-dimensional ni safu ya mwelekeo mmoja ambayo vipengele vyake ni marejeleo ya safu za vipimo N-1.
Ipasavyo, safu za N-dimensional zinaweza kuundwa kwa usemi mmoja, kwa kutumia opereta mpya na kubainisha saizi katika vipimo vyote. Au unaweza kuifanya kwa mlolongo - tengeneza safu, ukibainisha kipimo kwa faharisi moja au kadhaa, na uanzishe viungo vilivyobaki ambavyo havijatambuliwa kwa mikono, ukitengeneza safu za kipimo kinachohitajika, lakini cha saizi / umbo la kiholela. Walakini, kwa safu zenye sura kubwa hii ni kazi ngumu, kwa maoni yangu. Kwa kweli, kama vile kufanya kazi na safu za multidimensional kwa ujumla.
Maneno machache kuhusu kunakili safu nyingi kwa kutumia System.arraycopy. Mikusanyiko itanakiliwa TU kwenye faharasa ya kwanza. Kwa maneno mengine, marejeleo ya safu ya N-1 kutoka safu ya kwanza yatahamishwa hadi safu ya pili. Katika kesi ya safu mbili-dimensional, haya ni marejeleo ya safu za kamba. Hali hii hurahisisha sana kunakili safu, tuseme, wakati wa kuongeza laini mpya - kumbukumbu inahitaji kutengwa tu kwa safu kwenye faharisi ya kwanza. Ifuatayo, marejeleo ya safu mlalo yote yatanakiliwa kwa safu mpya, na kiunga cha mwisho, ambacho kinapaswa kuelekeza kwenye safu mpya, kitaanzishwa kwa mikono:
int initArray; // safu ya awali int newArrayLength = initArray.length+1; int newArray = int mpya; kwa(int i=0; iKama nilivyotaja, System.arraycopy hufanya kitu sawa na kitanzi hapo juu, kwa haraka tu.
Labda kutosha imesemwa kuhusu safu kwa sasa. Tunaweza kuzungumza juu ya cloning, lakini, kwa maoni yangu, mada hii ni zaidi ya upeo wa makala hii. Kwa sababu makala hii bado inalenga watengenezaji wa mwanzo kwa kiasi kikubwa.
Asante kwa wote! Natumaini mtu alipata habari hii muhimu na ya kuvutia.
Safu ni mlolongo wa kikomo wa vipengele vilivyopangwa vya aina moja, kila kipengele ambacho kinafikiwa na index yake.
Ukubwa au urefu wa safu ni jumla ya idadi ya vipengele katika safu. Saizi ya safu imewekwa wakati safu imeundwa na haiwezi kubadilishwa baadaye, ambayo ni, huwezi kuondoa vitu kutoka kwa safu au kuziongeza hapo, lakini unaweza kugawa maadili mapya kwa vitu vilivyopo.
Fahirisi ya kipengele cha kuanzia ni 0, inayofuata ni 1, nk. Fahirisi ya kipengele cha mwisho katika safu ni moja chini ya ukubwa wa safu.
Katika Java, safu ni vitu. Hii inamaanisha kuwa jina lililopewa kila safu linaonyesha tu anwani ya kipande fulani cha data kwenye kumbukumbu. Hakuna kilichohifadhiwa katika kigezo hiki isipokuwa anwani. Kielelezo cha safu, kwa kweli, kinaonyesha ni kiasi gani unahitaji kuondoka kutoka kwa kipengele cha kuanzia cha safu kwenye kumbukumbu ili kufikia kipengele unachotaka.
Ili kuunda safu, unahitaji kutangaza jina linalofaa kwake, na kisha ushirikishe na jina hili kipande muhimu cha kumbukumbu, ambapo maadili ya vipengele vya safu yatahifadhiwa moja baada ya nyingine. Chaguzi zifuatazo za kutangaza safu. inawezekana: jina la aina; jina la aina;
Wapi aina ni aina ya vipengele vya safu, na Jina- kitambulisho cha pekee (kisicho na vigezo vingine au vitu katika sehemu hii ya programu) kuanzia na barua.
Mifano: int a; ar1 mara mbili; ar2 mara mbili;
Katika mfano, tulitangaza majina kwa safu tatu. Na jina la kwanza a safu ya mambo ya aina int inaweza kuhusishwa zaidi, na kwa majina ar1 Na ar2 zaidi, safu za nambari halisi (aina mbili) zinaweza kuunganishwa. Kufikia sasa hatujaunda safu, lakini tumetayarisha majina yao tu.
Sasa unaweza kuunda (au, kama wanasema, kuanzisha) safu kama ifuatavyo: a = int mpya; // safu ya vipengele 10 vya aina int int n = 5; ar1 = new double[n]; // Safu ya vipengele 5 mara mbili ar2 = (3.14, 2.71, 0, -2.5, 99.123); // Safu ya vipengele 6 vya aina mbili Hiyo ni, wakati wa kuunda safu, tunaweza kutaja ukubwa wake, au mara moja kuorodhesha vipengele vyote vinavyohitajika vilivyotenganishwa na koma katika braces curly (katika kesi hii, ukubwa utahesabiwa moja kwa moja kulingana na mlolongo wa vipengele ambavyo vitabainishwa). Tafadhali kumbuka kuwa katika kesi hii, semicolon huwekwa baada ya kufunga curly brace, ambayo haina kutokea wakati brace kufunga block.
Ikiwa safu iliundwa kwa kutumia operator mpya, basi kila moja ya vipengele vyake hupokea thamani chaguo-msingi. Itakuwa nini imedhamiriwa kulingana na aina ya data (0 kwa int, 0.0 kwa mara mbili, nk).
Iliwezekana kutangaza jina la safu na kuunda safu yenyewe kwenye mstari mmoja kwa kutumia mpango ufuatao: jina la aina = aina mpya[saizi]; jina la aina = (el0, el1, ..., elN); Mifano: int mas1 = (10,20,30); int mas2 = int mpya;
Ili kufikia moja ya vipengele vya safu ili kusoma au kubadilisha thamani yake, unahitaji kutaja jina la safu ikifuatiwa na index ya kipengele katika mabano ya mraba. Kipengele cha safu kilicho na faharasa maalum hufanya kazi sawa na kigezo. Kwa mfano, ili kuonyesha kipengee cha mwisho cha safu ya mas1, lazima tuandike kwenye programu:
System.out.println("Kipengele cha safu ya mwisho " + mas1);
Na hivi ndivyo tunaweza kuweka katika safu ya mas2 seti sawa ya maadili ambayo yamehifadhiwa katika mas1:
Mas2 = 10; wingi2 = 20; mas2 = 30;Tayari kutoka kwa mfano huu ni wazi kwamba ili kufikia vipengele vyote vya safu, tunapaswa kurudia aina sawa ya vitendo. Kama unavyokumbuka, vitanzi hutumiwa kurudia shughuli mara nyingi. Ipasavyo, tunaweza kujaza safu na vitu muhimu kwa kutumia kitanzi: kwa(int i=0; iNi wazi kwamba ikiwa tungekuwa na safu sio ya 3, lakini ya vitu 100, tusingeweza kuifanya. bila kitanzi.
Urefu wa safu yoyote iliyoundwa hauitaji kukumbukwa, kwa sababu kuna mali inayoihifadhi. Unaweza kufikia sifa hii kwa kuongeza .length kwa jina la safu. Kwa mfano:
Int razmer = mas1.length; Mali hii haiwezi kurekebishwa (yaani, haiwezi kupewa chochote), inaweza kusoma tu. Kwa kutumia mali hii, unaweza kuandika msimbo wa programu ili kusindika safu bila hata kujua ukubwa wake maalum.
Kwa mfano, hivi ndivyo unavyoweza kuonyesha vitu vya safu yoyote inayoitwa ar2:
Kwa (int i = 0; i<= ar2.length - 1; i++) { System.out.print(ar2[i] + " "); } Для краткости удобнее менять нестрогое неравенство на строгое, тогда не нужно будет вычитать единицу из размера массива. Давайте заполним массив целыми числами от 0 до 9 и выведем его на экран: for(int i = 0; i < ar1.length; i++) {ar1[i] = Math.floor(Math.random() * 10); System.out.print(ar1[i] + " "); }
Tafadhali kumbuka kuwa katika kila hatua ya kitanzi, tulituma kwanza thamani isiyo ya kawaida kwa kipengele cha safu na index ya i-th, na kisha tukaonyesha kipengele sawa kwenye skrini. Lakini michakato miwili (kujaza na kujiondoa) inaweza kufanywa kwa mizunguko tofauti. Kwa mfano:
Kwa (int i = 0; i< ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.
Ili kuchakata safu, vitanzi vya aina ya "n nyakati" (kwa) hutumiwa kila wakati kwa sababu tunajua mapema ni mara ngapi kitanzi kinapaswa kurudiwa (idadi sawa ya nyakati kama kuna vipengee kwenye safu).
Kazi
Unda safu ya nambari zote sawa kutoka 2 hadi 20 na uonyeshe vipengele vya safu kwanza kwenye mstari, ukitenganisha kipengele kimoja kutoka kwa mwingine na nafasi, na kisha kwenye safu (kutenganisha kipengele kimoja kutoka kwa mwingine kwa kuanzia mstari mpya). Kabla ya kuunda safu, fikiria juu ya jinsi itakuwa kubwa.
2 4 6 … 18 20
2
4
6
…
20
Unda safu ya nambari zote zisizo za kawaida kutoka 1 hadi 99, ionyeshe kwenye skrini kama mstari, na kisha uonyeshe safu sawa kwenye skrini kama mstari, lakini kwa mpangilio wa nyuma (99 97 95 93 ... 7 5 3 1 )
Unda safu ya nambari 15 za nasibu kutoka kwa sehemu. Onyesha safu kwenye skrini. Hesabu ni vipengele vingapi vilivyo kwenye safu na uonyeshe nambari hii kwenye skrini kwenye mstari tofauti.
Unda safu ya nambari 8 za nasibu kutoka kwa sehemu. Chapisha safu kwenye skrini kama mfuatano. Badilisha kila kipengele na index isiyo ya kawaida na sufuri. Tena, onyesha safu kwenye mstari tofauti.
Unda safu 2 za nambari 5 za nasibu kutoka kwa kila sehemu, onyesha safu kwenye skrini kwenye mistari miwili tofauti. Kokotoa maana ya hesabu ya vipengee vya kila safu na uripoti ni safu gani ambayo thamani hii ilikuwa kubwa zaidi (au ripoti kwamba njia zao za hesabu ni sawa).
Unda safu ya nambari 4 za nasibu kutoka kwa sehemu, ichapishe kwenye skrini kama mfuatano. Amua na uonyeshe ujumbe unaoonyesha ikiwa safu ni mlolongo unaoongezeka sana.
Unda safu ya nambari 20 za juu za Fibonacci na uionyeshe kwenye skrini. Tunakukumbusha kwamba masharti ya kwanza na ya pili ya mlolongo ni sawa na moja, na kila moja inayofuata ni jumla ya mbili zilizopita.
Unda safu ya nambari 12 za nasibu kutoka kwa sehemu [-15;15]. Bainisha ni kipengele kipi ndicho cha juu zaidi katika safu hii na uripoti faharasa ya utokeaji wake wa mwisho katika safu.
Unda safu mbili za nambari 10 za nasibu kutoka kwa sehemu na safu ya tatu ya nambari 10 halisi. Kila kipengele kilicho na faharasa ya i-th ya safu ya tatu lazima iwe sawa na uwiano wa kipengele kutoka safu ya kwanza na index ya i-th hadi kipengele kutoka safu ya pili na i-th index. Chapisha safu zote tatu kwenye skrini (kila kwenye mstari tofauti), kisha uchapishe nambari ya vipengele kamili katika safu ya tatu.
Unda safu ya nambari 11 za nasibu kutoka kwa sehemu [-1;1], onyesha safu kama mstari. Amua ni kipengele gani hutokea mara nyingi katika safu na uonyeshe ujumbe kuhusu hilo kwenye skrini. Ikiwa vitu viwili vinatokea kwa idadi sawa ya nyakati, basi usitoe chochote.
Mtumiaji lazima abainishe nambari chanya kutoka kwa kibodi, na programu lazima iunde safu ya saizi iliyobainishwa kutoka nambari kamili kutoka kwa [-5;5] na ionyeshe kwenye skrini kama mstari. Baada ya hayo, programu inapaswa kuamua na kumjulisha mtumiaji kuhusu jumla ya moduli ambazo nusu ya safu ni kubwa zaidi: kushoto au kulia, au taarifa kwamba hesabu hizi za moduli ni sawa. Ikiwa mtumiaji ataingiza nambari isiyo sahihi, programu inapaswa kuhitaji kuingia mara kwa mara hadi thamani sahihi itakapobainishwa.
Mpango lazima uunde safu kamili ya nambari nasibu 12 kutoka kwa sehemu [-10;10] ili kuwe na nambari sawa za vipengele hasi na vyema na kusiwe na sufuri. Katika kesi hii, mpangilio wa vipengee lazima uwe wa nasibu (yaani, chaguo haifai wakati safu huwa na nambari 6 chanya na kisha 6 hasi, au wakati vitu vinabadilishana kila wakati, nk). Onyesha safu inayotokana kwenye skrini.
Mtumiaji huingiza nambari ya asili zaidi ya 3 kutoka kwa kibodi, ambayo imehifadhiwa katika n n. Ikiwa mtumiaji ameingiza nambari isiyo sahihi, programu inapaswa kumuuliza mtumiaji kurudia ingizo. Unda safu ya nambari kamili za n kutoka kwa sehemu na uionyeshe kwenye skrini. Unda safu ya pili kutoka kwa vipengee sawa vya safu ya kwanza, ikiwa ipo, na uionyeshe kwenye skrini.
Panga safu
Kupanga ni mchakato wa kupanga upya vipengele vya safu, wakati vipengele vyake vyote vimepangwa kwa utaratibu wa kupanda au kushuka. Unaweza kupanga sio tu safu za nambari, lakini pia, kwa mfano, safu za kamba (kwa kanuni sawa na vitabu vinavyopangwa rafu za maktaba). Kwa ujumla, unaweza kupanga vipengele vya seti yoyote ambapo uhusiano wa mpangilio umebainishwa. Kuna algoriti za jumla zinazofanya upangaji bila kujali hali ya awali ya mkusanyiko ilikuwaje. Lakini kando yao, kuna algorithms maalum ambayo, kwa mfano, inaweza kupanga haraka safu karibu iliyoamuru, lakini haishughulikii vizuri na safu iliyochanganywa sana (au usishughulikie kabisa). Algorithms maalum inahitajika ambapo kasi ni muhimu na shida mahususi inatatuliwa; utafiti wao wa kina uko nje ya upeo wa kozi yetu.Inapanga kwa uteuzi
Wacha tuangalie mfano wa kupanga kwa mpangilio wa kupanda. Hiyo ni, nafasi ya mwanzo katika safu inapaswa kuwa na kipengele cha chini zaidi, kinachofuata kiwe na kipengele kikubwa au sawa, nk, na nafasi ya mwisho inapaswa kuwa na kipengele kikubwa zaidi.Kiini cha algoriti ni kama ifuatavyo. Tunatafuta kipengele kidogo katika kila kitu na tukibadilisha na cha awali. Kisha, katika sehemu iliyobaki ya safu (yaani, kati ya vipengele vyote isipokuwa ya awali), tunatafuta tena kipengele cha chini na kuibadilisha na kipengele cha pili katika safu. Nakadhalika.Mchoro:
Kwa (int i = 0; i
Aina ya Bubble
Kiini cha algorithm ni hii. Ikiwa tutapitia safu yoyote, tukiweka mpangilio sahihi katika kila jozi ya vitu vilivyo karibu, basi baada ya hapo kitu kinachohitajika kitahakikishwa kuwa katika nafasi ya mwisho ya safu (kubwa zaidi kwa kupanga kwa mpangilio wa kupanda au ndogo zaidi kwa kupanga. kwa utaratibu wa kushuka). Ikiwa unapitia safu tena na mabadiliko sawa, basi kipengele kinachohitajika kinahakikishiwa kuwa mahali pa mwisho. Na kadhalika. Mfano:2 9 1 4 3 5 2 → mpangilio ni sahihi, hakutakuwa na upangaji upya
2 9 1 4 3 5 2 → 2 1 9 4 3 5 2
2 1 9 4 3 5 2 → 2 1 4 9 3 5 2
2 1 4 9 3 5 2 → 2 1 4 3 9 5 2
2 1 4 3 9 5 2 → 2 1 4 3 5 9 2
2 1 4 3 5 9 2 → 2 1 4 3 5 2 9
Nambari: /* Kitanzi cha nje kinapunguza kila wakati kipande cha safu * ambayo itazingatiwa, kwa sababu baada ya kila kupita * ya kitanzi cha ndani, kitu unachotaka kitakuwa * mahali pa mwisho pa kipande (haitaji kuzingatiwa tena). */ kwa (int i = a.length - 1; i >= 2; i--) ( /* Katika kigezo kilichopangwa tutahifadhi ishara ya ikiwa safu * imepangwa. Kabla ya kila kupita kwa kitanzi cha ndani * tutachukulia kuwa imepangwa , lakini tukifanya * angalau kibali kimoja, inamaanisha kuwa bado hatujapangwa kikamilifu.* Mbinu hii, ambayo hurahisisha upangaji, inaitwa kigezo cha Iverson.*/ boolean sorted = true;/* Katika kitanzi cha ndani tunapitia kipande cha safu, ambayo ni * imedhamiriwa na kitanzi cha nje Katika kipande hiki tunaanzisha * utaratibu sahihi kati ya vipengele vilivyo karibu, hivyo katika jozi * usindikaji kipande nzima */ kwa (int j = 0; j a) ( int temp = a[j]; a[j] = a; a = temp ; sorted = uongo; ) ) /* Ikiwa safu imepangwa (yaani hakukuwa na vibali * kwenye kitanzi cha ndani, basi unaweza simamisha kitanzi * cha nje. */ if(sorted) ( break; ) )
Mipangilio ya multidimensional
Safu inaweza kujumuisha sio tu vitu vya aina fulani iliyojengwa ndani (int, mbili, nk), lakini pia, kati ya mambo mengine, ya vitu vya darasa lililopo na hata safu zingine.
Safu iliyo na safu zingine kwani vipengee vyake huitwa safu nyingi. Safu zenye sura mbili hutumiwa mara nyingi. Safu kama hizo zinaweza kuwakilishwa kwa urahisi kama matrix. Kila safu ambayo ni safu ya kawaida ya mwelekeo mmoja, na muungano wa safu zote ni safu mbili-dimensional, katika kila kipengele ambacho kiungo cha safu fulani ya matrix huhifadhiwa. Safu ya tatu-dimensional inaweza kuwa kufikiria kama seti ya matrices, ambayo kila moja tuliandika kwenye kadi ya maktaba. Halafu, ili kufikia nambari fulani, kwanza unahitaji kuonyesha nambari ya kadi (faharisi ya kwanza ya safu ya pande tatu), kwa hivyo onyesha nambari ya safu (kiashiria cha safu ya pili) na kisha tu nambari ya kitu kwenye safu. safu (kiashiria cha tatu).
Ipasavyo, ili kupata kipengee cha safu ya n-dimensional, unahitaji kutaja fahirisi za n.
Safu hutangazwa hivi: int d1; // Kawaida, moja-dimensional int d2; //Two-dimensional mara mbili d3; // int-dimensional tatu d5; //Five-dimensional Wakati wa kuunda safu, unaweza kutaja kwa uwazi ukubwa wa kila ngazi: d2 = int; // Matrix ya safu 3 na safu 4 Lakini unaweza tu kutaja ukubwa wa ngazi ya kwanza: int dd2 = int; /* Matrix ya safu 5. Bado haijajulikana ni vipengele vingapi vitakuwa katika kila mstari. */ Katika kesi ya mwisho, unaweza kuunda safu mbili-dimensional, ambayo haitakuwa matrix kutokana na ukweli kwamba kila safu itakuwa na idadi tofauti ya vipengele. Kwa mfano: kwa(int i=0; i<5; i++) { dd2[i] = new int; } В результате получим такой вот массив: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Мы могли создать массив явно указав его элементы. Например так: int ddd2 = {{1,2}, {1,2,3,4,5}, {1,2,3}};
Katika kesi hii, unaweza kupata kipengee na index 4 kwenye safu ya pili dd2, lakini ikiwa tutafikia kipengee dd2 au dd2- kosa litatokea, kwani vitu kama hivyo havipo. Kwa kuongeza, hitilafu hii itatokea wakati wa utekelezaji wa programu (yaani, mkusanyaji hataiona).
Kwa kawaida, safu za pande mbili zenye idadi sawa ya vipengele katika kila safu hutumiwa. Ili kuchakata safu-mbili, vitanzi viwili vilivyo na vihesabio tofauti hutumiwa. Mfano (tunajaza safu ya pande mbili na nambari nasibu kutoka 0 hadi 9 na uonyeshe kwenye skrini kwa namna ya matrix): int da = int mpya; kwa (int i=0; i Unda safu ya pande mbili ya safu 8 za safu wima 5 kila moja ya nambari kamili kutoka kwa sehemu. Onyesha safu kwenye skrini. Unda safu ya pande mbili ya safu 5 na safu wima 8 kila moja ya nambari kamili kutoka kwa sehemu [-99;99]. Onyesha safu kwenye skrini. Kisha, kwenye mstari tofauti, onyesha thamani ya kipengele cha juu cha safu hii (index yake haijalishi). Unda safu ya pande mbili ya safu 7 na safu wima 4 kila moja ya nambari kamili kutoka kwa sehemu [-5;5]. Onyesha safu kwenye skrini. Amua na uonyeshe faharasa ya safu mlalo yenye bidhaa kubwa kabisa ya vipengele. Ikiwa kuna mistari kadhaa kama hiyo, kisha uchapishe index ya kwanza iliyokutana. Unda safu ya pande mbili ya safu 6 na safu wima 7 kila moja ya nambari kamili kutoka kwa sehemu. Onyesha safu kwenye skrini. Badilisha safu ili kipengele kikubwa zaidi katika kila safu kije kwanza. Katika kesi hii, utungaji wa safu hauwezi kubadilishwa, lakini vipengele tu vinaweza kupangwa upya ndani ya mstari mmoja. Mpangilio wa vipengele vilivyobaki vya mstari sio muhimu (yaani, unaweza kufanya permutation moja tu, au unaweza kupanga kila mstari kwa utaratibu wa kushuka). Onyesha safu iliyobadilishwa kwenye skrini. Ili kupima maarifa ya mabaki ya wanafunzi baada ya likizo ya majira ya joto, mwalimu wa shule ya msingi aliamua kuanza kila somo kwa kumuuliza kila mwanafunzi mfano kutoka kwenye jedwali la kuzidisha, lakini kuna watu 15 darasani, na mifano kati yao haipaswi kurudiwa. . Ili kumsaidia mwalimu, andika programu ambayo itaonyesha mifano 15 ya nasibu kutoka kwa jedwali la kuzidisha (kutoka 2*2 hadi 9*9, kwa sababu kazi za kuzidisha kwa 1 na 10 ni rahisi sana). Aidha, kati ya mifano 15 haipaswi kuwa na kurudia (mifano 2 * 3 na 3 * 2 na jozi sawa zinapaswa kuzingatiwa kurudia). 2010, Alexey Nikolaevich Kostin. Idara ya TIDM, Kitivo cha Hisabati, Chuo Kikuu cha Pedagogical cha Jimbo la Moscow. Safu(safu) _ zimepangwa seti za vipengele vya aina moja. Vipengele vya safu vinaweza kuwa vitu vya aina rahisi na za marejeleo, ikijumuisha Nambari na marejeleo ya safu zingine. Safu zenyewe ni vitu na kurithi darasa la Kitu. Tangazo int ia = int mpya; Inafafanua safu inayoitwa ia ambayo mwanzoni inaelekeza kwenye seti ya Vipengele vitatu vya aina ya int. Tamko la safu haionyeshi ukubwa wake. Idadi ya vipengele vya safu hubainishwa wakati inapoundwa kwa kutumia opereta mpya. Urefu wa safu umewekwa wakati wa uumbaji na hauwezi kubadilishwa baadaye. Hata hivyo, kutofautiana aina ya safu (katika mfano wetu - ia) safu mpya yenye mwelekeo tofauti inaweza kupewa wakati wowote. Vipengee vya safu hufikiwa na maadili ya nambari zao za index. Kipengele cha safu ya kwanza kina kielezo cha sifuri (0), na cha mwisho kina urefu wa 1. Kipengele cha safu kinapatikana kwa kubainisha jina la safu na thamani ya faharisi, iliyoambatanishwa katika mabano ya mraba, [ na ]. katika mfano uliopita, kipengele cha kwanza cha safu ya ia kitakuwa ia, na kipengele cha mwisho kitakuwa ia. Wakati wowote kipengele cha safu kinapofikiwa na faharasa, muda wa utekelezaji wa Java hukagua kama thamani ya faharasa iko ndani ya mipaka inayokubalika na kutupa ubaguzi wa aina ArraylndexOutOfBoundsException ikiwa matokeo ya ukaguzi ni ya uwongo. 6 Usemi wa faharasa lazima uwe wa aina int - hiki ndicho kitu pekee kinachoweka mipaka ya upeo wa idadi ya vipengele vya safu. Urefu wa safu unaweza kuamuliwa kwa urahisi kwa kutumia uga wa urefu wa kitu cha safu (ambacho kimetolewa kwa uwazi na sifa za umma na za mwisho). Ifuatayo ni msimbo uliosasishwa wa mfano uliopita, ambao hutoa kwa ajili ya utekelezaji wa Kitanzi ambacho huhakikisha kuwa yaliyomo katika kila kipengele cha safu ia yanaonyeshwa kwenye skrini: kwa (int i = o; i< ia.length; i++) system.out.println(i + ": " + ia[i]); Safu ya urefu wa sifuri (yaani ambayo haina vipengele) kawaida huitwa tupu. Kumbuka kuwa rejeleo la safu tupu na marejeleo ya safu tupu ni vitu viwili tofauti kabisa. Safu tupu ni safu halisi ambayo haina vipengee. Safu tupu hutoa mbadala rahisi kwa null wakati wa kurudi kutoka kwa njia. Ikiwa mbinu ina uwezo wa kurudisha null, msimbo wa programu unaoita mbinu lazima ulinganishe thamani iliyorejeshwa na null kabla ya kuendelea na shughuli zilizosalia. Ikiwa njia inarudi safu (ikiwezekana tupu), hakuna ukaguzi wa ziada unaohitajika - bila shaka, isipokuwa wale kuhusu urefu wa safu, ambayo inapaswa kufanywa kwa hali yoyote. Aina nyingine ya tamko la safu pia inaruhusiwa, ambayo mabano ya mraba yanatajwa baada ya kitambulisho cha safu, na sio baada ya jina la aina yake: int ia = int mpya; Sintaksia ya zamani, hata hivyo, inachukuliwa kuwa bora zaidi kwa sababu inafanya tamko la aina kuwa ngumu zaidi. Virekebishaji katika Matangazo ya Mkusanyiko Sheria za kutumia safu fulani katika matamko virekebishaji ni ya kawaida na inategemea tu safu ni ya kategoria gani - uwanja au anuwai za Mitaa. Kuna jambo moja ambalo ni muhimu kukumbuka - marekebisho yanahusu safu yenyewe, lakini si kwa vipengele vyake vya kibinafsi. Ikiwa sifa ya mwisho imebainishwa katika tamko la safu, hii inamaanisha tu kwamba marejeleo ya safu hayawezi kubadilishwa baada ya kuundwa kwake, lakini haikatazi kwa njia yoyote uwezo wa kubadilisha yaliyomo ya vipengele vya mtu binafsi vya safu. Lugha haikuruhusu kubainisha virekebishaji vyovyote (sema, vya mwisho au vya mwisho) vya vipengele vya safu. Mipangilio ya multidimensional Java inasaidia uwezo wa kutangaza safu za multidimensional(safu zenye pande nyingi) (yaani, safu ambazo vipengele vyake ni safu nyingine), msimbo unaohusisha kutangaza matrix ya pande mbili na kuonyesha yaliyomo kwenye vipengele vyake inaweza kuonekana, kwa mfano, kama hii: kuelea mkeka = kuelea mpya; setupMatrix(mkeka); kwa (int y = o; y< mat.length; у++) { kwa (int x = o; x< mat[y].length; х++) system.out.print(mat[y][x] + " "); system.out.println(); Wakati wa kuunda safu, angalau mwelekeo wake wa kwanza, "kushoto" lazima ubainishwe. Vipimo vingine haviwezi kubainishwa - katika kesi hii itabidi kuamuliwa baadaye. Kubainisha vipimo vyote mara moja katika operator mpya ni njia fupi zaidi ya kuunda safu, kukuwezesha kuepuka haja ya kutumia waendeshaji wapya wa ziada. Usemi wa kutangaza na kuunda safu ya mkeka hapo juu ni sawa na kijisehemu kifuatacho cha msimbo: kuelea mkeka = kuelea mpya; kwa (int y = o; y< mat.length; у++) mat[y] = kuelea mpya; Aina hii ya tamko ina faida kwamba, pamoja na kupata safu zilizo na vipimo sawa (sema, 4 x 4), hukuruhusu kuunda safu za safu za vipimo tofauti muhimu kwa kuhifadhi mlolongo fulani wa data. Kuanzisha Safu Safu inapoundwa, kila kipengele hupokea thamani chaguo-msingi kulingana na aina ya mkusanyiko: sufuri (0) kwa aina za nambari, '\u0000′_ kwa char, sivyo kwa boolean, na null kwa aina za marejeleo. Kwa kutangaza safu ya aina ya marejeleo, kwa kweli tunafafanua safu ya muda aina hii. Fikiria kijisehemu cha msimbo kifuatacho: Attr attrs = Attr mpya; kwa (int i = o; i< attrs.length; i++) attrs[i] = new Attr(majina[i], maadili[i]); Baada ya kutekeleza usemi wa kwanza ulio na opereta mpya, utofauti wa attrs utakuwa na marejeleo ya safu ya vigeu 12 ambavyo vinaanzishwa ili kubatilisha. Vitu vya Attr vyenyewe vitaundwa tu kadri kitanzi kinavyoendelea. Safu inaweza kuanzishwa (wakati huo huo kama tamko lake) kwa njia ya ujenzi katika braces curly ambayo inaorodhesha maadili ya awali ya vipengele vyake: Hatari za kamba = ("Simba", "Tigers", "Bears"); Nukuu ifuatayo ya nambari itatoa matokeo sawa: Hatari za kamba = Kamba mpya; hatari = "Simba"; hatari = "Tigers"; hatari = "Bears"; Fomu ya kwanza, ambayo inabainisha orodha ya waanzilishi katika braces curly, hauhitaji matumizi ya wazi ya operator mpya - inaitwa moja kwa moja na mfumo wa kukimbia. Urefu wa safu katika kesi hii imedhamiriwa na idadi ya maadili ya kianzilishi. Inawezekana pia kutaja opereta mpya kwa uwazi, lakini kipimo bado kinapaswa kuachwa; kama hapo awali, imedhamiriwa na mfumo wa utekelezaji: Hatari za kamba = Kamba mpya("Simba", "Tigers", "Bears"); Njia hii ya tamko na uanzishaji wa safu inaweza kutumika mahali popote kwenye msimbo, kwa mfano katika usemi wa simu wa mbinu: printStringsCnew String ("moja", "mbili", "tatu"); Safu isiyo na jina ambayo imeundwa kwa njia hii inaitwa bila kujulikana(bila jina). Mikusanyiko ya safu inaweza kuanzishwa kwa mpangilio uliowekwa wa thamani za awali. Ifuatayo ni mfano wa kutangaza safu iliyo na safu mlalo chache za kwanza za kinachojulikana Pembetatu ya Pascal ambapo kila safu inaelezewa na safu yake ya maadili. int pascalsTriangle = ( { 1, 4, 6, 4, 1 }, Faharasa za safu nyingi ziko kwa mpangilio kutoka nje hadi ndani. Kwa hivyo, kwa mfano, pascalsTriangle)Kazi
