Studeren om "Game Developer" te worden + dienstverband

Java-arrays

Een array is een datastructuur waarin waarden van hetzelfde type worden opgeslagen. Een individueel array-element wordt benaderd met behulp van een geheeltallige index. Als a bijvoorbeeld een array van gehele getallen is, dan is de waarde van de uitdrukking a[i] gelijk aan het i-de gehele getal in de array.

Een array wordt als volgt gedeclareerd: eerst wordt het type array aangegeven, dat wil zeggen het type elementen in de array, gevolgd door een paar lege vierkante haken en vervolgens de naam van de variabele. Zo declareert u bijvoorbeeld een array die uit gehele getallen bestaat:
int a;

Deze instructie declareert echter alleen de variabele a, zonder deze te initialiseren met een daadwerkelijke array. Om een ​​array te maken, moet je de nieuwe operator gebruiken.

Deze operator maakt een array van 100 gehele getallen. De elementen van deze array zijn genummerd van 0 tot 99 (niet van 1 tot 100). Eenmaal gemaakt, kan de array bijvoorbeeld worden gevuld met behulp van een lus.

int a = nieuwe int;
voor (int i = 0; ik< 100; i++)
een[ik] = ik; // Vult de array met getallen van 0 tot 99.

Als u toegang probeert te krijgen tot element a (of een ander element waarvan de index buiten het bereik van 0 tot 99 ligt) door een array van 100 elementen te maken, crasht het programma omdat uitzonderlijke situatie, geassocieerd met het feit dat de array-index buiten het toegestane bereik ligt.
Gebruik de methode nameMass om het aantal elementen in een array te tellen.
va.lengte.

Bijvoorbeeld,

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

Als een array eenmaal is gemaakt, is het onmogelijk om de grootte ervan te wijzigen (hoewel u uiteraard wel de afzonderlijke elementen ervan kunt wijzigen). Als u de grootte van een array regelmatig moet wijzigen tijdens de uitvoering van een programma, is het beter om een ​​andere datastructuur te gebruiken, een zogenaamde arraylijst.

Een array kan op twee manieren worden gedeclareerd:

int a;
of
int a;

De meeste programmeurs Java-taal De eerste stijl heeft de voorkeur omdat deze het arraytype int (integer array) duidelijker scheidt van de naam van de variabele.

Array-initialisatoren en naamloze arrays

Java heeft de mogelijkheid om tegelijkertijd een array te maken en deze te initialiseren. Hier is een voorbeeld van zo’n syntactische structuur:

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

Merk op dat het in dit geval niet nodig is om de nieuwe operator te gebruiken. Bovendien kunt u zelfs een naamloze array initialiseren:

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

Deze expressie wijst geheugen toe voor een nieuwe array en vult dit met de opgegeven getallen in gekrulde beugels. In dit geval wordt hun aantal berekend en dienovereenkomstig wordt de grootte van de array bepaald. Deze syntactische constructie is handig om te gebruiken om een ​​array opnieuw te initialiseren zonder een nieuwe variabele te maken. De uitdrukking bijvoorbeeld

kleinePriemgetallen = new int( 17, 19, 23, 29, 31, 37 );
is een verkorte uitdrukking
int anoniem = ( 17, 19, 23, 29, 31, 37);
smailPrimes = anoniem;

U kunt een array maken nul grootte. Zo'n array kan handig zijn bij het schrijven van een methode die een array evalueert die leeg blijkt te zijn. Een array met lengte nul wordt als volgt gedeclareerd:

nieuw elementtype

Merk op dat een dergelijke array niet equivalent is aan een nulobject.

Arrays kopiëren

De ene array kan naar de andere worden gekopieerd, maar beide variabelen verwijzen naar dezelfde array.

int luckyNumbers = smailPrimes;
luckyNimbers = 12; // Nu is het smailPrimes-element ook 12.

Het resultaat wordt getoond in Fig. 3.14. Als u alle elementen van de ene array naar de andere wilt kopiëren, moet u de arraycopy-methode uit de klasse System gebruiken. Zijn oproep ziet er als volgt uit:

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

De to-array moet groot genoeg zijn om alle te kopiëren elementen te bevatten.

Rijst. 3.14. Een array kopiëren

