Bevezetés a Java tömbökbe
Mielőtt megértjük a 3D tömböket a Java-ban, tudnunk kell, mi a tömb, és miért használják azt a programozási nyelveken? A tömbök alapvetően hasonló típusú értékek egy csoportja, amelyet ugyanazon a néven utalnak. Hasonló típus esetén ugyanazon adattípus értékeit értjük. Vegyünk egy olyan helyzetet, amelyben meg akarjuk tárolni az osztály összes tanulójának nevét. Mivel a Hallgató neve karakterlánc típusú, de helytelen lenne az egyes hallgatók nevét különféle változóban tárolni, mivel az nem csak sok helyet foglalna el, hanem zavart okozna a programban is, mivel majdnem ugyanazt növeli kódsorok. Tehát az ilyen típusú helyzetek kezelésére tömböket használnak. A programozó létrehozhat egy Student_names tömböt, és meghatározhatja annak méretét a tömbobjektum létrehozásakor. Ilyen módon nincs szükség a változó nevének megadására minden egyes hallgató névhez, és amikor az értékeket frissíteni, beszúrni és lekérdezni akarjuk, ennek a tömbnek az indexei használhatók.
A Java-ban egy tömbváltozót hasonlónak nyilvánítanak a többi változóval, () jellel az adattípus után. A tömb méretét a tömb létrehozásakor kell meghatározni, és állandó marad. A tömb elemekhez a numerikus indexek férnek hozzá, az első elemmel 0 indexen tárolva. Alapvetően kétféle tömb van a Java-ban, azaz az egydimenziós és a többdimenziós tömbök. A 3D-s tömbök a többdimenziós tömbök kategóriájába tartoznak. A többdimenziós tömbök egyszerű szavakkal meghatározhatók tömbök tömbjeként, a 3D tömbök pedig 2D tömbök tömbjeként. A 3D a többdimenziós tömbök komplex formája. Fontolja meg az apartmanok forgatókönyvét. Tegyük fel, hogy a lakásban 10 emelet található, és minden emeleten 5 lakás van, és minden lakásban 3 szoba van. Ezeknek az adatoknak a programozásban történő kezeléséhez 3D tömböket használnak.
Hogyan definiálhatók a 3D-tömbök a Java-ban?
A Java nagyon egyszerű módon határozza meg a tömböket. Szögletes zárójelek ('()') a tömb objektumának a tömb adattípus utáni meghatározására szolgálnak. Meg kell határozni a méretet a tömb deklarálásakor. A 3D tömbök három zárójelben vannak meghatározva. Az alábbiakban bemutatjuk a Java tömbök meghatározásának szintaxisát:
Data_type array_name( ) ( ) ( ) = new array_name(a)(b)(c);
- Itt data_type: a tömbben tárolt elemek adattípusa. tömb_neve: a tömb neve
- új: kulcsszó az objektum létrehozásához a Java-ban
- a, b, c: a különböző méretek numerikus értékeit tartalmazza.
Szintaxis:
int ( ) ( ) ( ) arr = new int (10)(4)(3);
A fenti példában legfeljebb 10x4x3 = 120 elem tárolható az 'arr' tömb segítségével.
Hogyan hozhatunk létre 3D-tömböket, és hogyan építhetünk be azokat értékeket a Java-ba?
A 3D tömbök létrehozása Java-ban ugyanolyan egyszerű, mint az 1D és 2D tömbök létrehozása. Mint fentebb említettük, fontos a tömb méretét a deklaráció időpontjában meghatározni. A 3D-s tömbök létrehozása magában foglalja az értékek továbbadásának / bevitelének egy további lépését 2D-tömbök tömbje formájában. Meghatározhatjuk a tömb méretét és az értékeket utána beilleszthetjük / beírhatjuk, vagy közvetlenül átadhatjuk az értékeket egy tömbben. Tehát a 3D tömbökben meghatározott érték módját az alábbiakban adjuk meg:
Szintaxis
data_type()()() arr_name =
(
(
(Array1Row1Col1, Array1Row1Col2, ….),
(Array1Row2Col1, Array1Row2Col2, ….)
),
(
(Array2Row1Col1, Array2Row1Col2, ….),
(Array2Row2Col1, Array2Row2Col2, ….)
)
)
Kód
int num_array ( ) ( ) ( ) = (
(
(10, 20, 99),
(30, 40, 88)
),
(
(50, 60, 77),
(80, 70, 66)
),
);
A tömbök tömb belsejében vannak, ezért 2D tömb tömbnek hívják. A fenti példában, ha ezt egyértelműen látjuk, két 2D tömb van, és ez a 2D.
Hogyan inicializálhatjuk a 3D-s tömbök elemeit a Java-ban?
Mint fentebb említettem, a teljes tömb egyszerû inicializálása a 3D-s tömbökkel végzett munka legjobb gyakorlata, mivel ez csökkenti a késõbbi programozás zavarainak esélyét. Bár egy tömbben egyszerre egy értéket is hozzárendelhetünk, amelyet az alábbiak szerint lehet megtenni:
Szintaxis:
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
A fenti megközelítés fárasztó és nem tekinthető jó megközelítésnek, mivel sok helyet foglal el, és növeli a kódvonalakat. Van egy megközelítés a hurkok használatával, amelyeket jó gyakorlatnak tekintnek a 3D tömbökkel való munka során.
Szintaxis:
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;
)
)
)
A fenti példában az összes tömb elemet hurkok segítségével illesztjük be, ahol x = nem. táblázatok száma, y = a sorok teljes száma és z jelöli a Student_arr nevű 3D-s tömb oszlopok számát.
Hogyan érhető el a 3D tömb elemei a Java-ban?
A Java-ban azonban a tömb egyetlen eleméhez az indexek segítségével férhetünk hozzá, mivel az alábbiakhoz hasonló indexekkel inicializáltuk őket:
Szintaxis:
int arr ( ) ( ) ( ) = new arr (3) (3) (3);
// Accessing the array elements of 3D arrays in Java using indices
Szintaxis:
System.out.println(“The first element of array is” + arr(0)(0)(0));
A fenti szintaxisban az elemet az "arr" tömb (0) (0) (0) indexében fogja lekérdezni, de általában, ha egy tömb összes elemét szeretnénk letölteni, akkor ezt a megközelítést nem követjük, és az elemek hurkokon keresztül érhető el, mivel az összes elemet egyszerre keresi. Miközben az elemek hurokon keresztül érhetők el, 3 hurkot használnak, amelyekben az első hurok határozza meg a táblák teljes számát, a második hurok pedig a sorokat, a harmadik hurok pedig az oszlopokat az alábbiak szerint:
Kód:
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();
)
)
Kimenet:
| 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 |
Hogyan lehet eltávolítani a 3D tömb elemeit a Java-ból?
- Az elemek eltávolítása a 3D tömbökből Java-ban egyszerű és hasonló az inicializáláshoz. A tömb osztály nem nyújt közvetlen módszert egy elem hozzáadásához vagy törléséhez a tömbökből. Mivel a tömb méretét nem lehet dinamikusan növelni vagy csökkenteni, ezért ennek a feladatnak az egyszerű programozási logikáját alkalmazzuk. Egyszerűen 3 hurok segítségével haladhatunk át a teljes tömbön azáltal, hogy megadjuk azt az indexet, amelytől el akarjuk távolítani az elemet. Készíthetünk új tömböt, vagy lemásolhatjuk az eredeti tömböt, és elhagyhatjuk az eltávolítandó elemet.
- Ezen a folyamaton keresztül a 3D tömb elemeinek eltávolítását és frissítését ritkán használják. Ehelyett az ArrayList ilyen típusú esetekben használatos, mivel különféle funkciókat biztosít az elemek közvetlen eltávolításához. Az ArrayList alkalmazásban az „remove ()” metódus az elemeket eltávolítja az ArrayList megadott indexén. Ha ismétlődő értékek vannak egy tömbben, és el akarjuk távolítani az első előfordulást a tömbben, amelyet használhatunk, az ArrayUtils.removeElement (tömb, elem) módszer ugyanahhoz, amely 2 argumentumot vesz igénybe, azaz a teljes tömb és az elem, amelyet távolítsa el tőle.
Az elemek frissítése
Mint ilyen, nincs módszer a 3D tömb elemeinek frissítésére. Néhány programozási logikát alkalmaznak az elemek módosítására, például az elemek eltávolítására a teljes tömb áthaladásával 3 hurok használatával, és a módosítást az adott indexen vagy a teljes tömbön hajtják végre. Egy ilyen összetett feladat esetén ezt a feldolgozást nem részesítik előnyben a 3D-s tömbökön keresztül, és a gyűjtemény, az ArrayList használatával hajtják végre. Az ArrayList halmazban (int index, E elem) egy elem tömb dinamikus módosítására vagy frissítésére szolgál. Két érvre van szükség, azaz az indexre és az elemre a módosított és frissített értékkel.
Következtetés
Mint fentebb említettük, hogyan kell dolgozni a 3D-s tömbökön Java-ban. A Java-ban a többdimenziós tömbökkel való munka meglehetősen nehéz az új programozók számára, mivel különféle hurkokat igényel, de a lépésről lépésre történő megértés és a tömbökkel végzett munka során az alapszabályok szem előtt tartása sokkal könnyebbé teszi a rajta történő munkát.
Ajánlott cikkek
Ez egy útmutató a 3D tömbökhez Java-ban. Itt tárgyaljuk, hogyan lehet tömböket létrehozni, hogyan lehet értéket beszúrni, hogyan lehet elérni, eltávolítani és frissíteni. Megnézheti más kapcsolódó cikkeinket, hogy többet megtudjon-
- 3D tömbök C-ben
- 3D tömbök a Python-ban
- Tömbök R-ben
- A tömb előnyei
- Többdimenziós tömb Pythonban
- Tömbök a PHP-ben
- Hogyan működnek a tömbök és a listák a Pythonban?
- Többdimenziós tömbök C ++-ban példákkal