Õpe "Mänguarendaja" jaoks + töökoht

Java massiivid

Massiiv on andmestruktuur, mis salvestab sama tüüpi väärtusi. Üksiku massiivi elemendile pääseb juurde täisarvuindeksi abil. Näiteks kui a on täisarvude massiiv, siis on avaldise a [ i ] väärtus võrdne massiivi i-nda täisarvuga.

Massiiv deklareeritakse järgmiselt: kõigepealt määratakse massiivi tüüp, st massiivis sisalduvate elementide tüüp, millele järgneb paar tühja nurksulgu ja seejärel muutuja nimi. Näiteks saab täisarvude massiivi deklareerida järgmiselt:
int a;

Kuid see lause deklareerib ainult muutuja a, mitte ei initsialiseeri seda reaalse massiiviga. Massiivi loomiseks peate kasutama uut operaatorit.

See väide loob 100 täisarvust koosneva massiivi. Selle massiivi elemendid on nummerdatud vahemikus 0 kuni 99 (mitte 1 kuni 100). Pärast loomist saab massiivi täita näiteks tsükli abil.

int a = uus int;
jaoks (int i = 0; i< 100; i++)
a[i] = i; // Täidab massiivi numbritega 0 kuni 99.

Kui proovite pääseda juurde elemendile a (või mis tahes elemendile, mille indeks on väljaspool vahemikku 0 kuni 99), luues 100 elemendist koosneva massiivi, katkeb programm, kuna erand Seotud massiiviindeksiga väljaspool vahemikku.
Massiivi elementide arvu loendamiseks kasutage meetodit ArrayName.
va.pikkus.

Näiteks,

jaoks (int i = 0; i< a. length; i++ System.out.println (a[i]);

Kui massiiv on loodud, on selle suurust võimatu muuta (kuigi saate loomulikult muuta selle üksikuid elemente). Kui peate programmi täitmise ajal massiivi suurust sageli muutma, on parem kasutada mõnda muud andmestruktuuri, mida nimetatakse massiiviloendiks.

Massiivi saab deklareerida kahel viisil:

int a;
või
int a;

Enamik programmeerijaid sisse lülitatud Java keel eelistatud on esimene stiil, kuna see eraldab massiivitüübi int (täisarvulise massiivi) muutuja nimest selgemini.

Massiivi lähtestajad ja nimeta massiivid

Java keeles on võimalus massiivi loomiseks ja selle samaaegseks initsialiseerimiseks. Siin on näide sellisest süntaksist:

int smallPrimes = ( 2, 3, 5, 7, 11, 13);

Pange tähele, et sel juhul ei pea te uut operaatorit kasutama. Lisaks saate isegi initsialiseerida nimetu massiivi:

uus int ( 16, 19, 23 , 29 , 31, 37)

See avaldis eraldab mälu uuele massiivile ja täidab selle numbritega, mis on määratud lokkis traksid. Samal ajal loendatakse nende arv ja vastavalt sellele määratakse massiivi suurus. See süntaks on kasulik massiivi taasinitsialiseerimiseks ilma uut muutujat loomata. Näiteks väljend

smallPrimes = new int( 17, 19, 23, 29, 31, 37 );
on väljendi stenogramm
int anonüümne = ( 17, 19, 23, 29, 31, 37 );
smailPrimes = anonüümne;

Saate luua massiivi suurus null. Selline massiiv võib olla kasulik meetodi kirjutamisel, mis hindab massiivi, mis osutub tühjaks. Nullpikkusega massiiv deklareeritakse järgmiselt:

uus üksuse tüüp

Pange tähele, et selline massiiv ei ole nullobjektiga samaväärne.

Massiivide kopeerimine

Ühte massiivi saab kopeerida teise, kuid mõlemad muutujad viitavad samale massiivile.

int luckyNumbers = smailPrimes;
õnnenumbrid = 12; // Nüüd on smailPrimesi element samuti 12.

Tulemus on näidatud joonisel fig. 3.14. Kui soovite kopeerida kõik ühe massiivi elemendid teise, peaksite kasutama süsteemi massiivikoopia meetodit. Selle kõne näeb välja selline:

System.arraycopy(from, fromlndex, to, tolndex, count);

Massiivi to peab olema piisavalt suur, et sisaldada kõiki kopeeritavaid elemente.

Riis. 3.14. Massiivi kopeerimine

Näiteks allpool näidatud operaatorid, mille tulemused on näidatud joonisel fig. 3.15 looge kaks massiivi ja kopeerige seejärel esimese massiivi neli viimast elementi teise. Kopeerimine algab lähtemassiivi teisest positsioonist ja kopeeritavad elemendid paigutatakse sihtmassiivi, alustades kolmandast positsioonist.

int smailPrimes = (2, 3, 5, 7, 11, 13);
int õnnenumbrid = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
System.aggauser(smailPrimes, 2, õnnenumbrid, 3, 4);
jaoks (int i = 0; i< luckyNumbers.length; i++)
System.println(i +.": " + õnnenumbrid]);

