Hoe een tweedimensionale array in Java te declareren Java-array

Multidimensionale arrays in Java

Beschouw bijvoorbeeld een tweedimensionale array in Java.

Tweedimensionale Java-arrays zijn een rechthoekige of niet-rechthoekige tabel met getallen.

Een tweedimensionale Java-array bestaat uit rijen en kolommen.

De eerste index van een tweedimensionale Java-array is het aantal rijen.

Voorbeeld van een Java 2D-rechthoekige array:

Int multiArr; multiArr = nieuwe int; /* * multiArr-structuur * | (0,0) | (0,1) |

* | (1,0) | (1,1) |

*/

Hier wordt een tweedimensionale array met twee rijen en twee kolommen gedeclareerd en gedefinieerd.

Laten we de array met elementen laden:

MultyArr = 1; multiArr = 2; multiArr = 3; multiArr = 4;< 2; inn++) { for(int jnn = 0; jnn < 2; jnn++) { System.out.println("multyArr[" + inn + "][" + jnn + "] = " + multyArr ); } }

Uitvoer van een tweedimensionale array (we herhalen de array):

Systeem.out.println("multyArr"); for(int herberg = 0; herberg< 2; inn++)

Wij krijgen:

for(int herberg = 0; herberg< 2; jnn++)

we gaan door de rijen, en in een cyclus

