Arrays. Java-array

Een array is krachtig hulpmiddel, waarmee u kunt werken een groot aantal gegevens. Als je bijvoorbeeld ergens 100 waarden moet opslaan terwijl je code draait, dan is het uiteraard op zijn minst onredelijk om hiervoor hetzelfde aantal variabelen te maken. Met de array kunt u opslaan groot aantal waarden onder dezelfde naam en open ze via de overeenkomstige index. Het concept van arrays is de hoeksteen van het leren van Java voor beginners. Ze vormen immers de basis voor veel datastructuren.

Omdat Java voornamelijk OOP is, heeft het er, vergeleken met arrays in andere programmeertalen, één onderscheidend kenmerk- ze worden weergegeven als objecten. Dit elimineert onder andere de noodzaak om het opschonen van het geheugen te controleren, omdat dit automatisch wordt vrijgegeven.

Eendimensionale arrays maken en manipuleren

Een eendimensionale array is een klassieke array en is een verzameling elementen die aan een algemene naam zijn gekoppeld en die elk overeenkomen met een specifieke index. De methode voor het declareren van een array wordt weergegeven in de onderstaande afbeelding.

Eerst wordt het aangekondigd Java-type array, die het type waarden definieert dat erin is opgeslagen. Het kan van alles zijn wat geldig is. Vervolgens komt de arraynaam en vierkante haakjes die de compiler vertellen dat deze variabele een array is. Let op belangrijk feit. kan achter het basistype van de array of achter de arraynaam worden geplaatst. Na het gelijkteken wordt de nieuwe operator aangegeven, die de toewijzing van geheugen voor de array initieert (hetzelfde als in het geval van objecten), het type elementen dat erin zal worden opgeslagen (moet compatibel zijn met het aangegeven basistype eerder), en ten slotte hun nummer, gespecificeerd in vierkante haakjes.

De nummering van elementen in een Java-array begint vanaf 0. Dus de index van het eerste element in deze array zal gelijk zijn aan 0, en de zesde - 5. Om naar een specifiek element van de array te verwijzen, bijvoorbeeld de vijfde, volstaat het om de naam van de array en de index van het element tussen vierkante haken naast de aan te geven naam. Zo kun je zowel een waarde aan een element toekennen als deze ophalen. U moet echter voorzichtig zijn, want als u een index doorgeeft waarin het element niet bestaat, zal er een fout optreden.

Multidimensionale arrays in Java

Multidimensionale arrays zijn rijen van eendimensionale arrays waarnaar wordt verwezen door elementen van andere arrays. Met andere woorden, de eenvoudigste onder hen zijn tweedimensionaal. Aan de hand van hun voorbeeld zullen we proberen het concept te begrijpen. Voor de duidelijkheid toont de onderstaande afbeelding de syntaxis en het diagram dat de structuur van een tweedimensionale array beschrijft.

Zoals u kunt zien, verschilt de syntaxis niet veel van eendimensionale arrays. Laten we naar de structuur kijken. In de eerste beugels hebben we ruimte gereserveerd voor 5 elementen. Deze elementen zijn niets meer dan verwijzingen naar individuele arrays. Bovendien wordt de grootte van elk van hen bepaald door het getal tussen de tweede haakjes. In feite zijn matrices het analogon van tweedimensionale arrays in de wiskunde. Houd er rekening mee dat naast de elementen ook geheugen wordt toegewezen aparte plaats, waar de waarde van de arraylengte (lengte) wordt opgeslagen. Meestal wordt er mee gewerkt multidimensionale arrays uitgevoerd met behulp van geneste for-lussen.

Onregelmatige arrays

Een tweedimensionale array is een array van arrays. Wij zijn er inmiddels achter gekomen. Maar kunnen de arrays die het bevat verschillende lengtes hebben? Het antwoord is ja, dat kunnen ze. Om dit te doen biedt Java de mogelijkheid om een ​​tweedimensionale array op een speciale manier te declareren. We willen bijvoorbeeld een tweedimensionale array maken waarin drie eendimensionale arrays met respectievelijk lengte 2, 3 en 4 kunnen worden opgeslagen. Het wordt als volgt verklaard:

intarr = nieuweint;

Houd er rekening mee dat we geen nummer tussen de tweede haakjes hebben opgenomen. Het bepalen van de grootte van arrays in arr gaat als volgt:

Door toegang te krijgen tot het element op index 0, dat naar de eerste array verwijst, verklaren we dat het dimensie 2 heeft. Het element op index 1 slaat een array met dimensie 3 op, enzovoort. Het is heel eenvoudig.

Alternatieve Java-array-declaratiesyntaxis

U kunt arrays ook rechtstreeks initialiseren wanneer u ze maakt. Het is vrij eenvoudig.

Let op de declaratie van de arrays jerseyNumber en playerName.

In het geval van tweedimensionale arrays deze aankondiging ziet er zo uit:

Om dit te doen, worden in plaats van de nieuwe operator accolades geopend, waarin alle elementen worden vermeld, gescheiden door komma's. Java wijst er in dit geval automatisch geheugen voor toe en indexeert ze dienovereenkomstig.

Helperklasse-arrays

Om met entiteiten zoals arrays in Java te kunnen werken, heeft het pakket java.util een speciale klasse Arrays die er veel biedt statische methoden, waardoor de operaties met hen enorm worden vergemakkelijkt. De lijst met belangrijkste methoden wordt weergegeven in de onderstaande afbeelding.

Laten we eens kijken naar enkele van de nuttigste Java-arraymethoden:

CopyOf (array, lengte) - retourneert een kopie van de doorgegeven array met de overeenkomstige lengte. Als de doorgegeven lengte groter is dan de originele array, worden alle “extra” elementen gevuld met een standaardwaarde (0 als het een eenvoudig type is, en null als het een referentietype is).

CopyOfRange(array, eerste index, laatste index) - niet weergegeven in de afbeelding, maar een handige methode. Het kopieert het gedeelte van de doorgegeven array, gedefinieerd door de overeenkomstige indices, beginnend met de eerste en eindigend met de laatste.

Sorteren (array) - sorteert array-elementen in oplopende volgorde.

Vullen (array, waarde) - Vult de doorgegeven array met de juiste waarde.

BinarySearch (array, waarde) - retourneert de index waarop het element met de overeenkomstige waarde zich in de doorgegeven gesorteerde array bevindt. Als een dergelijk element niet bestaat, wordt een negatief getal geretourneerd.

Omdat de methoden statisch zijn, hoeft er voor het aanroepen ervan geen exemplaar van de klasse Arrays te worden gemaakt. Ze worden er rechtstreeks vanuit aangeroepen: Arrays.sort(arr).

Conclusie

Wij hebben de meeste beoordeeld belangrijke aspecten met betrekking tot arrays, en voor degenen die net zijn begonnen Java leren voor beginners is dit voldoende voor een basiskennis van zo'n entiteit als een array en de basistechnieken om ermee te werken. Door te oefenen krijg je uiteraard een beter inzicht in het werk van dit instrument. Neem dus de tijd om een ​​paar oefeningen te doen waarbij je arrays op verschillende manieren manipuleert.

Helper klasse Array-Java Het wordt al gebruikt in "gevechtsomstandigheden", dus het wordt aanbevolen om eerst te leren hoe u alle basisbewerkingen met arrays handmatig kunt uitvoeren.

IN Java-taal er zijn arrays. Deze arrays zijn getypt. Verklaring

Richt mijnPunten;

beschrijft de variabele myPoints als een array van objecten van het type Point. U kunt een array van een bepaalde grootte maken met behulp van instructies zoals

mijnPunten = nieuw punt;

De waarden van de array-elementen worden gelijkgesteld aan de speciale waarde null.

De grootte van de array kan worden verkregen tijdens de uitvoering van het programma:

howMany = mijnPunten.lengte;

Om een ​​array te maken, kunt u vierkante haakjes rechts van de arraynaam of het type objecten waaruit de array bestaat gebruiken, bijvoorbeeld:

int nAnotherNumbers;

Beide opties zijn geldig, dus u kunt degene kiezen die u het beste bevalt.

Bij het definiëren van arrays in Java kunt u hun grootte niet opgeven. De bovenstaande twee regels veroorzaken geen geheugenreservering voor de array. Hier worden eenvoudigweg verwijzingen naar arrays gemaakt, die zonder initialisatie niet kunnen worden gebruikt.

Om geheugen voor een array te bestellen, moet u de juiste objecten maken met behulp van trefwoord nieuw, bijvoorbeeld:

int nAnotherNumbers;

nAnotherNumbers = nieuwe int;

Hoe tabelcellen initialiseren?