Nende avalduste täitmine viib järgmise tulemuseni.

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13

Riis. 3.15. Massiivi elementide kopeerimine

Java massiiv erineb väga C++ massiivist. See aga kattub praktiliselt osutiga dünaamiline massiiv. See tähendab, et operaator

int a = uus int; //Java
on samaväärne operaatoriga
i n t * = uus i n t [ 1 0 0 ]; // C++,
kuid mitte
int a; // C++

Keeles Java operaator no kontrollib vaikimisi indeksite vahemikku. Samuti pole Java-l kursori aritmeetikat – massiivi järgmise elemendini jõudmiseks ei saa kursorit a suurendada.

Massiivid(massiivid) _ on sama tüüpi elementide järjestatud komplektid. Massiivielemendid võivad olla lihtsat ja viitetüüpi objektid, sealhulgas viited teistele massiividele. Massiivid ise on objektid ja

pärivad klassi Object. Teadaanne

int ia = uus int;

Määratleb massiivi nimega ia, mis algselt osutab kolmest elemendist koosnevale hulgale tippige int.

Massiivi deklaratsioon ei täpsusta selle suurust. Massiivi elementide arv määratakse siis, kui selle loob operaator uus. Massiivi pikkus on loomise ajal fikseeritud ja seda ei saa hiljem muuta. Kuid, muutuv massiivi tüüpi (meie näites - ia) saab igal ajal määrata uue erineva mõõtmega massiivi.

Massiivielementidele pääseb juurde nende indeksinumbrite väärtuste järgi.

Massiivi esimesel elemendil on indeks, null(0) ja viimane on pikkus - 1. Massiivi elemendile pääseb juurde massiivi nime ja indeksi väärtuse määramisega, mis on ümbritsetud nurksulgudega [ ja ]. eelmises näites oleks ia massiivi esimene element ia ja viimane element ia. Iga kord, kui massiivi elemendile indeksi kaudu juurde pääseb, käivitatakse Java süsteem kontrollib, kas indeksi väärtus on piirides, ja viskab ArrayIndexOutOfBoundsExceptioni, kui kontroll on vale. 6 Indeksi avaldis peab olema int tüüpi – see on ainus piirang maksimaalne summa massiivi elemendid.

Massiivi pikkust saab hõlpsasti määrata massiiviobjekti pikkuse välja abil (mis on kaudselt märgitud avalikuks ja lõplikuks). Siin on eelmise näite värskendatud kood, mis käivitab silmuse, mis prindib ekraanile ia massiivi iga elemendi sisu:

for (int i = o; i< ia.length; i++)

system.out.println(i + ": " + ia[i]);

Tavaliselt nimetatakse massiivi, mille pikkus on null (st massiivi, milles elemente pole). tühi. Pange tähele, et nullmassiivi viide ja tühi massiiviviide on täiesti erinevad asjad. Tühi massiiv on tõeline massiiv, millel lihtsalt pole elemente. Tühi massiiv on meetodist naasmisel mugav alternatiiv nullile. Kui meetod on võimeline tagastama nulli, peab rakenduse kood, milles meetod välja kutsutakse, võrdlema tagastatud väärtust nulliga enne ülejäänud toimingute jätkamist. Kui meetod tagastab massiivi (võimalik, et see on tühi), pole täiendavaid kontrolle vaja – muidugi peale massiivi pikkusega seotud kontrollide ja need tuleks igal juhul läbi viia.

Lubatud on ka muu massiivi deklaratsiooni vorm, kus nurksulud määratakse massiivi identifikaatori, mitte selle tüübi nime järel:

int ia = uus int;

Eelistatakse siiski endist süntaksit, kuna tüübideklaratsioon on kompaktsem.

Modifikaatorid massiivi deklaratsioonides

Teatud massiivide kasutamise reeglid deklaratsioonides modifikaatorid on tavalised ja sõltuvad ainult sellest, kas massiiv kuulub väljadele või kohalikele muutujatele. On üks asi, mida on oluline meeles pidada – modifikaatorid kehtivad massiivile kui sellisele, kuid mitte selle üksikutele elementidele. Kui massiivi deklaratsioon sisaldab lõplikku atribuuti, tähendab see ainult seda, et viidet massiivile ei saa pärast selle loomist muuta, kuid see ei keela mingil viisil sisu muutmise võimalust üksikud elemendid massiivi. Keel ei võimalda massiivi elementide jaoks mingeid modifikaatoreid (näiteks lõplik või uolatiilne) määrata.

Mitmemõõtmelised massiivid

Java toetab deklareerimisvõimalust mitmemõõtmelised massiivid (mitmemõõtmelised massiivid) (st massiivid, mille elemendid on muud massiivid), kood, mis deklareerib kahemõõtmelise maatriksi ja kuvab selle elementide sisu ekraanil, võib välja näha järgmine:

ujukimatt = uus ujuki;

setupMatrix(mat);

for (int y = o; y< mat.length; у++) {

jaoks (int x = o; x< mat[y].length; х++)

system.out.print(mat[y][x] + " ");

system.out.println();

Massiivi loomisel tuleb määrata vähemalt selle esimene, "vasakpoolseim" dimensioon. Muid mõõtmeid ei pruugita määrata – sel juhul tuleb need hiljem määrata. Kõigi mõõtmete korraga määramine uues operaatoris on kõige ülevaatlikum viis massiivi loomiseks, vältides vajadust kasutada täiendavad operaatorid uus. Ülaltoodud mati massiivi deklaratsioon ja loomise avaldus on samaväärne järgmise koodilõiguga:

ujukimatt = uus ujuki;

for (int y = o; y< mat.length; у++)

mat[y] = uus ujuk;

Selle deklaratsioonivormi eeliseks on see, et see võimaldab koos samade mõõtmetega massiivide hankimisega (näiteks 4 x 4) koostada erinevate mõõtmetega massiive, mis on vajalikud teatud andmejadade salvestamiseks.

Massiivi initsialiseerimine

Massiivi loomisel saab iga element vaikeväärtuse, mis sõltub massiivi tüübist: null (0) - jaoks numbrilised tüübid, ‘\u0000′ _ tähemärgi jaoks, false tõeväärtuse jaoks ja null viitetüüpide jaoks. Viitetüüpi massiivi deklareerimisega defineerime tegelikult massiivi rase seda tüüpi. Kaaluge järgmist koodilõiku:

Attr attrs = uus attr;

for (int i = o; i< attrs.length; i++)

attrs[i] = new Attr(nimed[i], väärtused[i]);

Pärast esimest uut operaatorit sisaldava avaldise täitmist saab attrs muutuja viite 12 muutuja massiivile, mis initsialiseeritakse null, Attr-objektid kui sellised luuakse ainult tsükli ajal.

Massiivi saab lähtestada (samaaegselt deklaratsiooniga) lokkis sulgudes oleva konstruktsiooni abil, mis loetleb selle elementide algväärtused:

Stringohud = ( "Lõvid", "Tiigrid", "Karud" );

Järgmine koodilõik annab sama tulemuse:

Stringohud = uus String; ohud = "Lõvid";

ohud = "Tiigrid";

ohud = "Karud";

Esimene vorm, mis hõlmab initsialiseerijate loendi määramist lokkis sulgudes, ei nõua uue operaatori selgesõnalist kasutamist – käitussüsteem kutsub seda kaudselt. Massiivi pikkuse määrab sel juhul initsialiseerija väärtuste arv. Samuti on võimalik uut operaatorit selgesõnaliselt määrata, kuid dimensioon tuleks siiski välja jätta, nagu varemgi, määrab selle täitmissüsteem:

Stringohud = new String ( "Lions", "Tiigrid", "Karud" );

Seda massiivi deklaratsiooni ja initsialiseerimise vormi saab kasutada kõikjal koodis, näiteks meetodi kutseavaldises:

printStringsCnew String( "üks", "kaks", "kolm" ));

