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 Arrayname.length om het aantal elementen in een array te tellen. Bijvoorbeeld voor (int i = 0 ; i. 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); is een verkorte versie van de uitdrukking int anoniem = (17, 19, 23, 29, 31, 37); kleinePrimes = 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 = kleinePriemgetallen;<
luckyNumbers.
length;
i++
)
System.
out.
println
(i +
": "
+
luckyNumbers[
i]
)
;
Выполнение этих операторов приводит к следующему результату.
0
:
1001
1
:
1002
2
:
1003
3
:
5
4
:
7
5
:
11
6
:
13
geluksgetallen[ 5 ] = 12 ;//Nu is het element smallPriemgetallen ook 12 Het resultaat wordt getoond in Fig. 3.1. Als u alle elementen van de ene array naar de andere wilt kopiëren, moet u de arraycopy-methode uit de klasse System gebruiken. De oproep ziet er als volgt uit: System. arraycopy (van, vanlndex, naar, tolndex, aantal); De to-array moet groot genoeg zijn om alle te kopiëren elementen te bevatten. Afb.3.1. Een array kopiëren De hieronder getoonde operatoren, waarvan de resultaten worden getoond in Fig. 3.2, 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 kleinePriemgetallen = (2, 3, 5, 7, 11, 13);
int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
Systeem. apparator(kleine priemgetallen, 2, geluksgetallen, 3, 4);
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 0 tot 99 ligt) door een array van 100 elementen te maken, wordt het programma beëindigd omdat er een uitzondering voor de array-index buiten het bereik optreedt.
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 Java-programmeurs geven de voorkeur aan de eerste stijl omdat deze het int-arraytype 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 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 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 met een grootte van nul maken. 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 is echter praktisch hetzelfde als een verwijzing naar een dynamische array. 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 Java controleert de standaardoperator 'geen' het bereik van indexen. Bovendien beschikt Java niet over pointer-berekeningen: u kunt een pointer niet verhogen om toegang te krijgen tot het volgende element van een array.
Ik besloot dit artikel te schrijven naar aanleiding van een discussie op het forum. Het zal zich richten op arrays in Java. Eerlijk gezegd kan ik me geen enkel boek herinneren waarin dit onderwerp duidelijk en duidelijk werd behandeld. Ondertussen zijn arrays in Java heel anders dan arrays in welke andere taal dan ook die ik ooit heb gezien. En kennis van deze verschillen is zeer, zeer noodzakelijk.
Het artikel is verdeeld in drie delen:
Een kleine opmerking vanaf het begin. Een array, ongeacht het type en de afmeting ervan, is een object. Dit betekent dat het alle eigenschappen en methoden van het object heeft.
We zullen dus beginnen met de eenvoudigste gevallen, namelijk -
Eendimensionale arrays van primitieve typen
Deze arrays verschillen praktisch niet van wat programmeurs die andere talen gebruiken, gewend zijn. De array wordt op dezelfde manier gemaakt exploitant nieuw:
// array van gehele getallen maken met 5 elementen: int array = nieuwe int;
In tegenstelling tot andere talen heeft Java echter een paar leuke kleine dingen. Ten eerste kan de grootte van de array expliciet worden opgevraagd via de eigenschap .length:
int array = nieuwe int; System.out.println("Arraygrootte: "+array.lengte); // zal afdrukken: Arraygrootte: 5Deze eigenschap is definitief, dus u kunt er helaas geen nieuwe arraygrootte mee instellen.
Het tweede kleine ding is controle over het overschrijden van de arraygrenzen. Dit wordt gedaan door de interpreter; de index gaat verder dan de array, er wordt een java.lang.ArrayIndexOutOfBoundsException gegenereerd. Het is niet nodig om het te onderscheppen, en ik zou zelfs zeggen dat het onwenselijk is, omdat Dit is een RuntimeException en geeft aan dat het programma niet correct werkt. En je moet zeker geen applicatie ontwerpen met de verwachting dat na het doorlopen van de hele array deze uitzondering zal optreden, en dit zal een signaal zijn om de verwerkingscyclus te beëindigen. Dit is een heel slecht idee.
Eenmaal gemaakt, wordt de array geïnitialiseerd met een standaardwaarde voor het type elementen. Dit wordt gegarandeerd door de taalspecificatie.
Er is één subtiliteit. Wanneer gemaakt, kan de grootte van de array worden ingesteld op 0. Dit wordt een volwaardige array met 0 elementen. De eigenschap .length is 0. Deze constructie kan soms behoorlijk nuttig zijn.
Een paar woorden over kopiëren. De triviale manier is om een array van dezelfde grootte te maken en de inhoud in een lus over te dragen. Goed, betrouwbaar, maar niet erg snel. Er is een snellere manier: gebruik de System.arraycopy(...) methode. Bij deze methode wordt na alle controles het geheugengebied eenvoudigweg gekopieerd. De handtekening van deze methode is:
publieke statische leegte arraycopy(Objectbron, int srcPos, Objectbestemming, int bestePos, int lengte)Het kopiëren vindt plaats van de src-array, beginnend op positie srcPos, naar de dest-array, beginnend op positie destPos. Er worden in totaal lengte-elementen gekopieerd. Merk op dat src en dest van het type Object zijn. Dit wordt gedaan zodat deze methode arrays van elk type kan verwerken. Als src of dest geen array is, wordt een java.lang.ArrayStoreException gegenereerd.
Eigenlijk over arrays primitieve soorten er valt niets meer te zeggen. Daarom gaan we soepel verder naar het volgende gedeelte:
Eendimensionale reeksen objecten
B O Het meeste van wat er over arrays van primitieve typen wordt gezegd, geldt ook voor arrays van objecten. Hun grootte kan worden verkregen via .length en overschrijdingen worden gecontroleerd. Ze worden gemaakt met de nieuwe operator:
// array van java.awt.Point met 10 elementen: java.awt.Point points = nieuw java.awt.Point;
Merk op dat er hier GEEN constructoraanroep is. java.awt.Point na de new operator geeft alleen het type elementen aan van de array die wordt gemaakt.
Na het maken wordt de array op dezelfde manier geïnitialiseerd met een standaardwaarde... En hier schuilt een grote valkuil. Een korte vraag. Wat is deze standaardwaarde? Een object gemaakt door een parameterloze constructor aan te roepen? Wat als zo’n constructeur niet bestaat? Het antwoord ligt in het antwoord op een andere vraag: wat wordt er precies in deze array opgeslagen?
Maar het zijn geen objecten die in deze array worden opgeslagen. Links ernaartoe worden daar opgeslagen. Zoals elke variabele objecttype is een verwijzing naar een object, en elk array-element is ook een verwijzing. En voor de link is de standaardwaarde null!
Deze fout is bijna een klassieke fout. Heel vaak kom je vragen tegen “waar komt de NullPointerException vandaan” met betrekking tot code, zoals de volgende:
Java.awt.Point punten = nieuw java.awt.Point; punten.x = 1; //<-- here is a NullPointerException
Nu denk ik dat het duidelijk is waar deze fout vandaan komt. De array wordt gemaakt en de elementen ervan worden geïnitialiseerd op null. De objecten zelf worden echter niet gemaakt. De situatie is precies hetzelfde als bij het gebruik van een variabele met de waarde null. Het juiste fragment ziet er als volgt uit:
Java.awt.Point punten = nieuw java.awt.Point; voor(int ik=0; i
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 4Houd 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; iZoals 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 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 wanneer de array wordt gemaakt en kan later niet worden gewijzigd. Dat wil zeggen dat u geen elementen uit de array kunt verwijderen of daar kunt toevoegen, maar dat u 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 minder 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 A een array van elementen van het type int kan verder worden geassocieerd, en met namen ar1 En ar2 verder kunnen arrays van reële getallen (type double) worden verbonden. Tot nu toe hebben we geen arrays gemaakt, maar alleen namen ervoor voorbereid.
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 te declareren 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;
Deze eigenschap kan niet worden gewijzigd (dat wil zeggen: er kan niets aan worden toegewezen), hij kan alleen worden gelezen. Met deze eigenschap kunt u programmacode schrijven om een array te verwerken zonder zelfs maar de specifieke grootte ervan te kennen.<= 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] + " "); }
Dit is bijvoorbeeld hoe u de elementen van elke array met de naam ar2 kunt weergeven:
Deze eigenschap kan niet worden gewijzigd (dat wil zeggen: er kan niets aan worden toegewezen), hij kan alleen worden gelezen. Met deze eigenschap kunt u programmacode schrijven om een array te verwerken zonder zelfs maar de specifieke grootte ervan te kennen.< ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.
For(int i = 0; ik
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:
Om arrays te verwerken 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).
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 5 willekeurige gehele getallen uit elk een segment, geef de arrays op het scherm weer op twee afzonderlijke regels. 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 20 beste 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 (dat wil zeggen dat de optie niet geschikt is als de array voortdurend eerst zes positieve en vervolgens zes negatieve getallen bevat, of als 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 is het proces waarbij de elementen van een array opnieuw worden gerangschikt, wanneer alle elementen in oplopende of aflopende volgorde zijn gerangschikt. U kunt niet alleen numerieke arrays sorteren, maar bijvoorbeeld ook stringarrays (volgens hetzelfde principe als waarop boeken worden gerangschikt). bibliotheekplanken). Over het algemeen kunt u de elementen van elke set sorteren waarin de volgorderelatie is opgegeven. Er zijn universele algoritmen die sorteren uitvoeren, ongeacht de oorspronkelijke status van de array. Maar daarnaast zijn er speciale algoritmen die bijvoorbeeld heel snel een bijna geordende array kunnen sorteren, maar niet goed overweg kunnen met een sterk gemengde array (of helemaal niet overweg kunnen). Er zijn speciale algoritmen nodig waar snelheid belangrijk is en een specifiek probleem wordt opgelost; de gedetailleerde studie ervan valt buiten het bestek van onze cursus.Sorteren op selectie
Laten we een voorbeeld bekijken van sorteren in oplopende volgorde. Dat wil zeggen dat de beginpositie in de array het minimale element moet hebben, de volgende een groter of gelijk element moet hebben, enz., en de laatste positie het grootste element moet hebben is als volgt. We zoeken in alles naar het minimale element en ruilen dit met het oorspronkelijke element. Vervolgens zoeken we in het resterende deel van de array (dat wil zeggen tussen alle elementen behalve het eerste element) opnieuw naar het minimumelement en wisselen dit met het tweede element in de array. En zo verder.Illustratie:
Voor (int i = 0; ik
Bellensoort
De essentie van het algoritme is dit. Als we door een array gaan en de juiste volgorde in elk paar aangrenzende elementen vaststellen, zal het gewenste element daarna gegarandeerd op de laatste plaats van de array staan (het grootste voor sorteren in oplopende volgorde of het kleinste voor sorteren in aflopende volgorde). Als je de array opnieuw doorloopt met dezelfde transformaties, staat het gewenste element gegarandeerd op de voorlaatste plaats. En zo verder.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 vernauwt 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).
Multidimensionale arrays
*/ 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; ) )
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 bibliotheekkaart 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).
Om toegang te krijgen tot een element van een n-dimensionale array, moet u dus n indices opgeven.
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 Maak een tweedimensionale array van 8 rijen van elk 5 kolommen met willekeurige gehele getallen uit het segment. Geef de array op het scherm weer. Maak een tweedimensionale array van 5 rijen met elk 8 kolommen met willekeurige gehele getallen uit het segment [-99;99]. Geef de array op het scherm weer. Maak een tweedimensionale array van 7 rijen met elk 4 kolommen met willekeurige gehele getallen uit het segment [-5;5]. Geef de array op het scherm weer. Bepaal en toon de index van de rij met het grootste absolute product van elementen. Als er meerdere van dergelijke regels zijn, druk dan de index af van de eerste die u tegenkomt. Maak een tweedimensionale array van 6 rijen van 7 kolommen, elk met willekeurige gehele getallen uit het segment. Geef de array op het scherm weer. Transformeer de array zodat het grootste element in elke rij eerst komt. In dit geval kan de samenstelling van de array niet worden gewijzigd, maar kunnen alleen de elementen binnen één regel worden herschikt. De volgorde van de overige elementen van de rij is niet belangrijk (dat wil zeggen dat u slechts één permutatie kunt maken, of dat u elke rij in aflopende volgorde kunt sorteren). Geef de geconverteerde array op het scherm weer. Om de resterende kennis van de leerlingen na de zomervakantie te testen, besloot de leerkracht van de basisschool om elke les te beginnen met het vragen van een voorbeeld aan elke leerling van de tafel van vermenigvuldiging, maar er zitten 15 mensen in de klas en de voorbeelden onder hen mogen niet herhaald worden. . Om de leraar te helpen, schrijft u een programma dat 15 willekeurige voorbeelden uit de tafel van vermenigvuldiging weergeeft (van 2*2 tot 9*9, omdat vermenigvuldigingstaken met 1 en 10 te eenvoudig zijn). Bovendien mogen er onder de 15 voorbeelden geen herhalingen voorkomen (voorbeelden 2*3 en 3*2 en vergelijkbare paren moeten als herhalend worden beschouwd). 2010, Alexey Nikolajevitsj Kostin. Afdeling TIDM, Faculteit Wiskunde, Pedagogische Staatsuniversiteit van Moskou. 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 Het eerste array-element heeft een index van nul (0), en het laatste heeft een lengte van 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. Telkens wanneer een array-element wordt benaderd door de index, controleert de Java-runtime of de indexwaarde binnen aanvaardbare grenzen ligt en genereert een uitzondering van het type ArraylndexOutOfBoundsException als het controleresultaat onwaar is. 6 De indexexpressie moet van het type int zijn - dit is het enige dat het maximale aantal array-elementen beperkt. 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: Geef de geconverteerde array op het scherm weer. De eerstgenoemde syntaxis verdient echter de voorkeur omdat deze de typedeclaratie compacter maakt. Modifiers in arraydeclaraties 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 niet kan worden gewijzigd nadat deze is gemaakt, maar verbiedt dit op geen enkele manier de mogelijkheid om de inhoud van individuele elementen van de array te wijzigen. 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, waarbij de noodzaak wordt vermeden om extra nieuwe operators te gebruiken. De expressie voor het declareren en maken van de mat-array hierboven 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, zal de attrs-variabele een verwijzing hebben naar een array van 12 variabelen die zijn geïnitialiseerd op nul. De Attr-objecten zelf zullen pas worden 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 declaratie en initialisatie van een array 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 door 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)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:
