Bevezetés a tömbökbe a Java programozásban
- A mai részben a tömböket vizsgáljuk meg a Java programozásban. Meg fogja tudni a tömböket. Hogyan kell dolgozni az Arrays-szal? Ezenkívül, Hogyan lehet deklarálni, létrehozni és inicializálni a tömböt? A tömbök rögzített hosszúságúak. Látni fogjuk a tömbök néhány előnyeit és hátrányait. Megvizsgáljuk azt is, hogyan lehet írni a programot és elérni a tömb elemeit. Amikor a tömb beágyazódik a multi-dimenzióba, unalmas lesz megérteni. Ha világos elképzelése van arról, hogy mi fog pontosan történni, akkor nagyon könnyű a tömb segítségével dolgozni.
- A Java egy programozási nyelv. A Java követi az OOP koncepcióját. Azt mondhatjuk, hogy a java tiszta tárgy-orientált nyelv. A mai világban a Java olyan helyzetben van, ahol minden IT-ágazat közvetlen és közvetett módon kapcsolódik hozzá. A Java-nak számos adattípusa van. Néhányuk primitív, mások nem primitívek. Az Arrays egy hatékony és hasznos koncepció, amelyet a programozásban használnak. A Java adatszerkezetet, a tömböt ad nekünk, amely rögzített méretű, azonos típusú homogén elemeket képes tárolni.
- Egy tömböt használunk az adatgyűjtés tárolására, de akkor is hasznosabb, ha egy tömbre mint azonos típusú változók gyűjteményére gondolunk. A java.util.Arrays osztálynak van néhány módszere. Ezek a módszerek alkalmazhatók a tömbön, hogy megkapják a tömb indexét, a tömbök hosszát. Össze lehet hasonlítani két tömböt annak ellenőrzésére, hogy mindkét adott tömb azonos-e vagy sem. Tegyük fel, hogy egy tömbbe kell beszerezni az értékeket, hogy minden indexhez egy adott értéket el lehessen helyezni. Minden indexhez meg kell adnunk bizonyos értékeket.
- A tömbök növekvő sorrendbe rendezésére van néhány módszerünk. Ez a rendezési módszerrel valósítható meg. Vannak párhuzamos rendezési módszerek a java-ban is. A párhuzamos és nagy tömbök rendezése a többprocesszoros rendszereken gyorsabb, mint a szekvenciális tömbök. Az egyik adattípus a tömb. Tegyük fel, hogy van egy forgatókönyv, ahol sok azonos típusú adatot kell tárolnia. A tömb statikus adatszerkezet több érték tárolására. A Java többi változójához hasonlóan, tömböket is átadhatunk a módszerekben.
Kód:
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);
)
)
Kimenet:
Hogyan deklarálható tömb Java-ban?
A tömb nem más, mint adatgyűjtemény. A tömb homogén adattípusok gyűjteménye. Azt is elmondhatjuk, hogy a tömb adatszerkezet hasonló adatértékek tárolására. Ez hasonló típusú adatokat tárol egy változóban. Tegyük fel, hogy diákok vannak egy osztályban. Minden hallgató rendelkezik azonosítóval.
Tegyük fel, hogy 100 hallgató van ott. Az alábbiakban változókat deklarálunk mindegyikre.
Int hallgató1 = 1;
Diák2 = 2;
Int hallgató3 = 3;
Int hallgató4 = 4;
.
.
.
Int hallgató5 = 5;
Hát … még mindig rendben van. De mi van, ha 1000 hallgatója van? Nagyon unalmas és időigényes, ha 1000-szeres változót deklarálunk.
Szóval mi a megoldás akkor? Igen, és a válasz Array. Lássuk, hogyan lehet deklarálni a tömböt.
A tömbben az értékeket egyetlen változóba tehetjük.
Pl .: int hallgató () = új int (1000);
Látni fogjuk, hogy az a következő ábrán látható:
Diák() 
Itt egyetlen változóban nem tárolhatjuk a kívánt értéket. A változó nem más, mint a memóriahelyre történő hivatkozás.
Ha gondosan látta, deklaráltuk a tömböt az új kulcsszóval. Általában új kulcsszót használunk az objektumok létrehozásához. Ez azt jelenti, hogy a java tömbök tárgyak.
Hé, várj mit? Tárgy. Ez azt jelenti, hogy létezzen olyan osztály, amely már létezik a tárgy létrehozásához. Igen, van egy szuperosztályunk ehhez, és ez az objektum osztály. A tömb mindig kiterjeszti az osztályobjektumot. A tömbök mindig halom memóriát foglalnak el. Nem csak tömb objektumok, hanem a java összes objektuma is tárolódik a halom memóriában. Tehát az összes értékre csak egy hivatkozás van. Ezzel hatékonyan használtuk fel a memóriát. A tömb szinte minden nyelvben gyakori téma. Miután megértettük a tömb alapfogalmát, könnyen meg tudjuk oldani.
Hogyan inicializáljuk a tömböket a Java programozásban?
Most felmerül a következő kérdés, hogyan lehet inicializálni a tömböt. Mit jelent ez a kifejezés? Az inicializálás nem más, mint a változó értékének hozzárendelése.
Többféle módszer is lehet a tömbök inicializálására a java-ban.
Az első módszer a fenti példában látható, miközben a tömböt deklarálja.
Pl .: int hallgató () = új int (1000);
A következő dolog: inicializálhatunk egy tömböt, miközben a következőképpen deklaráljuk:
Pl .: int hallgató () = (1, 2, 3, 4, 5, 6, … .1000);
A tömb használata közben kivételt képezhetünk. Ha megismerkedett a java hibakezelésével, akkor tudnia kell a kivételt. A kivétel nem más, mint a futás közben ismert hiba hatékony kezelése. A tömb esetében a tömbindex kivételével a határokon kívül esik.
Hogyan lehet hozzáférni a tömb elemekhez?
Mostanáig megtanultuk, hogyan kell deklarálni és inicializálni a tömböt. Itt az ideje, hogy továbblépjünk. Tegyük fel, hogy van-e olyan tömb, mint a fenti, azaz diák tömb.
Most azt szeretnénk, ha külön hozzáférést kapnánk a programozáshoz. Hogyan szerezzük meg az adott elem értékét a tömbben.
A Array-ban a index index fogalma van.
Például nézze meg az alábbi ábrát.
Az index nem nullával kezdődik (0).
A Java tömb típusai (Magyarázza meg az egyes típusokat példákkal)
Mielőtt elkezdenénk a tömb típusát, nézzük meg néhány alapfogalmat.
A tömb új elemek által kiosztott elemei automatikusan nullával (numerikus típusoknál), false (logikailag) vagy nullával (referencia típusoknál) lesznek inicializálva. Alapértelmezett tömbértékek vannak a Java-ban. A tömb beszerzése kétlépéses folyamat. Ki kell deklarálnia a tömb típusú változót. Ezután új kulcsszóval kell elosztania a memóriát arra, amely a tömböt fogja tárolni, és azt hozzárendeli a tömb változóhoz. Tehát azt mondhatjuk, hogy a Java-ban az összes tömb dinamikusan van elosztva.
Kétféle tömb létezik:
1. Egydimenziós tömb
Az egydimenziós 1D tömbből áll. Lehet, hogy egyetlen sor vagy egyetlen oszlop van.
Egydimenziós tömböt deklarálhatunk az alábbiak szerint:
Int () a; VAGY Int a (); VAGY Int () a; VAGY Int () a;
De a legelőnyösebb módszer az int () a; Ne feledje, hogy itt nem a tömb méretét deklaráljuk. Pl .: int (5) a; nem érvényes java-ban. A nyilatkozat idején nem adunk meg egy tömb méretét.
Most megvizsgáljuk a deklarációt és a tömb létrehozását:
Int () a; // A tömb nyilatkozata
Megjegyzés: a nyilatkozat idején nem bizonyítottuk a tömb méretét.
a = new int (5) // tömb létrehozása
A tömb létrehozásakor a tömb méretének megadása nagyon fontos.
Egy sorban deklarálhatunk és tömböt hozhatunk létre az alábbiak szerint:
Int () a = új int (3);
Most nézzük meg, hogyan lehet inicializálni a tömböt. Tegyük fel, hogy hozzáadnia kell néhány értéket egy tömbben. Akkor hozzá fogja adni egy adott indexhez. az alábbi:
a (0) = 1; // 1-et adunk hozzá a tömb 0. pozíciójában.
a (1) = 2;
a (2) = 3;
Most már látta, hogyan lehet inicializálni a tömböt. De mi lenne, ha megadnám az indexet, amely nem létezik a tömbön.
Pl .: a (10) = 11; // Tegyük fel, hogy csak 5 tömb volt
Ebben az időben ArrayIndexLoutOf BoundException fájlt dob. A tömb méretét meghaladó értékeket nem adhat hozzá.
Most deklarálhatjuk, létrehozhatjuk és inicializálhatjuk a tömböt egy sorban, az alábbiak szerint:
Int () a = (1, 2, 3, 4, 5); // Nyilatkoztassa, hozzon létre, inicializálja
Vagy egy másik módszer a következő
Int () a = új int () (1, 2, 3, 4, 5);
Most lássuk, hogyan lehet elemeket kinyerni egydimenziós tömbből:
Hogyan nyomtassa ki a tömb értékeit?
Itt fogjuk használni a hurkot:
Példa:
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));
)
)
)
Kimenet:
A fenti példában áthúzhatjuk a tömb értékeit.
2. Többdimenziós tömb
A többdimenziós tömb 2d és 3d tömbökből áll. Több sorból és több oszlopból áll. Array tömbnek is neveztük. Nevezhetjük egyenetlen tömbnek is. Most nézzük meg a tömbnyilatkozatot. Kétdimenziós tömb deklarációra gondolok. Fent láttuk, hogyan lehet egydimenziós tömböt deklarálni. Most meglátod a 2-D tömböt. Ugyanúgy, mint az egydimenziós tömböt a forráshurokon belüli hosszúságváltozóval olvasva, kétdimenziós tömböt is olvashatunk annak hossza változójának felhasználásával két for-hurkon belül. Tegyük fel, hogy az egydimenziós tömb hossz változója megadja az értékek összes számát, amelyet egydimenziós tömb tarthat. A 2-dimenziós tömb hossz változója megadja a tömbök teljes számát, amelyeket egy 2-dimenziós tömb tarthat.
A többdimenziós tömb azt mondhatja, hogy a tömbök tömbök.
Int () () a; // itt tömböt deklaráltunk a
Most ugyanúgy, mint a fentiekben, amit egydimenziós tömbtel tettünk. A tömb deklarálása után létre kell hoznunk egy tömböt. Nézze meg az alábbi példát.
a = új int (2) (4);
Ezután inicializálunk egy tömböt.
Ezt az alábbiakban ismertetett diagrammal tisztábban megértjük.
A fenti ábra alapján könnyen elindíthatjuk a tömb elemeit.
a (0) (0) = 10
a (0) (1) = 20
a (0) (2) = 30 <
a (0) (3) = 40
Nézze meg a következő diagramot, a fenti értékek az adott pozícióba kerülnek. Könnyedén inicializálhatjuk a tömböt sor és oszlop segítségével.
Most, az összes folyamat, például a deklarálás, a létrehozás és az inicializálás, egyetlen sorban hajtható végre, az alábbiak szerint. Kérjük, figyelje alaposan az alábbi szintaxist. Először egy deklarációt és létrehozást fogunk látni egy sorban:
int () () a = új int (2) (3);
Most meglátjuk mindhárom folyamat deklarálását, létrehozását és inicializálását.
int () () a = ((10, 20, 30), (100, 200, 300));
Nézze meg pontosan a következő programot:
Kód:
public class MyArray (
public static void main(String() args)
(
int()() a = ((10, 20, 30), (100, 200, 300));
System.out.print(a(1)(2));
)
)
Kimenet:
Próbálja ki a tömb kis programjait. Manipulálja az értékeket. Ha megtisztítja a kezét, miközben programozza a megértett apró dolgok nagy részét.
A tömbök előnyei és hátrányai a Java programozásban
Az alábbiakban bemutatjuk az előnyöket és hátrányokat.
Előnyök
- A tömb több értéket tárolhat egyetlen változóban.
- A tömbök gyorsak a primitív adattípusokhoz képest.
- Tárgyakat tárolhatunk tömbben.
- A tömb tagjai egymást követő memóriahelyekre vannak tárolva.
hátrányok
- A tömb rögzített méretű
- A tömb méretét futási időben nem növelhetjük vagy csökkenthetjük.
- Tömbben a memória pazarlás több lehet.
- Csak hasonló típusú adatelemeket tárolhatunk
- Míg az elemek hozzáadása vagy eltávolítása a tömb közepére befolyásolja a tömb teljesítményét.
A Java tömbök a homogén adattípus elemek tárolására használt adatstruktúrák. A tömbök előnye, hogy a tömb elemei az indexszámmal érhetők el. Ez megkönnyíti a válogatás, letöltés, keresés és az előnyben részesített műveletek elvégzését a tömbök ezen elemein. A tömb olyan kicsi koncepció, és korlátozott időben lefedi. A vizsgára vagy egy interjúra való felkészülés során győződjön meg arról, hogy látta-e és végrehajtotta-e a fent tárgyalt fogalmakat.
Összegzés - tömbök a Java programozásban
A tömbök a java alapvető fogalma. Ha szakértő vagy a tömbök és a karakterláncok kezelésében, akkor minden programozási nyelven ez a legjobb eredmény valaha. A tömböket nagyon könnyű megtanulni. Csak emlékeznem kell néhány alapfogalomra. Ha megtanulta, soha nem fogja elfelejteni a tömb megvalósítását.
Ajánlott cikkek
Ez egy útmutató a Java Programming tömbjeihez. Itt tárgyaljuk a tömbök bevezetését, előnyeit és hátrányait a Java programozásban, a mintakódokat és a kimenetet. Megnézheti más javasolt cikkeinket -
- Többdimenziós tömb C-ben
- Karakterlánc tömb C # -ben
- 3D tömbök Java-ban
- Tömbök C # -ben
- Különböző típusú hurkok és azok előnyei
- 2D grafika Java-ban
- Rendezési funkció Python-ban példákkal
- Hurkok a VBScript-ben példákkal
- Többdimenziós tömb a PHP-ben
- Dobás és dobás | Öt legfontosabb különbség, amelyet tudnia kell