Sel viisil loodud nimetu massiivi kutsutakse anonüümne(anonüümne).

Massiivide massiive saab lähtestada pesastatud järjestustega algväärtused. Järgnevalt on toodud näide massiivi deklareerimisest, mis sisaldab paari esimest rida nn Pascali kolmnurk kus iga rida kirjeldatakse oma väärtuste massiiviga.

int pascalsTriangle = (

{ 1, 4, 6, 4, 1 },

Mitmemõõtmelised massiiviindeksid on järjestuses välimisest sisemiseni. Näiteks pascalsTriangle = uus java.awt.Point(); ) // nüüd saab kasutada massiivi punkte.x = 1; //<-- NO NullPointerException here!

Ma tahan konkreetselt puudutada objektide massiivi elementide kopeerimise küsimust. Kuna see sisaldab linke, kopeeritakse need. Need. pärast kopeerimist osutab uus massiiv samale objektide komplektile! Ja kui muudate mõne objekti sisemist olekut, on see nähtav, kui sellele juurde pääsete mis tahes massiivi kaudu.

Niisiis, hiilisime aeglaselt kõige huvitavama jaotiseni -

Mitmemõõtmelised massiivid

See on teistest keeltest kõige paremini eristatav massiivide klass. Ausalt öeldes pole ma midagi sellist kuskil mujal näinud. Lihtsuse huvides alustame kahemõõtmelistest massiividest ja liigume siis edasi n-mõõtmeliste massiividega.

Kõigepealt tahan mainida seda tõsiasja. Kahemõõtmelise massiivi jaoks pole sellist asja nagu selle mõõtmed. Massiivi suuruse saate määrata ainult esimese indeksi järgi. Põhjus peitub massiivi korralduses. See on massiivi viidete massiiv, millest igaüks sisaldab tegelikke andmeid. Ja need massiivid võivad olla erineva pikkusega!

Mõelge sellele kahemõõtmelisele massiivile. Selle pikkus esimese indeksi juures on 3 . Seda saab hankida a.length kaudu. Selle massiivi elemendid on lingid andmetega massiividele. Kõigi nende massiivide pikkuse saab ka .length kaudu. Kõigile nendele massiividele pääseb juurde selle indeksi kaudu – massiivi esimene indeks a .

Ma arvan, et nüüd on selge, et kahemõõtmelise massiivi pikkusest saame rääkida ainult esimese indeksi juures. Teise indeksi maksimaalse väärtuse saab saada ainult esimese indeksi iga konkreetse väärtuse kohta.

// 2d massiivi ints, milles on 10 rida, igaühes 5 elementi int massiiv2d = uus int;

See konstruktsioon loob 10x5 2D massiivi. Siin saame rääkida suurustest ainult seetõttu, et teise indeksi suurus on lähtestamise käigus selgesõnaliselt määratud. Ja kõik stringid on pikkusega 5, massiiv on ristkülikukujuline.

Siiski on veel üks viis. Näiteks loome ülaltoodud joonisel näidatud massiivi:

int a = uus int; // rida 1 a = uus int; // rida 2 a = uus int; // rida 3 a = uus int; // rida 4

Pange tähele, et real 1 ei ole massiivi lähtestamisel teise indeksi dimensiooni määratud!

Mis selles koodis toimub? 1. rida loob esimese indeksi juures massiivi, mille suurus on 3 . See tähendab, et mälu eraldatakse stringimassiividele kolme viite jaoks. Massiive endid ei looda, eraldatud mälu lähtestatakse nulliks.

Rida 2 loob massiivi pikkusega 2 . Viide sellele massiivile salvestatakse massiivi esimesse elemendisse esimese indeksi juures. Samamoodi luuakse ridadel 3 ja 4 massiivid, millele viited salvestatakse massiivi teises ja kolmandas elemendis esimese indeksi juures.