De hieronder getoonde operatoren, waarvan de resultaten worden getoond in Fig. 3.15, maak twee arrays en kopieer vervolgens de laatste vier elementen van de eerste array naar de tweede. Het kopiëren begint vanaf de tweede positie in de bronarray en de gekopieerde elementen worden vanaf de derde positie in de doelarray geplaatst.

int smailPriemgetallen = (2, 3, 5, 7, 11, 13);
int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
Systeem.aggausor(smailPrimes, 2, luckyNumbers, 3, 4);
voor (int i = 0; ik< luckyNumbers.length; i++)
Systeem.println(i +.": " + luckyNumbersfi]);

Het uitvoeren van deze instructies levert het volgende resultaat op.

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

Rijst. 3.15. Array-elementen kopiëren

Een array in Java verschilt aanzienlijk van een array in C++. Het valt echter praktisch samen met de aanwijzer naar dynamische reeks. Dit betekent dat de exploitant

int a = nieuwe int; //Java
is gelijk aan de operator
ik n t * = nieuw in n t [ 1 0 0 ] ; // C++,
en niet
int a; // C++

In taal Java-operator no controleert standaard het bereik van indexwijzigingen. Bovendien beschikt Java niet over pointer-berekeningen: u kunt een pointer niet verhogen om toegang te krijgen tot het volgende element van een array.

Arrays(arrays) _ zijn geordende sets elementen van hetzelfde type. De elementen van een array kunnen eenvoudige objecten en referentietypen zijn, inclusief nummer en verwijzingen naar andere arrays. Arrays zelf zijn objecten en

de klasse Object overnemen. Aankondiging

int ia = nieuwe int;

Definieert een array met de naam ia die in eerste instantie verwijst naar een set van drie elementen typ int.

De array-declaratie geeft de dimensie ervan niet aan. Het aantal array-elementen wordt opgegeven wanneer het wordt gemaakt met behulp van exploitant nieuw. De lengte van de array ligt vast op het moment dat deze wordt gemaakt en kan later niet meer worden gewijzigd. Echter, variabel arraytype (in ons voorbeeld – ia) kan op elk moment een nieuwe array met een andere dimensie worden toegewezen.

Array-elementen zijn toegankelijk via de waarden van hun indexnummers.

Het eerste element van de array heeft een index, gelijk aan nul(0), en de laatste is lengte – 1. U krijgt toegang tot een array-element door de arraynaam en de indexwaarde op te geven tussen vierkante haakjes, [ en ]. in het vorige voorbeeld zal het eerste element van de ia-array ia zijn, en het laatste element ia. Elke keer dat een array-element wordt benaderd door index, wordt het executing Java-systeem controleert of de indexwaarde binnen aanvaardbare grenzen ligt en genereert een uitzondering van het type ArraylndexOutOfBoundsException als het testresultaat false is. 6 De indexexpressie moet van het type int zijn - dat is alles maximale hoeveelheid array-elementen.

De lengte van een array kan eenvoudig worden bepaald met behulp van het lengteveld van het arrayobject (dat impliciet is voorzien van de publieke en definitieve attributen). Hieronder staat de bijgewerkte code van het vorige voorbeeld, die voorziet in de uitvoering van een lus die ervoor zorgt dat de inhoud van elk element van de array ia op het scherm wordt weergegeven:

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

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

Meestal wordt een array met een lengte nul genoemd (dat wil zeggen een array zonder elementen). leeg. Merk op dat een nularrayreferentie en een lege arrayreferentie twee totaal verschillende dingen zijn. Een lege array is een echte array die eenvoudigweg geen elementen bevat. Een lege array biedt een handig alternatief voor null bij het retourneren van een methode. Als een methode null kan retourneren, moet de toepassingscode die de methode aanroept de geretourneerde waarde vergelijken met null voordat wordt verdergegaan met de overige bewerkingen. Als de methode een array retourneert (mogelijk leeg), zijn er geen extra controles nodig - uiteraard behalve die met betrekking tot de lengte van de array, die in ieder geval moeten worden uitgevoerd.

Een andere vorm van array-declaratie is ook toegestaan, waarbij vierkante haken worden gespecificeerd na de array-ID, en niet achter de naam van het type:

int ia = nieuwe int;

De eerstgenoemde syntaxis verdient echter de voorkeur omdat deze de typedeclaratie compacter maakt.