Deze initialisatie kan statisch of dynamisch worden uitgevoerd. In het eerste geval vermeld je eenvoudigweg de waarden in krullende beugels zoals hieronder weergegeven:

int nKleurRood = (255, 255, 100, 0, 10);

Dynamische initialisatie gebeurt met behulp van de array-index, bijvoorbeeld in een lus:

int nInitiëleWaarde = 7;

int nAnotherNumbers;

nAnotherNumbers = nieuwe int;

voor(int i = 0; ik< 15; i++)

Het is niet alleen mogelijk om arrays van variabelen te maken basistypen, maar ook van willekeurige objecten. Elk element van zo'n array moet worden geïnitialiseerd met de nieuwe operator.

Arrays kunnen multidimensionaal en, interessant genoeg, asymmetrisch zijn.

Hieronder wordt een array met arrays gemaakt. Er wordt een array van vier getallen gemaakt in het nul- en eerste element, en een array van acht in het tweede:

int nDim = nieuwe int;

nDim = nieuwe int;

nDim = nieuwe int;

nDim = nieuwe int;

Tijdens de uitvoering van de applicatie controleert de Java Virtual Machine op detectie van array-out-of-bounds. Als de toepassing de grenzen van de array probeert te overschrijden, treedt er een uitzondering op.

Arrays in Java zijn objecten van een ingebouwde klasse. Voor deze klasse is het mogelijk om de grootte van de array te bepalen door toegang te krijgen tot het klassegegevenslid met de naam lengte, bijvoorbeeld:

int nAnotherNumbers;

nAnotherNumbers = nieuwe int;

voor(int i = 0; ik< nAnotherNumbers.length; i++)

nAnotherNumbers[i] = nInitiëleWaarde;

Om de grootte van een array te bepalen, heb je geen operator zoals sizeof uit de programmeertaal C nodig, omdat er een andere manier is om de grootte te bepalen.

Anderen structurele typen Er zijn geen (niet-object) objecten in de Java-taal, dat wil zeggen, er zijn geen structuren, vakbonden, enz. Er zijn ook geen verwijzingen in Java.

Tekenreeksen zijn objecten van het type String (tekstconstanten) of StringBuffer (veranderlijke tekenreeksen). Voorbeeld:

String hallo = "Hallo wereld!";

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. Er wordt een array gemaakt met dezelfde nieuwe operator:

// array van gehele getallen maken met 5 elementen: int array = nieuwe int;

In tegenstelling tot andere talen heeft Java er echter een paar leuke kleine dingen. Ten eerste kan de grootte van de array expliciet worden opgevraagd via de eigenschap .length:

Deze eigenschap is definitief, dus zet deze door nieuwe maat een array zal helaas niet werken.

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 signatuur van deze methode is:

Het kopiëren vindt plaats vanaf 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 de 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 een link is de standaardwaarde null!

Deze fout is bijna een klassieke fout. Heel vaak kom je vragen tegen “waar komt 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 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:

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:

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 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. Hier ziet u bijvoorbeeld hoe u een array declareert die uit gehele getallen bestaat: int a;< 100 ; i++ ) a[ i] = i; 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. int a = nieuwe int [ 100 ] ;< a. length; i++ , System. out. println (a[ i] ) ) ; После создания массива изменить его размер невозможно (хотя можно, конечно, изменять отдельные его элементы). Если в ходе выполнения программы необходимо часто изменять размер массива, лучше использовать другую структуру данных, называемую списком массивов (array list). Массив можно объявить двумя способами: int a; или int a ; Большинство программистов на языке Java предпочитают первый стиль, поскольку в нем четче отделяется тип массива int (целочисленный массив) от имени переменной.

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.

Java heeft de mogelijkheid om tegelijkertijd een array te maken en deze te initialiseren. Hier is een voorbeeld van zo'n syntactische constructie: int smallPriemgetallen = (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: 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);

is een verkorte versie van de uitdrukking int anoniem = (17, 19, 23, 29, 31, 37); kleinePrimes = 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.< luckyNumbers. length; i++ ) System. out. println (i + ": " + luckyNumbers[ i] ) ; Выполнение этих операторов приводит к следующему результату. 0 : 1001 1 : 1002 2 : 1003 3 : 5 4 : 7 5 : 11 6 : 13 int luckyNumbers = kleinePriemgetallen; 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 operator int a = new int [100]; //Java equivalent aan operator int * = new int [100];