Selle tulemusena on meil suvalise kujuga massiiv. Muidugi võiksime luua kõik kolm ühepikkust stringimassiivi, näiteks 5 . Need toimingud oleksid täiesti samaväärsed uue int-konstruktsiooniga.

Tasub veel kord mainida, et objektide tüüpidega stringimassiivide loomisel on olukord täpselt sama, mis ühemõõtmeliste massiivide puhul (mida nad tegelikult ka on). Objektiviidete jaoks eraldatakse mälu, kuid objekte endid ei looda.

Liigume nüüd edasi n-mõõtmeliste massiivide juurde. Siin pole midagi uut. Nii nagu kahemõõtmeline massiiv on viidete massiiv ühemõõtmelistele massiividele, nii on kolmemõõtmeline massiiv viidete loend, kuid kahemõõtmelistele massiividele. Üldreegel on:

N-mõõtmeline massiiv on ühemõõtmeline massiiv, mille elemendid on viited massiividele mõõtmetega N-1.

Seega saab N-mõõtmelisi massiive luua ühe avaldisega, kasutades uut operaatorit ja määrates kõikide mõõtmete suurused. Või saate järjestikku luua massiivi, määrates mõõtmed ühe või mitme indeksiga, ja lähtestada ülejäänud initsialiseerimata viited käsitsi, luues soovitud mõõtmetega, kuid suvalise suuruse/kujuga massiive. Kõrgmõõtmeliste massiivide puhul on see aga minu arvates üsna keeruline ülesanne. Tegelikult, samuti üldiselt töötada mitmemõõtmeliste massiividega.

Eraldi paar sõna mitmemõõtmeliste massiivide kopeerimisest System.arraycopy abil. Massiivid kopeeritakse AINULT esimese indeksiga. Teisisõnu, viited N-1 massiivile esimesest massiivist kantakse üle teise massiivi. Kahemõõtmelise massiivi puhul on need viited stringimassiividele. See asjaolu hõlbustab oluliselt massiivide kopeerimist, näiteks uue rea lisamisel - mälu tuleb eraldada ainult esimese indeksi massiivi jaoks. Edasised viited kõikidele ridadele kopeeritakse uude massiivi ja viimane link, mis peaks osutama uuele reale, lähtestatakse käsitsi:

int initArray; // massiivi algus int newArrayLength = initArray.length+1; int uusArray = uus int; jaoks(int i = 0; i uus int[];

Nagu mainisin, teeb System.arraycopy täpselt sama asja, mis ülaltoodud silmus, ainult et kiiremini.

Võib-olla on massiivide kohta praegu piisavalt räägitud. Kloonimisest võiks küll rääkida, aga minu arvates jääb see teema juba selle artikli raamidest välja. Sest see artikkel on endiselt suures osas keskendunud algajatele arendajatele.

Aitäh kõigile! Loodan, et kellelegi oli see teave kasulik ja huvitav.

Massiiv on sama tüüpi objektide kogum, millel on üldnimetus. Igale massiivi elemendile pääseb juurde selle indeksi kaudu. Vaatleme tõelist näidet. Oletame, et meil on ladu nimega a ja see sisaldab teatud arvu kaste, millest igaüks on järjestikku nummerdatud. Igas kastis on mõni objekt, mis oma tüübilt ühtib teistes kastides olevate objektidega. Selle lao näiteks on klassikaline massiiv, kus lao nimi on massiivi nimi, lahtrid on massiivi elemendid, lahtrite numbrid on elementide indeksid ja kastide sisu on meie muutujate väärtused. Kujutage ette, et kastide sees on sidrunid ja igas kastis on teatud arv sidruneid. Seejärel näitavad meie muutujate väärtused sidrunite arvu. Vaatleme sellist kolmest kastist koosnevat ladu, olgu esimeses kastis 3, teises 7, kolmandas 273. Seejärel saab seda ladu kirjeldava massiivi esitada järgmiselt:

Indeks	0	1	2
Tähendus	3	7	273

Indekseerimine massiivis algab alati 0-st. Vaatleme mõnda toimingut, mida saab teha massiiviga:

Massiivi loomine

Tüüp VariableName;
int a;//täisarvu massiiv
char b;//märkide massiiv
String c;

Mälu eraldamine:

A = uus int;//eraldake mälu 10 elemendi jaoks
b = uus tähemärk;//eraldake mälu 20 elemendi jaoks
c = uus string;//eraldake mälu 30 elemendi jaoks

Nii et massiivi initsialiseerimine näeb välja selline:

Int a = uus int;//10 elemendist koosneva täisarvude massiivi initsialiseerimine
char b = uus char;//20 elemendist koosneva märgimassiivi initsialiseerimine
String c = uus String;//30 elemendist koosneva stringimassiivi initsialiseerimine

Kõigile massiivi elementidele pärast sellist initsialiseerimist määratakse vaikeväärtus.
Massiivi elementide väärtused on võimalik kohe määrata, loome massiivi, mis näitab kastis olevate sidrunite arvu, nagu ülaltoodud näites:

int a = new int( 3, 7, 273 );

Töötamine massiiviga

Massiivi lugemine:

Impordi java.util.Scanner;
avaliku klassi test(
avalik static void main(String args) (
int a;//täisarvude massiiv
int n;//massiivi elementide arv
Skanner sisse = uus skanner(System.in);
n = in.nextInt();
a = uus int[n];
for(int i = 0; i Massiivi väärtuste muutmine:

for(int i = 0; i Massiivi väljund:

Int a;//täisarvude massiiv, mis on kuidagi töödeldud
for(int i = 0; i Juhuslik juurdepääs massiivi elemendile indeksi järgi:

System.out.println(a);//Prindib massiivi esimese elemendi
a = 1;//Määrake massiivi teisele elemendile 1
int temp = a;//Salvesta massiivi kolmanda elemendi väärtus temp-muutujasse

Nii näevad välja põhitoimingud massiividega. Väga sageli palutakse neil erinevates informaatikatundides need massiiviga töötamise etapid eraldi funktsioonidesse teisaldada, kuid sellest räägime hiljem. Seega saame massiivi lugedes konsoolist sisestada mingi väärtuse, väärtusi muutes näiteks kõiki väärtusi ühe võrra suurendada või kahega korrutada ning väljundit kasutades kuvada voolu massiivi väärtused. Kui peame töötama ainult massiivi kindlate elementidega, siis siin saame kasutada juhuslikku juurdepääsu indeksi järgi, kus indeks on suvaline positiivne täisarv, mis on väiksem kui massiivi pikkus. Massiivi praeguse pikkuse saab saada atribuudi pikkus abil, mida rakendati juba massiivi kuvamisel.
Siin jätan vahele dialoogi selle kohta, et massiivid on viited ja nendega töötamine erineb tavaliste baastüüpidega töötamisest.

2D massiivid

Alati ei ole laos mugav lahtreid nummerdada 0-st kindla numbrini, vahel tahetakse ladu korratumale kujule viia, näiteks ridu sisestada. Nüüd on igal kastil oma rea ​​number ja seerianumber selles reas. Oletame, et meie laos on üheksa kasti, mis sisaldavad 1, 2 ja nii edasi 9 apelsini. Laos olevad kastid on paigutatud kolmes kolmes kastis kolmes reas, siis saab lao olukorra kujutada järgmiselt.

massiivi (inglise massiiv) see on objekt, mis salvestab kindla arvu sama tüüpi väärtusi. Teisisõnu, massiiv on muutujate nummerdatud kogum. Massiivi muutujat nimetatakse massiivi element, ja selle asukoha massiivis annab indeks. Näiteks peame salvestama 50 erinevat nime, näete, on ebamugav iga nime jaoks eraldi muutujat luua, seega kasutame massiivi. Massiivi elementide nummerdamine algab 0-st ja massiivi pikkus määratakse selle loomise ajal ja on fikseeritud.

Selguse mõttes pilt, millelt tegin Java õpetus.

Massiivi loomiseks peate selle deklareerima, reserveerima selle jaoks mälu ja lähtestama.

Massiivi deklaratsioon Java keeles

Javas massiivi loomisel on esimene samm selle deklareerimine. Seda saab teha järgmiselt:

Int myFirstArray;

Massiivi saate deklareerida ka järgmiselt:

int mySecondArray;

Seda aga Java kodeerimise tava ei tervita, sest sulud näitavad, et tegemist on massiiviga ja on mõttekamad, kui need on tüübitähise kõrval.

Selle näite põhjal oleme deklareerinud 2 massiivi nimega myFirstArray Ja mySecondArray. Mõlemad massiivid sisaldavad tüüpi elemente int.

Samamoodi saate deklareerida mis tahes tüüpi massiivi:

bait anArrayOfBytes; lühike anArrayOfShorts; pikk anArrayOfLongs; float anArrayOfFloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

Massiivi tüüp määratakse tüübi järgi, kus tüüp on selles sisalduvate elementide andmetüüp. Sulud on eriline märge, et muutujad sisalduvad massiivis. Massiivi nimi võib olla ükskõik milline, kuid see peab ühtima .

Massiive saab luua mitte ainult põhitüüpide muutujatest, vaid ka suvalistest objektidest.

Kui massiiv on deklareeritud Java keeles, siis selle suurust ei määrata ja sellele ei reserveerita mälu. See loob ainult viite massiivile.

Massiivi mälureserveerimine ja selle lähtestamine.

Int myFirstArray; myFirstArray = uus int;

Meie näites oleme loonud 15 tüüpi elemendist koosneva massiivi int ja määras selle eelnevalt deklareeritud muutujale myFirstArray.

Samal real saate deklareerida ka massiivi nime ja reserveerida sellele mälu.

int myArray = uus int;

Massiivi loomisel märksõna abil uus, lähtestatakse kõik massiivi elemendid automaatselt nullväärtustele. Massiivi elementide algväärtuste määramiseks on vaja see läbi viia initsialiseerimine. Initsialiseerimist saab teha elemendi kaupa

MyFirstArray = 10; // esimese elemendi initsialiseerimine myFirstArray = 20; // teise elemendi initsialiseerimine myFirstArray = 30; // jne.

ja tsüklis, kasutades indeksit, läbides kõik massiivi elemendid ja määrates neile väärtused.

For(int i = 0; i< 15; i++){ myFirstArray[i] = 10; }

Nagu eelmistest näidetest näha, tuleb massiivielemendile viitamiseks määrata selle nimi ja seejärel nurksulgudes elemendi indeks. Konkreetse indeksi massiivi element käitub samamoodi kui muutuja.

Kaaluge massiivi loomist ja lähtestamist järgmise näite abil. Selles loome massiivi, mis sisaldab numbreid 0-9, ja prindime väärtused konsooli.

//massiivi loomine ja initsialiseerimine int numberMassiiv = new int; for(int i = 0; i< 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Lihtsustatud märge

Massiivi loomiseks ja lähtestamiseks saate kasutada ka lihtsustatud tähistust. See ei sisalda sõna uus, ja massiivi algväärtused on loetletud sulgudes.

int myColor = (255, 255, 0);

Siin määratakse massiivi pikkus sulgudes olevate väärtuste arvu järgi, mis on eraldatud komadega. See tähistus sobib rohkem väikeste massiivide loomiseks.

Massiivi suuruse määramine

Massiivi suurus ei ole alati ilmne, seega kasutage selle väljaselgitamiseks atribuuti pikkus, mis tagastab massiivi pikkuse.

MyColor.length;

See kood aitab meil teada saada, et myColor massiivi pikkus on 3.

Näide: 4 arvu korral peate leidma miinimumi

int numbrid = (-9, 6, 0, -59); int min = numbrid; for(int i = 0; i< numbers.length; i++){ if(min>numbrid[i]) min = arvud[i]; ) System.out.println(min);

Harjutused Java ühemõõtmeliste massiivide kohta:

1. Looge massiiv, mis sisaldab 10 esimest paaritut numbrit. Trüki massiivi elemendid konsooli ühele reale, eraldades need komaga.
2. Arvestades massiivi dimensiooniga N, leidke massiivi väikseim element ja printige konsooli (kui väikseimaid elemente on mitu, printige need kõik).
3. Leia ülesande 2 massiivist suurim element.
4. Vahetage massiivi suurimad ja väikseimad elemendid. Näide: antud massiiv (4, -5, 0, 6, 8). Pärast asendamist näeb see välja selline (4, 8, 0, 6, -5).
5. Leidke kõigi massiivi elementide aritmeetiline keskmine.