Modifiers in array-declaraties

Regels voor het gebruik van bepaalde arrays in declaraties modificatoren komen vaak voor en zijn alleen afhankelijk van de categorie waartoe de array behoort: velden of lokale variabelen. Er is één ding dat belangrijk is om te onthouden: modifiers zijn van toepassing op de array zelf, maar niet op de afzonderlijke elementen ervan. Als het laatste attribuut wordt gespecificeerd in een arraydeclaratie, betekent dit alleen dat de verwijzing naar de array na de creatie ervan niet kan worden gewijzigd, maar verbiedt dit op geen enkele manier de mogelijkheid om de inhoud te wijzigen individuele elementen reeks. De taal staat niet toe dat u modifiers (bijvoorbeeld final of final) voor array-elementen specificeert.

Multidimensionale arrays

Java ondersteunt de mogelijkheid om te declareren multidimensionale arrays (multidimensionale arrays) (dat wil zeggen arrays waarvan de elementen andere arrays zijn), zou de code die betrekking heeft op het declareren van een tweedimensionale matrix en het weergeven van de inhoud van de elementen op het scherm er bijvoorbeeld als volgt uit kunnen zien:

vlottermat = nieuwe vlotter;

opstellingMatrix(mat);

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

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

systeem.uit.print(mat[y][x] + " ");

systeem.out.println();

Bij het maken van een array moet in ieder geval de eerste, "meest linkse" dimensie worden opgegeven. Andere afmetingen zijn mogelijk niet gespecificeerd; in dit geval moeten ze later worden bepaald. Het in één keer opgeven van alle dimensies in de nieuwe operator is de meest beknopte manier om een ​​array te maken, waardoor u de noodzaak om te gebruiken vermijdt extra exploitanten nieuw. De expressie voor het declareren en maken van de bovenstaande mat-array is gelijk aan het volgende codefragment:

vlottermat = nieuwe vlotter;

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

mat[y] = nieuwe vlotter;

Deze vorm van declaratie heeft het voordeel dat je, naast het verkrijgen van arrays met dezelfde afmetingen (bijvoorbeeld 4 x 4), je in staat stelt arrays van arrays met verschillende afmetingen te bouwen die nodig zijn voor het opslaan van bepaalde gegevensreeksen.

Arrays initialiseren

Wanneer een array wordt gemaakt, krijgt elk element een standaardwaarde, afhankelijk van het arraytype: nul (0) voor numerieke typen, ‘\u0000′ _ voor char, false voor boolean en null voor referentietypen. Door een array van een referentietype te declareren, definiëren we feitelijk een array tijdelijk dit type. Beschouw het volgende codefragment:

Attr attrs = nieuwe Attr;

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

attrs[i] = new Attr(namen[i], waarden[i]);

Na het uitvoeren van de eerste expressie die de nieuwe operator bevat, ontvangt de attrs-variabele een verwijzing naar een array van 12 variabelen die zijn geïnitialiseerd nul Attr-objecten als zodanig worden alleen gemaakt naarmate de lus vordert.

Een array kan worden geïnitialiseerd (tegelijk met de declaratie ervan) door middel van een constructie tussen accolades die de initiële waarden van de elementen opsomt:

String gevaren = ("Leeuwen", "Tijgers", "Beren");

Het volgende codefragment geeft hetzelfde resultaat:

Stringgevaren = nieuwe String; gevaren = "Leeuwen";

gevaren = "Tijgers";

gevaren = "Beren";

Het eerste formulier, dat een lijst met initialisatoren tussen accolades specificeert, vereist geen expliciet gebruik van de new-operator; deze wordt indirect aangeroepen door het runtime-systeem. De lengte van de array wordt in dit geval bepaald door het aantal initialisatiewaarden. Het is ook mogelijk om de nieuwe operator expliciet te specificeren, maar de dimensie moet nog steeds worden weggelaten, zoals voorheen; deze wordt bepaald door het uitvoeringssysteem:

String gevaren = new String("Leeuwen", "Tijgers", "Beren");

Deze vorm van arraydeclaratie en initialisatie kan overal in de code worden gebruikt, bijvoorbeeld in een methodeaanroepexpressie:

printStringsCnew String ("één", "twee", "drie" ));

