Inleiding tot 3D-arrays in Java
Voordat we 3D-arrays in Java begrijpen, moeten we weten wat de array is en waarom wordt deze in programmeertalen gebruikt? Arrays zijn in feite een groep van hetzelfde type waarden waarnaar wordt verwezen met dezelfde naam. Met hetzelfde type bedoelen we de waarden van hetzelfde gegevenstype. Overweeg een situatie waarin we de namen van alle studenten van een klas willen opslaan. Omdat de naam van de student van het gegevenstype String is, maar het onjuist zou zijn om de naam van elke student in een andere variabele op te slaan, omdat deze niet alleen veel ruimte in beslag zou nemen, maar ook verwarring in een programma zou veroorzaken door bijna hetzelfde te vergroten regels code. Dus voor dit soort situaties worden arrays gebruikt. De programmeur kan een reeks Student_names maken en de grootte ervan opgeven op het moment dat het arrayobject wordt gemaakt. Op deze manier is het niet nodig om de variabelenaam voor elke studentnaam op te geven en wanneer we de waarden willen bijwerken, invoegen en ophalen, kunnen indices van deze array worden gebruikt.
In Java wordt een arrayvariabele vergelijkbaar verklaard met de andere variabelen met het teken () na het gegevenstype ervan. De arraygrootte moet worden gedefinieerd op het moment dat de array wordt gemaakt en deze blijft constant. Matrixelementen worden benaderd door de numerieke indexen, waarbij het eerste element wordt opgeslagen op 0 indexen. Er zijn in principe twee soorten arrays in Java, namelijk eendimensionale en multidimensionale arrays. 3D-arrays vallen onder de categorie multidimensionale arrays. Multidimensionale arrays in eenvoudige woorden kunnen worden gedefinieerd als een array van arrays en 3D-arrays zijn een array van 2D-arrays. 3D is een complexe vorm van multidimensionale arrays. Overweeg een scenario van appartementen in een gebouw. Stel dat er 10 verdiepingen in het appartement zijn en elke verdieping 5 flats heeft en elke flat 3 kamers heeft. Om deze gegevens tijdens het programmeren te verwerken, worden 3D-arrays gebruikt.
Hoe 3D-arrays zijn gedefinieerd in Java?
Java gebruikt een zeer eenvoudige manier om de arrays te definiëren. Vierkante haken ('()') worden gebruikt om het array-object na het gegevenstype van de array te definiëren. Men moet de grootte definiëren ten tijde van de aangifte van de array. 3D-arrays worden gedefinieerd met drie haakjes. Hieronder wordt de syntaxis gegeven van het definiëren van de 3D-arrays in Java:
Data_type array_name( ) ( ) ( ) = new array_name(a)(b)(c);
- Hier data_type: gegevenstype van elementen die in de array worden opgeslagen. matrixnaam: naam van de matrix
- nieuw: trefwoord om een object in Java te maken
- a, b, c: bevat de numerieke waarden voor de verschillende dimensies.
Syntaxis:
int ( ) ( ) ( ) arr = new int (10)(4)(3);
In het bovenstaande voorbeeld kunnen er maximaal 10x4x3 = 120 elementen worden opgeslagen door de array 'arr'.
Hoe 3D-arrays te maken en waarden in Java in te voegen?
3D-arrays maken in Java is net zo eenvoudig als het maken van 1D- en 2D-arrays. Zoals hierboven vermeld, is het belangrijk om de grootte van een array te definiëren op het moment van aangifte. Het maken van 3D-arrays omvat nog een stap waarbij waarden worden doorgegeven / ingevoerd in de vorm van een reeks 2D-arrays. We kunnen de grootte van een array definiëren en achteraf de waarden invoegen / invoeren of we kunnen de waarden direct in een array doorgeven. Dus de manier van waarde gedefinieerd in 3D-arrays wordt hieronder gegeven:
Syntaxis
data_type()()() arr_name =
(
(
(Array1Row1Col1, Array1Row1Col2, ….),
(Array1Row2Col1, Array1Row2Col2, ….)
),
(
(Array2Row1Col1, Array2Row1Col2, ….),
(Array2Row2Col1, Array2Row2Col2, ….)
)
)
Code
int num_array ( ) ( ) ( ) = (
(
(10, 20, 99),
(30, 40, 88)
),
(
(50, 60, 77),
(80, 70, 66)
),
);
Arrays bevinden zich in een array en daarom wordt het een array van 2D-arrays genoemd. In het bovenstaande voorbeeld, als we het duidelijk zien, zijn er twee 2D-reeksen getallen en deze 2D.
Hoe initialiseer ik elementen van 3D-arrays in Java?
Zoals hierboven vermeld, is het initialiseren van de hele array in één keer een best practice bij het werken met 3D-arrays omdat het de kans op verwarring bij toekomstige programmering vermindert. Hoewel we ook één waarde per keer in een array kunnen toewijzen, wat op de onderstaande manier kan worden gedaan:
Syntaxis:
int employee_arr( ) ( ) ( ) = new int (10)(3)(3);
employee_arr(0)(0)(0) = 100; // it will assign value 100 at very first element of employee_arr employee_arr(0)(0)(1) = 200; // it will assign value 200 at second element of employee_arr employee_arr(0)(0)(2) = 300; // it will assign value 100 at third element of employee_arr
De bovenstaande benadering is vermoeiend en wordt niet als een goede benadering beschouwd, omdat deze veel ruimte in beslag neemt en de coderegels vergroot. Er is ook een benadering waarbij de lussen worden gebruikt die als een goede praktijk worden beschouwd bij het werken met 3D-arrays.
Syntaxis:
int Student_arr ( ) ( ) ( ) = new arr (2) (3) (4); int x, y, z, value;
for(x = 0; x< 2; x++) (
for(y = 0; y< 3; y++) (
for(z = 0; z< 4; z++) (
Student_arr(x)(y)(z) = value; value= value*2;
)
)
)
In het bovenstaande voorbeeld worden alle arrayelementen ingevoegd met behulp van de lussen waarbij x = no. van tabellen, y = totaal aantal rijen en z geeft het totale aantal kolommen aan in een 3D-array met de naam Student_arr.
Hoe toegang te krijgen tot elementen van 3D-arrays in Java?
In Java hebben we echter toegang tot het afzonderlijke element van de array met behulp van de indices, aangezien we ze hebben geïnitialiseerd door indexen die lijken op die hieronder:
Syntaxis:
int arr ( ) ( ) ( ) = new arr (3) (3) (3);
// Accessing the array elements of 3D arrays in Java using indices
Syntaxis:
System.out.println(“The first element of array is” + arr(0)(0)(0));
In de bovenstaande syntaxis haalt het element op bij (0) (0) (0) index van de array 'arr', maar normaal als we alle elementen van een array willen ophalen, wordt deze aanpak niet gevolgd en worden elementen toegankelijk via lussen omdat alle elementen tegelijk worden opgehaald. Terwijl toegang wordt verkregen tot elementen via lussen, worden 3 lussen gebruikt waarin de eerste lus het totale aantal tabellen definieert en de tweede lus de rijen definieert en de derde lus de kolommen definieert zoals hieronder aangegeven:
Code:
class Student(
public static void main(String() args) (
// student_arr is the name of 3d array int()()() student_arr= (
(
(10, 20, 30),
(20, 30, 40)
),
(
(40, 50, 60),
(10, 70, 80),
)
);
// for loop to iterate through each element of 3D array for (tables = 0; tables<2; tables++)
(
for (rows= 0; rows <2; rows++)
(
for (columns= 0; columns<3; columns++)
(
System.out.print("student_arr(" +tables+ ")(" +rows+ ")(" +columns+ ") = "
+student_arr(tables)(rows)(columns)+ "\t");
)
System.out.println();
)
System.out.println();
)
)
Output:
| student_arr (0) (0) (0) = 10 | student_arr (0) (0) (1) = 20 | student_arr (0) (0) (2) = 30 |
| student_arr (0) (1) (0) = 20 | student_arr (0) (1) (1) = 30 | student_arr (0) (1) (2) = 40 |
| student_arr (1) (0) (0) = 40 | student_arr (1) (0) (1) = 50 | student_arr (1) (0) (2) = 60 |
| student_arr (1) (1) (0) = 10 | student_arr (1) (1) (1) = 70 | student_arr (1) (1) (2) = 80 |
Hoe elementen van 3D-arrays in Java te verwijderen?
- Het verwijderen van elementen in 3D-arrays in Java is eenvoudig en vergelijkbaar met degene die ze initialiseert. De klasse Array biedt geen directe methode om een element aan de arrays toe te voegen of te verwijderen. Omdat de grootte van de array niet dynamisch kan worden vergroot of verkleind, wordt eenvoudige programmeerlogica toegepast om deze taak uit te voeren. We kunnen eenvoudigweg 3 lussen gebruiken om de hele array te doorlopen door de index op te geven waarop we het element willen verwijderen. We kunnen een nieuwe array maken of de originele array kopiëren en het element verlaten dat moet worden verwijderd.
- Door dit proces van het verwijderen en bijwerken van elementen in de 3D-array wordt zelden gebruikt. In plaats daarvan wordt ArrayList in dit soort gevallen gebruikt omdat het verschillende functies biedt om er rechtstreeks elementen uit te verwijderen. In ArrayList wordt de methode 'remove ()' gebruikt om elementen in de opgegeven index in een ArrayList te verwijderen. Als we herhalende waarden in een array hebben en we willen de eerste keer voorkomen in de array die we kunnen gebruiken, de methode ArrayUtils.removeElement (array, element) voor dezelfde waarvoor 2 argumenten nodig zijn, dat wil zeggen de hele array en het element dat moet ervan worden verwijderd.
Hoe elementen bij te werken
Er is dus geen methode om elementen in een 3D-array bij te werken. Sommige programmeerlogica wordt toegepast om de elementen te wijzigen, zoals het verwijderen van de elementen door de hele array te doorlopen met behulp van 3 lussen en de wijziging uit te voeren op de specifieke index of in de hele array. Voor zo'n complexe taak heeft deze verwerking niet de voorkeur via 3D-arrays en gedaan door het gebruik van de collectie, ArrayList. In ArrayList wordt set (int index, E-element) gebruikt om het element dynamisch in een array te wijzigen of bij te werken. Er zijn 2 argumenten nodig, namelijk de index en het element met de gewijzigde en bijgewerkte waarde.
Conclusie
Zoals we hierboven vermeldden, hoe te werken aan 3D-arrays in Java. Het werken met multidimensionale arrays in Java is enigszins moeilijk voor de nieuwe programmeurs omdat het verschillende loops omvat, maar het begrijpen via de stapsgewijze procedure en het in gedachten houden van de basisregels tijdens het werken met arrays kan het veel gemakkelijker maken om eraan te werken.
Aanbevolen artikelen
Dit is een gids voor 3D-arrays in Java. Hier bespreken we hoe arrays te maken, hoe een waarde in te voegen, hoe toegang te krijgen tot, te verwijderen en bij te werken. U kunt ook onze andere gerelateerde artikelen doornemen voor meer informatie-
- 3D-arrays in C
- 3D-arrays in Python
- Arrays in R
- Voordelen van Array
- Multidimensionale array in Python
- Arrays in PHP
- Hoe arrays en lijsten werken in Python?
- Multidimensionale arrays in C ++ met voorbeelden