for(int jnn = 0; jnn

door kolommen.

U kunt tegelijkertijd een multidimensionale array declareren en definiëren:

int multiArr = ((1,2), (3,4));

Lengte van een multidimensionale array in Java

Int multiArr = ((1,2), (3,4), (5,6)); /* * multiArr-structuur * | 1 | 2 |

* | 3 | 4 |

* | 5 | 6 |

*/ System.out.println("Arraylengte = " + multiArr.lengte);
Arraylengte = 3

Er zijn drie rijen van elk twee elementen. De eerste dimensie is drie, dit is de lengte van een tweedimensionale array.

Driedimensionale array in Java

int triArray;

triArray = nieuwe int; Hier wordt een driedimensionale array gedeclareerd en gedefinieerd. Het kan worden weergegeven als een kubus bestaande uit twee lagen (laag), elke laag bestaat uit twee rijen en twee kolommen, d.w.z. elke laag is een tweedimensionale array. Hoe vul je een 3D-array? Het is mogelijk in een lus, maar voor het voorbeeld vullen we handmatig in: //******************** //DE EERSTE LAAG //******************** //de eerste rij van de eerste laag triArray = 1; triArray = 2; //de tweede rij van de eerste laag triArray = 3; triArray = 4; //******************** //DE TWEEDE LAAG //******************** //de eerste rij van de tweede laag triArray = 5; triArray = 6; //de tweede rij van de tweede laag triArray = 7; triArray = 8; Hoe kan ik een driedimensionale array weergeven? Of hoe je een 3D-array kunt herhalen? Dus. Array. We moeten bijvoorbeeld 50 verschillende namen opslaan. U zult het ermee eens zijn dat het lastig is om voor elke naam een ​​aparte variabele te maken, dus zullen we 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.

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.

Merk op dat het in dit geval niet nodig is om de nieuwe operator te gebruiken. Bovendien kunt u zelfs een naamloze array initialiseren: new int (16, 19, 23, 29, 31, 37) Deze expressie wijst geheugen toe voor een nieuwe array en vult deze met de getallen die tussen accolades zijn opgegeven. 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 smallPriemgetallen = new int (17, 19, 23, 29, 31, 37);

//C++, niet int a[ 100 ] ;

//C++ In de Java-taal controleert de standaardoperator 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.

Link naar eerste

Een array is een eindige reeks geordende elementen van hetzelfde type, waarbij elk element toegankelijk is via zijn index.

De grootte of lengte van een array is het totale aantal elementen in de array. De grootte van de array wordt ingesteld bij het aanmaken van de array en kan later niet meer worden gewijzigd. Dat wil zeggen dat u geen elementen uit de array kunt verwijderen of daar kunt toevoegen, maar wel nieuwe waarden kunt toewijzen aan bestaande elementen.

De index van het startelement is 0, het volgende is 1, enz. De index van het laatste element in de array is één kleiner dan de grootte van de array. In Java zijn arrays objecten. Dit betekent dat de naam die aan elke array wordt gegeven, alleen het adres van een bepaald stukje gegevens in het geheugen aangeeft. Er wordt niets in deze variabele opgeslagen, behalve het adres. De array-index geeft in feite aan hoeveel u van het startelement van de array in het geheugen moet afwijken om bij het gewenste element te komen. Om een ​​array te maken, moet u er een geschikte naam voor opgeven en vervolgens het gewenste geheugenfragment aan deze naam koppelen, waar de waarden van de array-elementen één voor één worden opgeslagen. De volgende opties voor het declareren van een array zijn mogelijk: typenaam; typenaam; Waar type

is het type array-elementen, en

Naam - een unieke (niet bezet door andere variabelen of objecten in dit deel van het programma) identificatie die begint met een letter. Voorbeelden: int a; dubbele ar1; dubbele ar2; In het voorbeeld hebben we namen opgegeven voor drie arrays. Met voornaam En A een array van elementen van het type int kan verder worden geassocieerd, en met namen

Nu kunt u als volgt arrays maken (of, zoals ze zeggen, initialiseren): a = new int; // array van 10 elementen van het type int int n = 5; ar1 = nieuw dubbel[n]; // Array van 5 elementen dubbel ar2 = (3,14, 2,71, 0, -2,5, 99,123); // Een array van 6 elementen van het type double Dat wil zeggen dat we bij het maken van een array de grootte ervan kunnen specificeren, of onmiddellijk alle gewenste elementen kunnen opsommen, gescheiden door komma's tussen accolades (in dit geval wordt de grootte automatisch berekend op basis van de volgorde van de elementen die wordt gespecificeerd). Houd er rekening mee dat er in dit geval een puntkomma achter de sluitende accolade wordt geplaatst, wat niet gebeurt als de accolade een blok sluit.

Als de array is gemaakt met behulp van de operator nieuw, dan krijgt elk van zijn elementen een standaardwaarde. Wat het zal zijn, wordt bepaald op basis van het gegevenstype (0 voor int, 0,0 voor double, enz.).

Het was mogelijk om een ​​naam voor een array op te geven en de array zelf op één regel te maken met behulp van het volgende schema: typenaam = nieuw type[grootte]; typenaam = (el0, el1, ..., elN);

Voorbeelden: int mas1 = (10,20,30); int mas2 = nieuwe int;

Om toegang te krijgen tot een van de elementen van de array en de waarde ervan te lezen of te wijzigen, moet u de naam van de array opgeven, gevolgd door de index van het element tussen vierkante haakjes. Een array-element met een specifieke index gedraagt ​​zich hetzelfde als een variabele. Om bijvoorbeeld het laatste element van de mas1-array weer te geven, moeten we in het programma schrijven:

System.out.println("Laatste array-element " + mas1);

En zo kunnen we in de mas2-array dezelfde reeks waarden plaatsen die zijn opgeslagen in mas1:

Mas2 = 10; mas2 = 20; mas2 = 30;Uit dit voorbeeld blijkt al dat we, om toegang te krijgen tot alle elementen van de array, hetzelfde type acties moeten herhalen. Zoals u zich herinnert, worden lussen gebruikt om bewerkingen vele malen te herhalen. Dienovereenkomstig zouden we de array kunnen vullen met de benodigde elementen met behulp van een lus: for(int i=0; iHet is duidelijk dat als we een array hadden die niet uit 3, maar uit 100 elementen bestond, we dit eenvoudigweg niet hadden kunnen doen zonder lus.

De lengte van elke gemaakte array hoeft niet te worden onthouden, omdat er een eigenschap is die deze opslaat. U krijgt toegang tot deze eigenschap door .length aan de arraynaam toe te voegen. Bijvoorbeeld:

Int razmer = mas1.lengte;

For(int i = 0; ik<= 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] + " "); }

Houd er rekening mee dat we bij elke stap van de lus eerst een willekeurige waarde naar het array-element met de i-de index hebben gestuurd en vervolgens hetzelfde element op het scherm hebben weergegeven. Maar de twee processen (vullen en terugtrekken) zouden in verschillende cycli kunnen worden uitgevoerd. Bijvoorbeeld:

For(int i = 0; ik< ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.

Voor het verwerken van arrays worden altijd lussen van het type “n times” (for) gebruikt, omdat we van tevoren weten hoe vaak de lus zich moet herhalen (hetzelfde aantal keren als er elementen in de array zitten).

Taken

Maak een array van alle even getallen van 2 tot en met 20 en geef de elementen van de array eerst op een regel weer, waarbij u het ene element van het andere scheidt met een spatie, en vervolgens in een kolom (waarbij u het ene element van het andere scheidt door een nieuwe regel te beginnen). Voordat u een array maakt, moet u bedenken hoe groot deze zal zijn.

2 4 6 … 18 20
2
4
6
…
20

Maak een array van alle oneven getallen van 1 tot 99, geef deze als een lijn op het scherm weer en geef vervolgens dezelfde array als een lijn op het scherm weer, maar in omgekeerde volgorde (99 97 95 93 ... 7 5 3 1 ).

Maak een array van 15 willekeurige gehele getallen uit het segment. Geef de array op het scherm weer. Tel hoeveel even elementen er in de array zitten en geef dit aantal op een aparte regel op het scherm weer.

Maak een array van 8 willekeurige gehele getallen uit het segment. Druk de array als een string naar het scherm af. Vervang elk element door een oneven index met nul. Geef de array opnieuw op een aparte regel weer.

Maak 2 arrays van elk 5 willekeurige gehele getallen uit het segment en geef de arrays op twee afzonderlijke regels weer op het scherm. Bereken het rekenkundig gemiddelde van de elementen van elke array en rapporteer voor welke van de arrays deze waarde groter was (of rapporteer dat hun rekenkundige gemiddelden gelijk zijn).

Maak een array van 4 willekeurige gehele getallen uit het segment en druk deze als een string op het scherm af. Bepaal en geef een bericht weer dat aangeeft of de array een strikt stijgende reeks is.

Maak een array van de top 20 Fibonacci-getallen en geef deze weer op het scherm. We herinneren je eraan dat de eerste en tweede term van de reeks gelijk zijn aan één, en dat elke volgende de som is van de voorgaande twee.

Maak een array van 12 willekeurige gehele getallen uit het segment [-15;15]. Bepaal welk element het maximum is in deze array en rapporteer de index van het laatste exemplaar ervan in de array.

Maak twee arrays van 10 willekeurige gehele getallen uit het segment en een derde array van 10 reële getallen. Elk element met de i-de index van de derde array moet gelijk zijn aan de verhouding van het element uit de eerste array met de i-de index tot het element uit de tweede array met de i-de index. Druk alle drie de arrays af op het scherm (elk op een aparte regel) en druk vervolgens het aantal gehele elementen in de derde array af.

Maak een array van 11 willekeurige gehele getallen uit het segment [-1;1], geef de array weer als een lijn. Bepaal welk element het vaakst voorkomt in de array en geef hierover een bericht weer op het scherm. Als twee elementen hetzelfde aantal keren voorkomen, voer dan niets uit.

De gebruiker moet een even positief getal opgeven via het toetsenbord, en het programma moet een array van de opgegeven grootte maken uit willekeurige gehele getallen van [-5;5] en deze als een lijn op het scherm weergeven. Hierna moet het programma de som van de modules waarvan de helft van de array groter is: links of rechts, bepalen en de gebruiker informeren over de som van de modules, of informeren dat deze sommen van de modules gelijk zijn. Als de gebruiker een verkeerd nummer invoert, moet het programma herhaalde invoer vereisen totdat de juiste waarde is opgegeven.

Het programma moet een array van 12 willekeurige gehele getallen uit het segment [-10;10] maken, zodat er gelijke aantallen negatieve en positieve elementen zijn en geen nullen. In dit geval moet de volgorde van de elementen willekeurig zijn (d.w.z. de optie is niet geschikt wanneer de array voortdurend eerst zes positieve en vervolgens zes negatieve getallen bevat, of wanneer de elementen voortdurend elkaar afwisselen door één, enz.). Geef de resulterende array op het scherm weer.

De gebruiker voert via het toetsenbord een natuurlijk getal groter dan 3 in, dat wordt opgeslagen in de variabele n. Als de gebruiker een verkeerd nummer heeft ingevoerd, moet het programma de gebruiker vragen de invoer te herhalen. Maak een array van n willekeurige gehele getallen uit een segment en geef deze weer op het scherm. Maak een tweede array, indien aanwezig, van de even elementen van de eerste array, en geef deze weer op het scherm.

Sorteer een array

Sorteren op selectie

Illustratie:

Voor (int i = 0; ik

Bellensoort

2 9 1 4 3 5 2 → de volgorde is correct, er vindt geen herschikking plaats

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

Code: /* De buitenste lus verkleint voortdurend het fragment van de array * dat in aanmerking wordt genomen, omdat na elke doorgang * van de binnenste lus het gewenste element * op de laatste plaats van het fragment zal staan ​​(het hoeft niet opnieuw worden overwogen).

*/ for (int i = a.length - 1; i >= 2; i--) ( /* In de gesorteerde variabele slaan we een teken op dat aangeeft of de array * is gesorteerd. Vóór elke doorgang van de interne * lus we gaan ervan uit dat het gesorteerd is, maar als we * minstens één permutatie maken, dan is het nog niet volledig gesorteerd * Deze techniek, die het sorteren vereenvoudigt, wordt het Iverson-criterium genoemd */ boolean sorted = true /* In the binnenste lus, we doorlopen het arrayfragment, dat * wordt bepaald door de buitenste lus. In dit fragment stellen we * de juiste volgorde in tussen aangrenzende elementen, dus in paren * verwerken we het hele fragment */ for (int j = 0. ; j a) ( int temp = a[j]; a[j] = a; a = temp. ; gesorteerd = false; ) ) /* Als de array gesorteerd is (d.w.z. er waren geen permutaties * in de binnenste lus, dan je kunt de buitenste * lus stoppen. */ if(gesorteerd) ( break; ) )

Multidimensionale arrays

Een array kan niet alleen bestaan ​​uit elementen van een bepaald ingebouwd type (int, double, enz.), maar ook, onder andere, uit objecten van een bestaande klasse en zelfs uit andere arrays.

Een array die andere arrays als elementen bevat, wordt een multidimensionale array genoemd. Meestal worden tweedimensionale arrays gebruikt. Dergelijke arrays kunnen eenvoudig worden weergegeven als een matrix. Elke rij daarvan is een gewone eendimensionale array, en de vereniging van alle rijen is een tweedimensionale array, in elk element waarvan een link naar een bepaalde rij van de matrix is ​​opgeslagen. Een driedimensionale array kan zijn voorgesteld als een reeks matrices, die we elk op een bibliotheekpas hebben opgeschreven. Om vervolgens bij een specifiek nummer te komen, moet u eerst het kaartnummer (de eerste index van de driedimensionale array) opgeven, dus het regelnummer (de tweede array-index) en pas daarna het nummer van het element. in de regel (de derde index).

Arrays worden als volgt gedeclareerd: int d1; //Gewoon, eendimensionaal int d2; //Tweedimensionale dubbele d3; //Driedimensionaal int d5; //Vijfdimensionaal Bij het maken van een array kunt u expliciet de grootte van elk niveau opgeven: d2 = int; // Matrix van 3 rijen en 4 kolommen Maar u kunt alleen de grootte van het eerste niveau opgeven: int dd2 = int; /* Matrix van 5 rijen. Het is nog niet bekend hoeveel elementen er in elke lijn zullen zitten. */ In het laatste geval kunt u een tweedimensionale array maken, die geen matrix zal zijn vanwege het feit dat elke rij een ander aantal elementen zal hebben. Bijvoorbeeld: for(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}};

In dit geval heeft u toegang tot het element met index 4 in de tweede rij ddd2, maar als we toegang krijgen tot het element ddd2 of ddd2- er zal een fout optreden, omdat dergelijke elementen eenvoudigweg niet bestaan. Bovendien zal deze fout optreden tijdens de uitvoering van het programma (dat wil zeggen dat de compiler deze niet zal zien).

Meestal worden tweedimensionale arrays met een gelijk aantal elementen in elke rij gebruikt. Om tweedimensionale arrays te verwerken, worden twee geneste lussen met verschillende tellers gebruikt. Voorbeeld (we vullen een tweedimensionale array met willekeurige getallen van 0 tot 9 en geef het weer op het scherm in de vorm van een matrix): int da = nieuwe int; for(int i=0; ik

Taken