Een naamloze array die op deze manier wordt gemaakt, wordt aangeroepen anoniem(anoniem).

Arrays van arrays kunnen worden geïnitialiseerd met behulp van geneste reeksen initiële waarden. Hieronder ziet u een voorbeeld van het declareren van een array met de eerste paar rijen van het zogenaamde De driehoek van Pascal waarbij elke rij wordt beschreven door zijn eigen reeks waarden.

int pascalsdriehoek = (

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

De indexen van multidimensionale arrays zijn gerangschikt van buiten naar binnen. Dus bijvoorbeeld pascalsTriangle = nieuw java.awt.Point(); ) // nu kunt u array points.x = 1 gebruiken; //<-- NO NullPointerException here!

Ik wil specifiek ingaan op de kwestie van het kopiëren van elementen van een reeks objecten. Omdat het links bevat, worden deze gekopieerd. Die. na het kopiëren zal de nieuwe array naar dezelfde set objecten verwijzen! En als u de interne status van een van de objecten wijzigt, zal dit zichtbaar zijn wanneer u er toegang toe krijgt via een van de arrays.

We naderen dus langzaam het meest interessante gedeelte:

Multidimensionale arrays

Dit is de meest verschillende klasse arrays van andere talen. Eerlijk gezegd heb ik zoiets nog nooit ergens anders gezien. Voor de eenvoud beginnen we met tweedimensionale arrays en gaan dan verder met n-dimensionale arrays.

Allereerst wil ik dit feit vermelden. Voor een tweedimensionale array bestaan ​​er niet zoiets als de afmetingen ervan. U kunt de grootte van een array alleen bepalen aan de hand van de eerste index. De reden ligt in de organisatie van de array. Het is een array van verwijzingen naar arrays, die elk echte gegevens bevatten. En deze arrays kunnen verschillende lengtes hebben!

Laten we eens kijken naar deze tweedimensionale array. De lengte bij de eerste index is 3. Het kan worden verkregen via a.length . De elementen van deze array zijn koppelingen naar arrays met gegevens. De lengte van elk van deze arrays kan ook worden verkregen via .length . Elk van deze arrays is toegankelijk via zijn index - de eerste index in de array a .

Ik denk dat het nu duidelijk is dat we alleen kunnen praten over de lengte van een tweedimensionale array bij de eerste index. De maximale waarde van de tweede index kan alleen worden verkregen voor elke specifieke waarde van de eerste index.

// 2D-array van ints met 10 rijen van elk 5 elementen int array2d = nieuwe int;

Dit ontwerp creëert een 2D-array van formaat 10x5. We kunnen hier alleen over maten praten omdat de grootte bij de tweede index expliciet wordt opgegeven tijdens de initialisatie. En alle lijnen hebben een lengte van 5, de array is rechthoekig.

Er is echter een andere manier. Laten we bijvoorbeeld de array maken die wordt weergegeven in de bovenstaande afbeelding:

int een = nieuwe int; // regel 1 a = nieuwe int; // regel 2 a = nieuwe int; // regel 3 a = nieuwe int; // regel 4

Houd er rekening mee dat in regel 1, bij het initialiseren van de array, de dimensie bij de tweede index niet wordt aangegeven!

Wat gebeurt er in deze code? Regel 1 creëert een array bij de eerste index, grootte 3. Dit betekent dat er geheugen wordt toegewezen voor drie verwijzingen naar stringarrays. De arrays zelf worden niet gemaakt; toegewezen geheugen wordt geïnitialiseerd met nulwaarden.

Lijn 2 creëert een array met lengte 2. Een verwijzing naar deze array wordt opgeslagen in het eerste element van de array bij de eerste index. Op dezelfde manier creëren de lijnen 3 en 4 arrays waarvan de referenties zijn opgeslagen in het tweede en derde element van de array bij de eerste index.

Als gevolg hiervan hebben we een reeks willekeurige vormen. Natuurlijk kunnen we alle drie de stringarrays van dezelfde lengte maken, bijvoorbeeld 5. Deze acties zouden volledig gelijkwaardig zijn aan de nieuwe int-constructie.

