Inleiding tot arrays in Java-programmering
- In het gedeelte van vandaag gaan we kijken naar Arrays in Java Programming. U zult arrays leren kennen. Hoe te werken met arrays? Ook, hoe de array te declareren, maken en initialiseren? Arrays zijn geschikt voor een vaste lengte. We zullen enkele voor- en nadelen van arrays zien. We gaan ook kijken hoe we het programma kunnen schrijven en toegang kunnen krijgen tot de array-elementen. Wanneer array wordt genest met multidimensionering, wordt het vervelend om te begrijpen. Als je een duidelijke visie hebt over wat er precies gaat gebeuren, dan is het heel eenvoudig om met array te werken.
- Java is een programmeertaal. Java volgt het OOP-concept. We kunnen zeggen dat Java een pure objectgerichte taal is. In de wereld van vandaag bevindt Java zich op de positie waar elke IT-sector op directe en indirecte manieren aan verwant is. Java heeft vele gegevenstypen. Sommigen van hen zijn primitief en sommige zijn niet-primitief. Arrays is een krachtig en nuttig concept dat wordt gebruikt bij het programmeren. Java geeft ons datastructuur, de array, waarin een homogene elementen van hetzelfde type met een opeenvolgende verzameling van vaste grootte kunnen worden opgeslagen.
- Een array wordt gebruikt om een verzameling gegevens op te slaan, maar het is ook nuttiger om een array te beschouwen als een verzameling variabelen van hetzelfde type. De klasse java.util.Arrays heeft enkele methoden. Deze methoden kunnen op de array worden toegepast om de index van de array en de lengte van de arrays te krijgen. We kunnen ook twee arrays vergelijken om te controleren of beide gegeven arrays hetzelfde zijn of niet. Stel dat we waarden in een array moeten krijgen om een specifieke waarde bij elke index te plaatsen. Bij elke index moeten we enkele waarden plaatsen.
- Voor het sorteren van arrays in oplopende volgorde hebben we enkele methoden om toe te passen. Dit kan via de sorteermethode. Er zijn ook parallelle sorteermethoden in Java. Het sorteren van parallelle en grote arrays op multiprocessorsystemen is sneller dan sequentiële array. Een van de gegevenstypes is Array. Stel dat we één scenario hebben waarin u veel gegevens van hetzelfde type moet opslaan. Array is een statische gegevensstructuur die meerdere waarden kan bevatten. Net als andere variabelen in Java, kunnen we ook arrays in methoden doorgeven.
Code:
class Demo
(
public static void main(String args())
(
int a() = (3, 1, 2, 5, 4);
sum(a);
)
public static void sum(int() a)
(
// getting sum of array values
int total = 0;
for (int i = 0; i < a.length; i++)
total+=a(i);
System.out.println("sum of array values : " + total);
)
)
Output:
Hoe Array in Java te verklaren?
Array is niets anders dan een verzameling gegevens. Array is een verzameling homogene gegevenstypen. We kunnen ook zeggen dat array een gegevensstructuur is voor het opslaan van vergelijkbare gegevenswaarden. Dit slaat een vergelijkbaar type gegevens op in één variabele. Stel dat we studenten in een klas hebben. Elke student heeft een ID.
Stel dat er 100 studenten zijn. Kijk hieronder zullen we variabele voor elk verklaren.
Int student1 = 1;
Int student2 = 2;
Int student3 = 3;
Int student4 = 4;
.
.
.
Int student5 = 5;
Huh … het is nog steeds goed. Maar wat als je 1000 studenten hebt. Het is erg vervelend en tijdrovend om 1000 keer variabele aan te geven.
Dus wat is dan de oplossing? Ja, en het antwoord is Array. Laten we kijken hoe we de array kunnen verklaren.
In Array kunnen we waarden in een enkele variabele plaatsen.
Ex: int student () = new int (1000);
We zullen zien dat het duidelijk in het volgende diagram staat:
Leerling() 
Hier kunnen we in één variabele geen waarden opslaan die we willen. Variabel is niets anders dan de verwijzing naar de geheugenlocatie.
Als u het zorgvuldig hebt bekeken, hebben we de array met het nieuwe trefwoord verklaard. Over het algemeen gebruiken we een nieuw trefwoord om objecten te maken. Dat betekent dat in Java-arrays objecten zijn.
Hé, wacht even? Voorwerp. Dat betekent dat er al een klasse moet zijn om het object te maken. Ja, we hebben er een superklasse voor en dat is objectklasse. Array breidt altijd het klasseobject uit. Arrays bezetten altijd hoopgeheugen. Niet alleen Array-objecten, maar alle objecten in Java worden opgeslagen in het heap-geheugen. We hebben dus maar één verwijzing naar alle waarden. Hierdoor hebben we geheugen efficiënt gebruikt. Array is een veelvoorkomend onderwerp in bijna alle talen. Als we het kernconcept van de array eenmaal begrijpen, kunnen we dit gemakkelijk aanpakken.
Hoe arrays te initialiseren in Java-programmering?
Nu rijst de volgende vraag: hoe kunnen we de array initialiseren. Wat betekent deze term? Initialisatie is niets anders dan het toewijzen van waarde aan de variabele.
Er zijn meerdere manieren om arrays in Java te initialiseren.
De eerste manier is zoals getoond in het bovenstaande voorbeeld bij het declareren van de array.
Ex: int student () = new int (1000);
Het volgende is dat we de array kunnen initialiseren en als volgt kunnen verklaren:
Ex: int student () = (1, 2, 3, 4, 5, 6, … .1000);
Tijdens het werken met de array kunnen we de uitzondering krijgen. Als u hebt geleerd over foutafhandeling in Java, moet u de uitzondering kennen. Uitzondering is niets anders dan de fout die tijdens runtime bekend is, wordt efficiënt afgehandeld. Voor array hebben we Array Index out of bounds uitzondering.
Hoe toegang krijgen tot matrixelementen?
Tot nu toe hebben we geleerd hoe de array te declareren en te initialiseren. Nu is het tijd om vooruit te gaan. Laten we aannemen dat u een array hebt zoals hierboven, dat wil zeggen een student-array.
Nu willen we bijzondere waarde voor toegang voor het programmeren. Hoe de waarde van een bepaald element in de array te krijgen.
In Array hebben we het concept van indexnr.
Kijk bijvoorbeeld naar het onderstaande diagram.
Index nr begint met nul (0).
Typen array in Java (leg elk type uit met voorbeelden)
Laten we eerst enkele basisconcepten begrijpen voordat we in een reeks arrays komen.
De elementen in de array die door new zijn toegewezen, worden automatisch geïnitialiseerd door nul (voor numerieke typen), false (voor boolean) of null (voor referentietypes). Er zijn standaard matrixwaarden in Java Het verkrijgen van een matrix is een proces in twee stappen. U moet een variabele van het arraytype opgeven. En dan moet u het geheugen toewijzen voor datgene dat de array zal bevatten, met behulp van een nieuw sleutelwoord, en het zal het toewijzen aan de arrayvariabele. We kunnen dus zeggen dat in Java alle arrays dynamisch worden toegewezen.
Er zijn twee soorten arrays:
1. Eén dimensionale array
Eén dimensionaal bestaat uit 1D array. Het kan een enkele rij of een enkele kolom hebben.
We kunnen een eendimensionale array declareren zoals hieronder:
Int () a; OF Int a (); OF Int () a; OF Int () a;
Maar de meest geprefereerde manier is int () a; Vergeet niet dat we hier niet de grootte van de array aangeven. Vb: int (5) a; is niet geldig in Java. Op het moment van aangifte geven we niet de grootte van een array.
Nu zullen we kijken naar de verklaring en de aanmaak van de array:
Int () a; // Verklaring van de array
Let op: op het moment van aangifte bewijzen we niet de grootte van de array.
a = new int (5) // Creatie van array
Ten tijde van het maken van een array is het erg belangrijk om de grootte van een array te bepalen.
We kunnen een array op een enkele regel declareren en maken, zoals hieronder:
Int () a = nieuwe int (3);
Laten we nu eens kijken hoe we de array kunnen initialiseren. Stel dat u enkele waarden in een array moet toevoegen. Vervolgens voegt u het toe aan een bepaalde indexnr. zoals hieronder:
a (0) = 1; // We voegen 1 op 0 positie in array toe.
a (1) = 2;
a (2) = 3;
Nu hebt u gezien hoe u de array kunt initialiseren. Maar wat als ik de index no gaf die niet bestaat in de array.
Vb: a (10) = 11; // stel dat we alleen een reeks van 5 hadden
Op dit moment gooit het een ArrayIndexLoutOf BoundException. U kunt geen waarden toevoegen die groter zijn dan een array.
Nu kunnen we de array op één regel declareren, maken en initialiseren zoals hieronder:
Int () a = (1, 2, 3, 4, 5); // Verklaar, creëer, initialiseer
Of een andere methode is als volgt
Int () a = new int () (1, 2, 3, 4, 5);
Laten we nu eens kijken hoe we elementen uit een eendimensionale array kunnen ophalen:
Hoe waarden van array afdrukken?
We zullen hier voor lus gebruiken:
Voorbeeld:
public class Demo2(
public static void main (String args())(
int() a = new int() (1, 2, 3, 4, 5);
for(int i=0; i<=a.length-1;i++)
(
System.out.println(a(i));
)
)
)
Output:
In het bovenstaande voorbeeld kunnen we de matrixwaarden herhalen.
2. Multidimensionale array
De multidimensionale array bestaat uit 2D- en 3D-arrays. Het heeft meerdere rijen en meerdere kolommen. We noemden het ook een Array of Arrays. We kunnen het ook gekartelde arrays noemen. Laten we nu eens kijken naar de matrixdeclaratie. Ik bedoel 2D-array-aangifte. Hierboven hebben we gezien hoe we een eendimensionale array kunnen declareren. Nu ga je de 2D-array zien. Hetzelfde als we een eendimensionale array lezen met behulp van de lengtevariabele binnen een for-lus, kunnen we een 2-dimensionale array lezen met behulp van de lengtevariabele binnen twee for-loops. Stel dat de lengtevariabele van een eendimensionale array het totale aantal waarden geeft dat door een eendimensionale array kan worden vastgehouden. De lengtevariabele van een tweedimensionale array geeft het totale aantal arrays dat door een tweedimensionale array kan worden vastgehouden.
Multidimensionale array kan die array van arrays zeggen.
Int () () a; // hier hebben we array a verklaard
Nu hetzelfde als hierboven wat we deden met een eendimensionale array. Na het declareren van de array moeten we een array maken. Bekijk het onderstaande voorbeeld.
a = nieuwe int (2) (4);
Hierna gaan we een array initialiseren.
We zullen dit met het onderstaande diagram duidelijker begrijpen.
Met het bovenstaande diagram kunnen we de array-elementen eenvoudig initialiseren.
a (0) (0) = 10
a (0) (1) = 20
a (0) (2) = 30 <
a (0) (3) = 40
Kijk naar het volgende diagram boven waarden die binnen een bepaalde positie komen. We kunnen de array eenvoudig initialiseren met rij en kolom.
Nu kunnen alle processen zoals declaratie, creatie en initialisatie worden uitgevoerd in een enkele regel zoals hieronder. Bekijk de onderstaande syntaxis zorgvuldig. Eerst zien we aangifte en creatie op één regel:
int () () a = nieuw int (2) (3);
Nu zullen we alle drie de processen zien declareren, maken en initialiseren van de array.
int () () a = ((10, 20, 30), (100.20000));
Bekijk het volgende programma om preciezer te zijn:
Code:
public class MyArray (
public static void main(String() args)
(
int()() a = ((10, 20, 30), (100, 200, 300));
System.out.print(a(1)(2));
)
)
Output:
Probeer de kleine programma's in de array. Manipuleer de waarden. Door handen vuil te maken tijdens het programmeren van de meeste kleine dingen die je zult begrijpen.
Voor- en nadelen van arrays in Java-programmering
Hieronder bespreken we de voor- en nadelen.
voordelen
- Array kan meerdere waarden opslaan in één variabele.
- Arrays zijn snel in vergelijking met primitieve gegevenstypen.
- We kunnen objecten in een array opslaan.
- Leden van de array worden opgeslagen in opeenvolgende geheugenlocaties.
nadelen
- Array heeft een vaste grootte
- We kunnen de array tijdens runtime niet vergroten of verkleinen.
- In array kan geheugenverspilling meer zijn.
- We kunnen alleen items van hetzelfde gegevenstype opslaan
- Hoewel het toevoegen of verwijderen van items in het midden van de array de prestaties van de array beïnvloedt.
Arrays in Java zijn de gegevensstructuren die worden gebruikt om elementen van het homogene gegevenstype op te slaan. Het voordeel van arrays is dat de elementen in de array toegankelijk zijn via het indexnummer. Dit maakt ons gemakkelijk om sorteer-, ophaal-, zoek- en andere voorkeursbewerkingen op die elementen in arrays aanzienlijk snel uit te voeren. De array is zo'n klein concept en kan in een korte vastgestelde tijd worden gebruikt. Wanneer we ons op dat moment voorbereiden op het examen of een interview, zorg er dan voor dat u alle hierboven besproken concepten hebt gezien en geïmplementeerd.
Conclusie - Arrays in Java Programming
Arrays zijn een kernconcept in Java. Als je in elke programmeertaal een expert bent in het omgaan met arrays en tekenreeksen, is dit de beste prestatie ooit. Arrays zijn heel gemakkelijk te leren. Ik moet alleen enkele kernconcepten onthouden. Als je het eenmaal hebt geleerd, zul je de array-implementatie nooit vergeten.
Aanbevolen artikelen
Dit is een gids voor voor Arrays in Java Programming. Hier bespreken we de introductie, voordelen en nadelen van arrays in Java-programmering, voorbeeldcodes en uitvoer. U kunt ook onze andere voorgestelde artikelen doornemen -
- Multidimensionale array in C
- String Array in C #
- 3D-arrays in Java
- Arrays in C #
- Verschillende soorten loops met zijn voordelen
- 2D-afbeeldingen in Java
- Sorteerfunctie in Python met voorbeelden
- Lussen in VBScript met voorbeelden
- Multidimensionale array in PHP
- Gooien versus Gooien | Top 5 verschillen die u moet weten