Het is de moeite waard nogmaals te vermelden dat de situatie bij het maken van stringarrays met een objecttype precies dezelfde is als voor eendimensionale arrays (wat ze in feite ook zijn). Er wordt geheugen toegewezen voor verwijzingen naar objecten, maar de objecten zelf worden niet gemaakt.

Laten we nu verder gaan met n-dimensionale arrays. Er is hier niets nieuws. Net zoals een tweedimensionale array een array is met verwijzingen naar eendimensionale arrays, is een driedimensionale array een lijst met verwijzingen, maar dan naar tweedimensionale arrays. De algemene regel is:

Een N-dimensionale array is een eendimensionale array waarvan de elementen verwijzingen zijn naar arrays met dimensie N-1.

Dienovereenkomstig kunnen N-dimensionale arrays worden gemaakt met één expressie, met behulp van de new-operator en door de groottes in alle dimensies te specificeren. Of u kunt het opeenvolgend doen: maak een array, specificeer de dimensie met een of meerdere indexen, en initialiseer de resterende niet-geïnitialiseerde links handmatig, waardoor arrays van de vereiste dimensie worden gemaakt, maar van een willekeurige grootte/vorm. Voor grootdimensionale arrays is dit naar mijn mening echter een nogal moeilijke taak. Eigenlijk net zoals het werken met multidimensionale arrays in het algemeen.

Een paar woorden over het kopiëren van multidimensionale arrays met System.arraycopy. Arrays worden ALLEEN bij de eerste index gekopieerd. Met andere woorden, verwijzingen naar N-1-arrays uit de eerste array zullen worden overgedragen naar de tweede array. In het geval van een tweedimensionale array zijn dit verwijzingen naar stringarrays. Deze omstandigheid vergemakkelijkt het kopiëren van arrays enorm, bijvoorbeeld bij het toevoegen van een nieuwe regel - geheugen hoeft alleen te worden toegewezen voor de array op de eerste index. Vervolgens worden verwijzingen naar alle rijen naar een nieuwe array gekopieerd en wordt de laatste link, die naar een nieuwe rij moet verwijzen, handmatig geïnitialiseerd:

int initArray; // initiële array int newArrayLength = initArray.lengte+1; int nieuweArray = nieuwe int; voor(int ik=0; i nieuwe int[];

Zoals ik al zei, doet System.arraycopy hetzelfde als de bovenstaande lus, alleen sneller.

Misschien is er op dit moment genoeg gezegd over arrays. We zouden over klonen kunnen praten, maar naar mijn mening valt dit onderwerp buiten het bestek van dit artikel. Omdat dit artikel nog steeds voor een groot deel gericht is op beginnende ontwikkelaars.

Bedankt iedereen! Ik hoop dat iemand deze informatie nuttig en interessant vond.

Een array is een verzameling objecten van hetzelfde type die een gemeenschappelijke naam hebben. Elk array-element is toegankelijk via de index. Laten we naar een echt voorbeeld kijken. Laten we een bepaald magazijn hebben, genaamd a, en het een bepaald aantal dozen laten hebben, die allemaal opeenvolgend zijn genummerd. Elke doos bevat een object dat van hetzelfde type is als de objecten in andere dozen. Een voorbeeld van dit magazijn is een klassieke array, waarbij de naam van het magazijn de naam van de array is, de dozen de elementen van de array zijn, de doosnummers de indexen van de elementen zijn en de inhoud van de dozen de waarden van onze variabelen. Laten we ons voorstellen dat er citroenen in de dozen zitten, en elke doos bevat een bepaald aantal citroenen. Vervolgens zullen de waarden van onze variabelen het aantal citroenen weergeven. Laten we eens kijken naar zo'n magazijn dat uit drie dozen bestaat, laat de eerste doos er 3 bevatten, de tweede 7 en de derde 273. Vervolgens kan de array die dit magazijn beschrijft als volgt worden weergegeven:

Index	0	1	2
Betekenis	3	7	273

Het indexeren in een array begint altijd bij 0. Laten we eens kijken naar enkele bewerkingen die met een array kunnen worden uitgevoerd:

Een array maken

TypeVariabeleNaam;
int a;//geheel getalarray
char b;//karakterarray
Tekenreeks c;

Geheugentoewijzing:

A = new int;//geheugen toewijzen voor 10 elementen
b = nieuwe char;//geheugen toewijzen voor 20 elementen
c = nieuwe String;//geheugen toewijzen voor 30 elementen

De array-initialisatie ziet er dus als volgt uit:

Int a = new int;//het initialiseren van een array van gehele getallen met 10 elementen
char b = new char;//initialiseer een karakterarray met 20 elementen
String c = nieuwe String;//het initialiseren van een stringarray van 30 elementen

Aan alle elementen van de array wordt na een dergelijke initialisatie een standaardwaarde toegewezen.
Het is mogelijk om onmiddellijk de waarden van de array-elementen in te stellen; laten we een array maken die het aantal citroenen in de doos laat zien, zoals in het bovenstaande voorbeeld:

Int a = nieuwe int( 3, 7, 273 );

Werken met een array

Een array lezen:

Importeer java.util.Scanner;
openbare klassetest (
public static void main(String args) (
int a;//matrix van gehele getallen
int n;//aantal elementen in de array
Scanner in = nieuwe scanner (System.in);
n = in.nextInt();
a = nieuwe int[n];
for(int i = 0; i Arraywaarden wijzigen:

for(int i = 0; i Array-uitvoer:

Int a;//een array van gehele getallen die op de een of andere manier zijn verwerkt
for(int i = 0; i Willekeurige toegang tot een array-element via index:

System.out.println(a);//Druk het eerste element van de array af
a = 1;//Wijs 1 toe aan het tweede element van de array
int temp = a;//Sla de waarde van het derde element van de array op in de temp-variabele

Zo zien basisbewerkingen met arrays eruit. Heel vaak wordt hen in verschillende computerwetenschappenlessen gevraagd om deze stadia van het werken met een array op te splitsen in afzonderlijke functies, maar we zullen hier later over praten. Door een array te lezen, kunnen we dus enkele waarden vanuit de console invoeren, door waarden te wijzigen kunnen we bijvoorbeeld alle waarden met één verhogen of met twee vermenigvuldigen, en door uitvoer te gebruiken kunnen we de huidige weergeven waarden van de array. Als we alleen met specifieke elementen van een array moeten werken, kunnen we willekeurige toegang via index gebruiken, waarbij index een positief geheel getal is dat kleiner is dan de lengte van de array. De huidige lengte van de array kan worden verkregen met behulp van de eigenschap length; deze is al gebruikt bij het weergeven van de array.
Hier laat ik de dialoog achterwege over het feit dat arrays referenties zijn en dat het werken ermee verschilt van het werken met gewone basistypen.

Tweedimensionale arrays

Het is niet altijd handig om dozen in een magazijn te nummeren van 0 tot een bepaald nummer; soms wil je het magazijn in een overzichtelijker vorm brengen, bijvoorbeeld door rijen te introduceren. Nu heeft elke doos een eigen rijnummer en een eigen serienummer in deze rij. Stel dat er in ons magazijn negen dozen staan ​​met daarin 1, 2, enzovoort, 9 sinaasappels. De dozen in het magazijn zijn opgesteld in drie rijen van drie dozen, waarna de situatie in het magazijn als volgt kan worden voorgesteld.

Array Array Dit is een object dat een vast aantal waarden van hetzelfde type opslaat. Met andere woorden: een array is een genummerde verzameling variabelen. De variabele in de array wordt aangeroepen array-element, en de positie ervan in de array wordt gegeven index. We moeten bijvoorbeeld 50 verschillende namen opslaan; u moet ermee akkoord gaan. Het is lastig om voor elke naam een ​​aparte variabele te maken, dus we zullen een array gebruiken. De nummering van array-elementen begint vanaf 0, en de lengte van de array wordt ingesteld op het moment dat deze wordt gemaakt en staat vast.

Voor de duidelijkheid: de foto waar ik van heb genomen De Java-tutorial.

Om een ​​array te maken, moet u deze declareren, er geheugen voor reserveren en deze initialiseren.

Een array declareren in Java

Wanneer u een array in Java maakt, moet u deze eerst declareren. Dit kan als volgt worden gedaan:

Int myFirstArray;

Je kunt een array ook als volgt declareren:

Int mySecondArray;

Dit is echter geen welkome conventie in Java-code, omdat de haakjes aangeven dat we met een array te maken hebben en logischer zijn als ze naast de typenotatie staan.

Op basis van dit voorbeeld hebben we twee arrays met de namen gedeclareerd mijnEersteArray En mijnSecondArray. Beide arrays bevatten elementen van het type int.

U kunt een array van elk type op deze manier declareren:

Byte anArrayOfBytes; korte anArrayOfShorts; lang anArrayOfLongs; zweven anArrayOfFloats; dubbele anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; Tekenreeks anArrayOfStrings; ...

Het type van een array wordt als volgt gespecificeerd: type, waarbij type het gegevenstype is van de elementen die het bevat. Haakjes zijn een speciaal teken dat de variabelen zich in een array bevinden. De arraynaam kan van alles zijn, maar moet wel overeenkomen met .

Arrays kunnen niet alleen worden gemaakt op basis van variabelen van basistypen, maar ook op basis van willekeurige objecten.

Bij het declareren van een array in Java wordt de grootte ervan niet gespecificeerd en wordt er geen geheugen voor gereserveerd. Het enige dat gebeurt is het creëren van een link naar de array.

Geheugen reserveren voor de array en initialiseren.

Int myFirstArray; mijnEersteArray = nieuwe int;

In ons voorbeeld hebben we een array van 15 elementen van type gemaakt int en toegewezen aan een eerder gedeclareerde variabele mijnEersteArray.

U kunt ook de naam van een array declareren en er geheugen voor reserveren op één regel.

Int myArray = nieuwe int;

Bij het maken van een array met behulp van een trefwoord nieuw, worden alle array-elementen automatisch geïnitialiseerd op nulwaarden. Om de elementen van de array hun initiële waarden toe te wijzen, is het noodzakelijk om dit uit te voeren initialisatie. Initialisatie kan element voor element worden uitgevoerd

MijnEersteArray = 10; // initialiseren van het eerste element myFirstArray = 20; // initialiseren van het tweede element myFirstArray = 30; // enz.

en in een lus, met behulp van een index, door alle elementen van de array heen en er waarden aan toewijzen.

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

Zoals uit de voorgaande voorbeelden blijkt, moet u, om toegang te krijgen tot een array-element, de naam ervan opgeven en vervolgens, tussen vierkante haken, de index van het element. Een array-element met een specifieke index gedraagt ​​zich hetzelfde als een variabele.

Laten we eens kijken naar het maken en initialiseren van een array met behulp van het volgende voorbeeld. Daarin maken we een array met de cijfers 0-9 en drukken we de waarden af ​​naar de console.

//een array maken en initialiseren int numberArray = new int; voor(int i = 0; ik< 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Vereenvoudigd opnameformulier

U kunt ook vereenvoudigde notatie gebruiken om een ​​array te maken en te initialiseren. Het bevat het woord niet nieuw en de beginwaarden van de array staan ​​tussen haakjes.

Int mijnKleur = (255, 255, 0);

Hier wordt de lengte van de array bepaald door het aantal waarden tussen de haakjes en gescheiden door komma's. Deze notatie is geschikter voor het maken van kleine arrays

Arraygrootte bepalen

De grootte van een array is niet altijd duidelijk, dus om dit te achterhalen moet u de eigenschap length gebruiken, die de lengte van de array retourneert.

MijnKleur.lengte;

Deze code helpt ons erachter te komen dat de lengte van de myColor-array 3 is.

Voorbeeld: Gegeven 4 getallen, moet je het minimum vinden

Int-getallen = (-9, 6, 0, -59); int min = getallen; voor(int i = 0; ik< numbers.length; i++){ if(min>getallen[i]) min = getallen[i]; ) Systeem.uit.println(min);

Oefeningen op eendimensionale arrays in Java:

1. Maak een array met de eerste 10 oneven getallen. Druk de elementen van de array op één regel af naar de console, gescheiden door een komma.
2. Gegeven een array met dimensie N, zoek het kleinste element van de array en print dit naar de console (als er meerdere kleinste elementen zijn, druk ze dan allemaal af).
3. Zoek het grootste element in de array uit taak 2.
4. Verwissel de grootste en kleinste elementen van een array. Voorbeeld: gegeven een array (4, -5, 0, 6, 8). Na vervanging ziet het er als volgt uit (4, 8, 0, 6, -5).
5. Zoek het rekenkundig gemiddelde van alle array-elementen.