A tömbök lehetnek egydimenziósak (vektor), kétdimenziósak (mátrix) és többdimenziósak.
Létrehozunk egy tömböt, adatokkal töltjük fel, majd kiíratjuk a tartalmát:
public class ArrayDemo {
public static void main(String[] args) {
int[] anArray; Tömb típusú változó deklarálása!
anArray = new int[10];
for (int i = 0; i < anArray.length; i++) {
anArray[i] = i;
System.out.print(anArray[i] + " ");
}
System.out.println();
}
}
A program kimenete:
0 1 2 3 4 5 6 7 8 9
további deklarálási példák tömbre
float[] anArrayOfFloats;
boolean[] anArrayOfBooleans;
Object[] anArrayOfObjects;
String[] anArrayOfStrings;
float anArrayOfFloats[];
explicit módonA tömb egy olyan változó, amely több azonos típusú adatot tartalmaz. A tömb (futásidei) hossza a létrehozásakor kerül megállapításra, és attól kezdve a tömb egy állandó méretű adatszerkezet.
Tömbök
A tömb egy eleme egyike a tömbben található tagoknak, mely a tömbben elfoglalt helye (indexe) alapján érhető el.
Ha különböző típusú adatokat akarunk tárolni egy szerkezeten belül, vagy olyan szerkezetre van szükség, melynek mérete dinamikusan módosítható, akkor használjunk a tömb helyett olyan gyűjtemény implementációkat, mint az ArrayList.
A tömb, mint adattípus az összetett adattípusok közé tartozik. A tömb valójában egy sorszámozott egyforma típusú elemeket tartalmazó halmaz. Halmaz alatt csak annyit értek, hogy több elemet tartalmaz. A tömbök mérete (hogy hány elemet tartalmaz) középiskolai szinten lényegtelen, akkora tömbökkel nem dolgozunk, ami a túl nagy méret miatt problémát okozna. Ami viszont fontos: a tömb mérete csak egyszer adható meg, amikor deklaráljuk a tömböt. Vagyis ha megadtam, hogy ez egy 10 elemet tartalmazó tömb, akkor ezen később nem változtathatok. Különösen figyelni kell erre akkor, amikor nem tudod, hogy hány elemet szeretnél tárolni, akkor kénytelen vagy az elméleti maximális méretet beállítani, amit a feladat ad meg. A tömböt logikailag ugyanúgy kell deklarálni, mint egy egyszerű változót. Megadjuk a típusát és nevét.
int[] tomb;
A tömb deklarálás formailag ettől el is térhet, a következő alakok is használhatóak:
int []tomb;
vagy
int tomb[];
Én az első deklaráció típust használom, számomra így logikus. Ha felolvasnám az általam használt alakot, akkor így hangzana: ez egy egészeket tartalmazó tömb, melynek neve: tomb. Félkövérrel kiemeltem a fontos részeket, amelyek pont ilyen sorrendben szerepelnek a deklarációban.
Észrevehetted, hogy itt csak a tömb típusát és nevét adtam meg, de a méretét nem. Pedig azt írtam, hogy a tömbnek mérete is van, ami a megadása után nem változhat. A tömb méretének megadása megtörténhet közvetlenül a deklarációkor. Ezt akkor célszerű így használni, ha már ekkor tudod, hogy hány elemet szeretnél tárolni benne. Adott a következő feladat: Sorsolj ki 10 egész számot és tárold el őket. Ilyenkor azonnal megadható a tömb mérete is:
int[] tomb = new int[10];
Az is előfordulhat, hogy szükségem lesz egy egészeket tartalmazó tömbre, de még nem ismert számomra, hány darab elemet szeretnék tárolni. Jellemzően ez fájlbeolvasáskor fordul elő, esetleg kiválogatás, szétválogatás témakörben, melyeket majd később ismertetek. Ilyenkor a tömb deklarálása után tetszőleges programkódok lehetnek, melyek nem használják még a tömböt, nem is használhatják, hiszen nincs mérete. Maga a tömb már név szerint létezik, de még nem foglalt le neki a rendszer memóriát az elemek tárolásához. Ellenben a méret megadása előtt megszámolhatom, hogy majd mekkora tömbre lesz szükségem, és akkor állítom be a méretet, ha már biztosan tudom mekkorára van szükségem.
int[] tomb;
// ...
// ...
tomb = new int[10]
A tömbméretet mindenképpen azelőtt kell megadni, mielőtt használni szeretnénk. Fontos azt is tudni, hogy habár a tömb méretének megadásakor a tömbbe mi még nem helyeztünk el elemeket, a tömb nem üres. A méret megadásának kulcsa a new operátor. Ez létrehozza magát a tömb objektumot, ami a méretnek megfelelő darabszámú elemet képes tárolni, és aminek a rendszer azonnal lefoglalja a tároláshoz szükséges memóriaterületet. Ennek során a tömbben lévő minden elem kap egy kezdőértéket, amely a tömb típusától függ. A kezdőérték minden elemnél számok esetén 0, logikai típus esetén pedig false lesz. Később, ha mi magunk helyezünk el bárhová a tömbben egy értéket , csak az adott helyen lévő elem kezdő értékét írjuk át. A tömb new operátorral történő létrehozását – ezáltal kezdőértékekkel való feltöltését – inicializálásnak nevezzük.
Lássuk hogyan lehet egy tömböt használni.
Egy tömb, mint már említettem egy sorszámozott egyforma típusú elemeket tartalmazó halmaz. A sorszámozásnak fontos szerepe van, mert az elemek sorrendje – amíg meg nem változtatjuk – kötött. Mindenkinek megvan a saját azonosítója, amit nevezzünk indexnek. A sorszám annyiban nem a legpontosabb elnevezés, hogy itt a sorszámozás – amit innentől nevezzünk indexelésnek – 0-val kezdődik. Ebből következik, hogy a legutolsó elem indexe mindig a tömbméret-1. Az indexek mindig pozitív egész számok!
Mivel minden tömbelem helye fix, és a helyét az elem indexe adja meg, ezért lehet egy tetszőleges elemre hivatkozni a következő módon:
tomb[index]
Ez az adott indexű helyen tárolt elem konkrét értékét adja vissza, és amíg direkt nem cserélgetjük össze az elemeket, vagy nem változtatjuk meg az értéküket, mindig ugyanazt az értéket adja. Így lehet például a tömb feltöltése közben az adott helyen lévő “tárolóban” értéket elhelyezni. Értelemszerűen az index legkisebb értéke 0 lehet (ez az első elem), a legnagyobb pedig tömbméret-1 (ez az utolsó). De hogyan tudjuk a tömbméretet megkapni? Az egy dolog, hogy mi adtuk meg a programban valahol, de már nem emlékszünk rá, vagy nem akarjuk mindenhova azt a konkrét számot beírni, mert lehet, hogy később átírjuk a tömb méretét. A tomb.length mindig megadja egy tetszőleges tömb méretét.
tomb[0] // mindig ez az első elem
tomb[tomb.length-1] // mindig ez az utolsó elem
Fontos, hogy nem a tömbben általunk eltárolt elemek számát adja meg, mert az lehet kevesebb is, mint a tömb mérete. Például tudom, hogy legfeljebb 20 értéket akarok tárolni, akkor egy 20 elemű tömbre van szükségem. És ha csak 15-öt tároltam el? Akkor az utolsó 5 üres lesz. Van ilyen. A tomb.length tehát azt a darabszámot adja meg, amennyi elem maximálisan elfér a tömbben és nem a már eltárolt elemek számát. Ha nem használtuk ki a tömb teljes méretét, akkor nekünk kell külön nyilvántartani, hogy melyik az utolsó elem, amit mi helyeztünk el a tömbben. Hiszen utána is vannak elemek a tömbben, a kezdőértékek. Az is lehet, hogy az általunk elhelyezett elem értéke 0, ami különbözik az utána következő 0 értéktől, ami már a kezdőérték miatt annyi! A lényeg: saját változóban tárold azt az indexet, ami annak az utolsó elemnek a helye a tömbben, amit te helyeztél el benne. Legyen ez a változó mondjuk db nevű.
tomb[db] // ez az utolsó általam elhelyezett elem
tomb[tomb.length-1] // ez pedig a tömb utolsó eleme, ami kezdőérték
Egyik kedvenc hibám, amit a diákoknál látok: tomb.lenght Ezt a hibát percekig lehet keresni. Hányszor futottam már bele ilyenbe. Tessék ügyelni a helyesírásra! Még ha nem is tanulsz angolt – ami az informatikában elég nagy hátrány – tanuld meg helyesen leírni az angol szavakat!
A feladat a következő: Töltsünk fel egy 10 elemű egészeket tartalmazó tömböt az [1;100] intervallumból és tároljuk el a kisorsolt értékeket. Amikor egy tömbbel dolgozunk, szinte mindig ciklusra van szükség. Hogy a ciklus milyen típusú (elöl tesztelő, hátul tesztelő vagy növekményes, esetleg speciális foreach), azt mindig az adott feladattípus dönti el. Amikor például egy tömböt feltöltünk értékekkel vagy ki akarjuk íratni a tartalmát, akkor úgyis végig kell nézni az egészet.
Mivel a ciklusokat már feltételezem, hogy ismeri az olvasó, így lássuk a megoldásokat alap feladatokra, egyelőre nem teljes programban. A lenti kódban a már ismertetett módon használom a számsorsolást:
1
2
3
4
for( int i = 0; i < tomb.length; i++ )
{
tomb[i] = (int)(Math.random()*100)+1;
}
Ez a programrész egy tetszőleges méretű tömböt feltölt egy adott méretű intervallumból. A két kiemelt sor tartalmazza a lényege (a többi csak formaság). Az 1. sorban indítunk egy növekményes ciklust, ami egy ciklusváltozót (i) elindít 0-tól és addig megy amíg kisebb, mint a tomb nevű tömb mérete. Vagyis mi lesz az i utolsó értéke? Tömbméret-1. Ismerős? Ez az utolsó elem indexe. Vagyis ez a ciklus végiglépteti az i változót a tömb összes lehetséges indexén. Akármekkora is a tömb. Ezért kérdeztük meg a méretét tőle, mert lényegtelen, hogy a program elején mekkora tömbméretet adtunk meg. A 3. sorban pedig a léptetett indexeket felhasználva a tömb minden elemének egy véletlenszerű értéket adunk a megadott intervallumból. Apropó, ez melyik intervallum? … … … Számold ki!
Mi van akkor, ha ellenőrizni akarjuk, hogy a tömböt tényleg megfelelően töltöttük-e fel? Hátha elszúrtuk az intervallumot.
1
2
3
4
for( int i = 0; i < tomb.length; i++ )
{
System.out.print(tomb[i]+" ");
}
Ezt a programrészt már nem is kell nagyon magyarázni. Az 1. sor ciklusa segítségével végigmegyünk a tömb összes indexén. A 3. sorban pedig mindig kiíratjuk a tömb aktuális indexű (vagyis mindegyik) elemét úgy, hogy egy szóközt is hagyunk utána, hogy az elemek elkülönüljenek egymástól.
Hogy néz ki ez az egész egyben?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Tombfeltoltes
{
public static void main( String[] args )
{
// tömb deklarálása és méretének megadása
int[] tomb = new int[10];
// tömb feltöltése
for( int i = 0; i < tomb.length; i++ )
{
tomb[i] = (int)(Math.random()*100)+1;
}
// tömb elemeinek kiíratása
for( int i = 0; i < tomb.length; i++ )
{
System.out.print(tomb[i]+" ");
}
// extra sordobás
System.out.println();
}
}
Többdimenziós tömbök, avagy tömbök egy csokorban
A tömb, mint összetett adattípus az előző anyagokból már ismerős lehet. Míg a tömbök egy adatsort tartalmaznak, a többdimenziós tömbök pedig többet. A többdimenziós tömbök valójában tömbök tömbjei. A dimenziók száma elméletileg nincs korlátozva, gyakorlatilag 3 dimenziónál többel dolgozni nem feltétlenül praktikus.
Egy általános tömb deklarációja a következőképp néz ki:
// deklarálás és inicializálás, ami csak 0 értékekkel tölti fel a tömböt
int[] tomb = new int[10];
// deklarálás és azonnali kezdőérték adás
int[] tomb = {1,2,3,4,5,6,7,8,9,10};
// adott indexű elem kiválasztása
tomb[5]
Ez a többdimenziós tömbök esetén is hasonló, de mivel ezek tömbök tömbjei, ezért ezt formailag is jelezni kell.
Kétdimenziós tömbök
// kétdimenziós tömb deklarálása és inicializálása
int[][] tomb = new int[2][3];
// kétdimenziós tömb adott elemének kiválasztása
tomb[1][2]
Az előző deklarálás azt jelenti, hogy létrehozunk egy 2 sorból és 3 oszlopból álló kétdimenziós tömböt. A sorok és oszlopok sorszámozása (indexelése) itt is 0-val indul, mint általában a tömbök esetén. Mint már említettem, a többdimenziós tömb valójában tömbök tömbje, de formailag ez hogy néz ki? Nézzük meg egy konkrét példán keresztül:
int[][] tomb = { { 2,4,6 }, { 3,7,8 } };
Mit is jelent ez? Adott két sor (a két kicsi tömb darabszáma, ami a számokat tartalmazza) és adott 3 oszlop (ami a kis tömbökben lévő számok darabszámát jelenti). Láthatod, hogy a kis tömbökben lévő számok darabszáma megegyezik, ez nem véletlen. Valójában ez a szám az oszlopok száma. Hogy jobban látható legyen, átrendezem az előző példában szereplő tömb szerkezetét:
int[][] tomb = {
{ 2,4,6 },
{ 3,7,8 }
};
Így már egyértelműbb, hogy mit jelent a sorok és oszlopok száma. A két kis belső tömb jelenti a sorokat, egymás alá írva őket, valóban sorokat alkotnak. A bennük lévő elemek száma pedig kötött, mert ez jelenti az oszlopok számát. A két sort összefogó külső tömb határolóit direkt külön sorba írtam, hogy az ne zavarjon, de az is a struktúra része. Amikor hivatkozunk egy elemre (tomb[1][2]), akkor azt mondjuk meg, hogy az 1-es indexű kis tömbnek (a másodiknak) a 2-es oszlopában (a harmadikban) lévő 8-as elemre gondolunk. Ne feledd, a sor és oszlop indexelése is 0-val kezdődik.
A kétdimenziós tömbök kezeléséhez szinte minden esetben két egymásba ágyazott ciklusra van szükség, olyanokra, mint amilyeneket a rendezéseknél is láthattál. A külső ciklus a sorszámot, a belső az oszlopszámot lépteti. Nézzük meg, hogy néz ez ki:
1
2
3
4
5
6
7
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*10);
}
}
Ez a példa végigmegy a tömb összes elemén, és mindegyiket egy [0;9] intervallumból sorsolt számmal tölt fel. Láthatod, hogy van egy tömbelem kiválasztás (tomb[i][j]), ami az előzőleg ismertetett módon [sor][oszlop] választja ki az adott elemet. Mivel a későbbiekben nagy valószínűséggel mindig ugyanolyan nevű változókat használsz, ezért jó ha megjegyzed, hogy az i változóval jelölöd a sorokat, és j-vel az oszlopokat. Ez a későbbiekben fontos lesz, hogy tudd, melyik melyik.
A kiemelt sorban van igazából az érdekesség, ami elsőre furcsa lehet. A tömb i indexű elemének tömbmérete? Kétdimenziós tömbben a tömb deklarálása után az inicializáláskor meg kell határozni a tömb méretét. Így van ez az alap tömbök esetén is, és így van ez itt is. A különbség az, hogy itt külön kell beállítani a sorok és oszlopok számát. Először a sorok, utána az oszlopok számát. De akkor a tomb.length melyiket adja meg a kettő közül, és hogy kapjuk meg a másikat? Tisztázzunk akkor pár sarokpontot az ilyen tömbök kezelésével kapcsolatban
tomb.length; // sorok száma (a kis tömbök darabszáma)
tomb[1]; // az 1-es indexű sor elemei (2. sor tömbje)
tomb[i].length; // oszlopok száma (az i indexű tömbben lévő elemek száma)
tomb[3][2]; // tömbben tárolt elem, ami a 4. sor 3. oszlopában van
Az oszlopok számát miért egy i indexű sor méretéből kapjuk meg, miért nem fixen a 0 indexű sor méretéből? Azért, mert létezik egy speciális többdimenziós tömbtípus, melyet nagyon ritkán használunk, és ott eltérhet az egyes sorok (kis tömbök) mérete, így mindig az aktuális sor méretével dolgozzunk.
Kétdimenziós tömbök bejárása
az összes elem bejárása:
Ebben az esetben két ciklusra van szükség, amire már láttál példát a tömb feltöltésénél.
egy sor bejárása:
Ekkor elég csak egy konkrét soron végigmenni egyetlen ciklussal. Ebben a példában a 3. sor összes elemét írjuk ki egymás mellé. Ez a következőképp néz ki:
for( int j = 0; j < tomb[2].length; j++ )
{
System.out.print(tomb[2][j]+" ");
}
Ebben az esetben láthatjuk, hogy a tomb[2]-re hivatkozok fixen, több helyen is. Először a ciklus fejében, ahol a 2-es indexű (3.) sor elemeit akarom kiírni. Valamint a konkrét elem kiválasztásánál is látszik, hogy csak a 2-es indexű sor szerepel, de azon belül a j-vel végiglépkedek a sor összes elemén (oszlopán). Technikailag a j helyett itt i is lehetne ciklusváltozó, a program akkor is tökéletesen működne. Logikailag azért szoktam javasolni, hogy j legyen, mert akkor jobban rögzül, hogy a j az oszlopokat jelenti, és most csak az oszlop változik, a sor kötött.
egy oszlop bejárása:
Az előzőhöz hasonlóan itt is elég egyetlen ciklus, hiszen egyetlen oszlopon kell csak végigmenni. Ekkor az oszlop száma kötött és csak a sorszám változik. Ez így néz ki:
for( int i = 0; i < tomb.length; i++ )
{
System.out.println(tomb[i][4]);
}
Láthatod, hogy a ciklus fejében máshogy szerepel a futási feltétel, csak tomb.length szerepel, ami a sorok számát jelenti. A ciklusmagban pedig az adott elem kiválasztásakor a oszlopszám fix (jelen esetben a 4-es indexű 5. sor) és az sorszám az, ami változik, ezért használtam i ciklusváltozót.
Most már tetszőleges kétdimenziós tömböt be tudunk járni, jöhetnek az ezzel kapcsolatos feladatok. Az első feladat a tömb feltöltése, a többi feladatban pedig ezzel a tömbbel dolgoznánk.
Gyakorló feladatok
Tölts fel egy 3×5-ös kétdimenziós tömböt a [-10;30] intervallumból:
int[][] tomb = new int[3][5];
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*41)-10;
}
}
Írd ki a tömböt sorokba és oszlopokba rendezve:
int[][] tomb = new int[3][5];
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// egymás mellé írom ki egy sor elemeit
System.out.print(tomb[i][j]+" ");
}
// ha végeztem egy sor kiírásával, akkor új sort kezdek
System.out.println();
}
Írd ki a tömbben szereplő számok összegét:
int osszeg = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
osszeg = osszeg + tomb[i][j];
// vagy osszeg += tomb[i][j];
}
}
System.out.println("A tomb elemeinek osszege"+osszeg);
Írd ki a 2. sor összegét:
int osszeg = 0;
for( int j = 0; j < tomb[1].length; j++ )
{
osszeg = osszeg + tomb[1][j];
// vagy osszeg += tomb[1][j];
}
System.out.println("A 2. sor osszege"+osszeg);
Számold meg, hány negatív szám szerepel a tömbben:
int db = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
if( tomb[i][j] < 0 )
{
db++;
}
}
}
System.out.println("A tombben "+db+" negativ szam van.");
Számold meg, hány páros szám található a 3. oszlopban:
int db = 0;
for( int i = 0; i < tomb.length; i++ )
{
if( tomb[i][2] % 2 == 0 )
{
db++;
}
}
System.out.println("A tomb 3. oszlopaban "+db+" paros szam van.");
Írd ki, melyik a legkisebb elem a tömbben:Ez a feladat nem teljesen ugyanaz, mint amit a minimumkeresésnél láthattál. Arra remélem emlékszel, hogy a minimumnak a helyét, és nem az értékét tároljuk, mert a helyéből két dologra is válaszolhatunk, ezt most nem írnám le újra. De itt a hely nem egy index, hanem kettő: [oszlop][sor]
Két dolgot tehetsz. Vagy két változót használsz a hely tárolására (egyet a sornak, egyet az oszlopnak), vagy egy két elemű tömbben tárolod, valahogy így:
int[] min = new int[2];
min[0] = sor;
min[1] = oszlop;
Vagy tárolhatod két változóban is:
int minI = sor;
int minJ = oszlop;
Rád bízom melyiket használod, a lényeg, hogy helyesen tedd. Lássunk akkor példát a bonyolultabbra:
int[] min = new int[2];
// ebben a két sorban állítom be, hogy az első elem az első minimum
min[0] = 0;
min[1] = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// ha a tömb aktuális eleme kisebb, mint az eddigi minimum
// ahol a minimum elem sora min[0], oszlopa min[1]
if( tomb[i][j] < tomb[ min[0] ][ min[1] ] )
{
min[0] = i;
min[1] = j;
}
}
}
// na itt ne keverd össze a [ ] jeleket...
System.out.println("A tomb legkisebb eleme: "+tomb[min[0]][min[1]]);
Azért hasonlítsuk ezt össze azzal, ha két külön változóban tárolod a minimum elem sorát és oszlopát:
// ebben a két sorban állítom be, hogy az első elem az első minimum
int minI = 0;
int minJ = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// ha a tömb aktuális eleme kisebb, mint az eddigi minimum
// ahol a minimum elem sora min[0], oszlopa min[1]
if( tomb[i][j] < tomb[minI][minJ] )
{
minI = i;
minJ = j;
}
}
}
// na itt ne keverd össze a [ ] jeleket...
System.out.println("A tomb legkisebb eleme: "+tomb[minI][minJ]);
Talán a két külön változó kicsit barátságosabb.
Ha igazán figyeltél az eddigiekben, kiszúrhattad, hogy más különbség is van a minimumkereséshez képest, azon kívül, hogy itt a minimum helyét értelemszerűen két számként tároljuk. Figyeld meg, honnan indulnak itt a ciklusok. Nem 1-től! A minimumkeresésnél emlékezhetsz, hogy az első (0 indexű) elem a legkisebb, ezért a ciklus 1-es indextől kezdődik, hogy önmagával már ne hasonlítsuk össze. Itt ezt nem tehetjük meg. Miért?
Ha a külső ciklusban az i változó 1-től indulna, akkor az első (0 indexű) sor teljesen kimaradna a vizsgálatból. Ha a belső ciklusban a j változó indulna 1-től, akkor pedig minden sor első eleme, vagyis a teljes első (0. indexű) oszlop maradna ki. Itt kénytelenek vagyunk az első minimumot önmagával is összehasonlítani, ami azért valljuk be, nem túl nagy veszteség. De ha nem így oldod meg, akkor súlyos hiba.
Háromdimenziós tömbök
Többdimenziós tömböket 3 dimenzió felett nem igazán használunk. A 3. dimenzióval még van értelme dolgozni, mondjuk térbeli koordináták, vagy képfeldolgozás esetén mondjuk egy RGB kód tárolása esetén. Ebben az esetben formailag így néz ki a tömbünk:
// háromdimenziós tömb deklarálása és inicializálása
int[][][] tomb = new int[4][5][2];
// háromdimenziós tömb adott elemének kiválasztása
tomb[1][2][1]
Itt a 3. dimenzió mondjuk mint egyfajta magasság értelmezhető térbeli pontok tárolása esetén. Színkódoknál pedig a 3 színkomponens értékét tárolhatjuk a tömbben. Ezekben az esetekben a tömb teljes bejárása értelemszerűen 3 ciklust jelent, de csak az első sorbeli magasságadatok bejárása is két ciklust igényel. Akkor van szükség egy ciklusra, ha a 3 dimenzióból 2 rögzített. Például az első sor második eleméhez tartozó pontok (a tomb[0][1] magasságoszlopa) bejárása esetén.
Fűrészfogas tömbök
Láthattad, hogy a kétdimenziós tömbök esetén az oszlopok száma minden esetben megegyezik. Ez azonban nem mindig van így. Megadható az is, hogy az egyes sorok változó (de megadásuk után fix) hosszúak legyenek. Ezt a szerkezetet fűrészfogas tömbnek is szokás nevezni. Ilyen szerkezetet nagyon speciális esetekben használunk, de a kezelése a fentiek alapján meglehetősen egyszerű. Lássuk hogyan deklaráljuk ezt:
// először csak a sorok számát adjuk meg
int[][] tomb = new int[3][];
// ezután használat előtt egyenként adjuk meg a sorok méreteit
tomb[0] = new int[5];
tomb[1] = new int[7];
tomb[2] = new int[3];
// töltsük fel a tömböt a [0;9] intervallumból
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*10);
}
}
// írjuk ki a tömböt
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
System.out.print(tomb[i][j]+" ");
}
System.out.println();
}
Ismétlés;
Egyszerű változók:
char - karakter
byte - numerikus egész
short - numerikus egész
int - numerikus egész
long - numerikus egész
float - numerikus lebegőpont
double - numerikus lebegőpont
boolean - boolean
literálok; A literál nem más, mint a program szövegében direkt módon beleírt adat
egész...
valós...
logikai...
karakter...
szöveg...
null"
Létrehozunk egy tömböt, adatokkal töltjük fel, majd kiíratjuk a tartalmát:
public class ArrayDemo {
public static void main(String[] args) {
int[] anArray; Tömb típusú változó deklarálása!
anArray = new int[10];
for (int i = 0; i < anArray.length; i++) {
anArray[i] = i;
System.out.print(anArray[i] + " ");
}
System.out.println();
}
}
A program kimenete:
0 1 2 3 4 5 6 7 8 9
további deklarálási példák tömbre
float[] anArrayOfFloats;
boolean[] anArrayOfBooleans;
Object[] anArrayOfObjects;
String[] anArrayOfStrings;
float anArrayOfFloats[];
explicit módonA tömb egy olyan változó, amely több azonos típusú adatot tartalmaz. A tömb (futásidei) hossza a létrehozásakor kerül megállapításra, és attól kezdve a tömb egy állandó méretű adatszerkezet.
Tömbök
A tömb egy eleme egyike a tömbben található tagoknak, mely a tömbben elfoglalt helye (indexe) alapján érhető el.
Ha különböző típusú adatokat akarunk tárolni egy szerkezeten belül, vagy olyan szerkezetre van szükség, melynek mérete dinamikusan módosítható, akkor használjunk a tömb helyett olyan gyűjtemény implementációkat, mint az ArrayList.
A tömb, mint adattípus az összetett adattípusok közé tartozik. A tömb valójában egy sorszámozott egyforma típusú elemeket tartalmazó halmaz. Halmaz alatt csak annyit értek, hogy több elemet tartalmaz. A tömbök mérete (hogy hány elemet tartalmaz) középiskolai szinten lényegtelen, akkora tömbökkel nem dolgozunk, ami a túl nagy méret miatt problémát okozna. Ami viszont fontos: a tömb mérete csak egyszer adható meg, amikor deklaráljuk a tömböt. Vagyis ha megadtam, hogy ez egy 10 elemet tartalmazó tömb, akkor ezen később nem változtathatok. Különösen figyelni kell erre akkor, amikor nem tudod, hogy hány elemet szeretnél tárolni, akkor kénytelen vagy az elméleti maximális méretet beállítani, amit a feladat ad meg. A tömböt logikailag ugyanúgy kell deklarálni, mint egy egyszerű változót. Megadjuk a típusát és nevét.
int[] tomb;
A tömb deklarálás formailag ettől el is térhet, a következő alakok is használhatóak:
int []tomb;
vagy
int tomb[];
Én az első deklaráció típust használom, számomra így logikus. Ha felolvasnám az általam használt alakot, akkor így hangzana: ez egy egészeket tartalmazó tömb, melynek neve: tomb. Félkövérrel kiemeltem a fontos részeket, amelyek pont ilyen sorrendben szerepelnek a deklarációban.
Észrevehetted, hogy itt csak a tömb típusát és nevét adtam meg, de a méretét nem. Pedig azt írtam, hogy a tömbnek mérete is van, ami a megadása után nem változhat. A tömb méretének megadása megtörténhet közvetlenül a deklarációkor. Ezt akkor célszerű így használni, ha már ekkor tudod, hogy hány elemet szeretnél tárolni benne. Adott a következő feladat: Sorsolj ki 10 egész számot és tárold el őket. Ilyenkor azonnal megadható a tömb mérete is:
int[] tomb = new int[10];
Az is előfordulhat, hogy szükségem lesz egy egészeket tartalmazó tömbre, de még nem ismert számomra, hány darab elemet szeretnék tárolni. Jellemzően ez fájlbeolvasáskor fordul elő, esetleg kiválogatás, szétválogatás témakörben, melyeket majd később ismertetek. Ilyenkor a tömb deklarálása után tetszőleges programkódok lehetnek, melyek nem használják még a tömböt, nem is használhatják, hiszen nincs mérete. Maga a tömb már név szerint létezik, de még nem foglalt le neki a rendszer memóriát az elemek tárolásához. Ellenben a méret megadása előtt megszámolhatom, hogy majd mekkora tömbre lesz szükségem, és akkor állítom be a méretet, ha már biztosan tudom mekkorára van szükségem.
int[] tomb;
// ...
// ...
tomb = new int[10]
A tömbméretet mindenképpen azelőtt kell megadni, mielőtt használni szeretnénk. Fontos azt is tudni, hogy habár a tömb méretének megadásakor a tömbbe mi még nem helyeztünk el elemeket, a tömb nem üres. A méret megadásának kulcsa a new operátor. Ez létrehozza magát a tömb objektumot, ami a méretnek megfelelő darabszámú elemet képes tárolni, és aminek a rendszer azonnal lefoglalja a tároláshoz szükséges memóriaterületet. Ennek során a tömbben lévő minden elem kap egy kezdőértéket, amely a tömb típusától függ. A kezdőérték minden elemnél számok esetén 0, logikai típus esetén pedig false lesz. Később, ha mi magunk helyezünk el bárhová a tömbben egy értéket , csak az adott helyen lévő elem kezdő értékét írjuk át. A tömb new operátorral történő létrehozását – ezáltal kezdőértékekkel való feltöltését – inicializálásnak nevezzük.
Lássuk hogyan lehet egy tömböt használni.
Egy tömb, mint már említettem egy sorszámozott egyforma típusú elemeket tartalmazó halmaz. A sorszámozásnak fontos szerepe van, mert az elemek sorrendje – amíg meg nem változtatjuk – kötött. Mindenkinek megvan a saját azonosítója, amit nevezzünk indexnek. A sorszám annyiban nem a legpontosabb elnevezés, hogy itt a sorszámozás – amit innentől nevezzünk indexelésnek – 0-val kezdődik. Ebből következik, hogy a legutolsó elem indexe mindig a tömbméret-1. Az indexek mindig pozitív egész számok!
Mivel minden tömbelem helye fix, és a helyét az elem indexe adja meg, ezért lehet egy tetszőleges elemre hivatkozni a következő módon:
tomb[index]
Ez az adott indexű helyen tárolt elem konkrét értékét adja vissza, és amíg direkt nem cserélgetjük össze az elemeket, vagy nem változtatjuk meg az értéküket, mindig ugyanazt az értéket adja. Így lehet például a tömb feltöltése közben az adott helyen lévő “tárolóban” értéket elhelyezni. Értelemszerűen az index legkisebb értéke 0 lehet (ez az első elem), a legnagyobb pedig tömbméret-1 (ez az utolsó). De hogyan tudjuk a tömbméretet megkapni? Az egy dolog, hogy mi adtuk meg a programban valahol, de már nem emlékszünk rá, vagy nem akarjuk mindenhova azt a konkrét számot beírni, mert lehet, hogy később átírjuk a tömb méretét. A tomb.length mindig megadja egy tetszőleges tömb méretét.
tomb[0] // mindig ez az első elem
tomb[tomb.length-1] // mindig ez az utolsó elem
Fontos, hogy nem a tömbben általunk eltárolt elemek számát adja meg, mert az lehet kevesebb is, mint a tömb mérete. Például tudom, hogy legfeljebb 20 értéket akarok tárolni, akkor egy 20 elemű tömbre van szükségem. És ha csak 15-öt tároltam el? Akkor az utolsó 5 üres lesz. Van ilyen. A tomb.length tehát azt a darabszámot adja meg, amennyi elem maximálisan elfér a tömbben és nem a már eltárolt elemek számát. Ha nem használtuk ki a tömb teljes méretét, akkor nekünk kell külön nyilvántartani, hogy melyik az utolsó elem, amit mi helyeztünk el a tömbben. Hiszen utána is vannak elemek a tömbben, a kezdőértékek. Az is lehet, hogy az általunk elhelyezett elem értéke 0, ami különbözik az utána következő 0 értéktől, ami már a kezdőérték miatt annyi! A lényeg: saját változóban tárold azt az indexet, ami annak az utolsó elemnek a helye a tömbben, amit te helyeztél el benne. Legyen ez a változó mondjuk db nevű.
tomb[db] // ez az utolsó általam elhelyezett elem
tomb[tomb.length-1] // ez pedig a tömb utolsó eleme, ami kezdőérték
Egyik kedvenc hibám, amit a diákoknál látok: tomb.lenght Ezt a hibát percekig lehet keresni. Hányszor futottam már bele ilyenbe. Tessék ügyelni a helyesírásra! Még ha nem is tanulsz angolt – ami az informatikában elég nagy hátrány – tanuld meg helyesen leírni az angol szavakat!
A feladat a következő: Töltsünk fel egy 10 elemű egészeket tartalmazó tömböt az [1;100] intervallumból és tároljuk el a kisorsolt értékeket. Amikor egy tömbbel dolgozunk, szinte mindig ciklusra van szükség. Hogy a ciklus milyen típusú (elöl tesztelő, hátul tesztelő vagy növekményes, esetleg speciális foreach), azt mindig az adott feladattípus dönti el. Amikor például egy tömböt feltöltünk értékekkel vagy ki akarjuk íratni a tartalmát, akkor úgyis végig kell nézni az egészet.
Mivel a ciklusokat már feltételezem, hogy ismeri az olvasó, így lássuk a megoldásokat alap feladatokra, egyelőre nem teljes programban. A lenti kódban a már ismertetett módon használom a számsorsolást:
1
2
3
4
for( int i = 0; i < tomb.length; i++ )
{
tomb[i] = (int)(Math.random()*100)+1;
}
Ez a programrész egy tetszőleges méretű tömböt feltölt egy adott méretű intervallumból. A két kiemelt sor tartalmazza a lényege (a többi csak formaság). Az 1. sorban indítunk egy növekményes ciklust, ami egy ciklusváltozót (i) elindít 0-tól és addig megy amíg kisebb, mint a tomb nevű tömb mérete. Vagyis mi lesz az i utolsó értéke? Tömbméret-1. Ismerős? Ez az utolsó elem indexe. Vagyis ez a ciklus végiglépteti az i változót a tömb összes lehetséges indexén. Akármekkora is a tömb. Ezért kérdeztük meg a méretét tőle, mert lényegtelen, hogy a program elején mekkora tömbméretet adtunk meg. A 3. sorban pedig a léptetett indexeket felhasználva a tömb minden elemének egy véletlenszerű értéket adunk a megadott intervallumból. Apropó, ez melyik intervallum? … … … Számold ki!
Mi van akkor, ha ellenőrizni akarjuk, hogy a tömböt tényleg megfelelően töltöttük-e fel? Hátha elszúrtuk az intervallumot.
1
2
3
4
for( int i = 0; i < tomb.length; i++ )
{
System.out.print(tomb[i]+" ");
}
Ezt a programrészt már nem is kell nagyon magyarázni. Az 1. sor ciklusa segítségével végigmegyünk a tömb összes indexén. A 3. sorban pedig mindig kiíratjuk a tömb aktuális indexű (vagyis mindegyik) elemét úgy, hogy egy szóközt is hagyunk utána, hogy az elemek elkülönüljenek egymástól.
Hogy néz ki ez az egész egyben?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Tombfeltoltes
{
public static void main( String[] args )
{
// tömb deklarálása és méretének megadása
int[] tomb = new int[10];
// tömb feltöltése
for( int i = 0; i < tomb.length; i++ )
{
tomb[i] = (int)(Math.random()*100)+1;
}
// tömb elemeinek kiíratása
for( int i = 0; i < tomb.length; i++ )
{
System.out.print(tomb[i]+" ");
}
// extra sordobás
System.out.println();
}
}
Többdimenziós tömbök, avagy tömbök egy csokorban
A tömb, mint összetett adattípus az előző anyagokból már ismerős lehet. Míg a tömbök egy adatsort tartalmaznak, a többdimenziós tömbök pedig többet. A többdimenziós tömbök valójában tömbök tömbjei. A dimenziók száma elméletileg nincs korlátozva, gyakorlatilag 3 dimenziónál többel dolgozni nem feltétlenül praktikus.
Egy általános tömb deklarációja a következőképp néz ki:
// deklarálás és inicializálás, ami csak 0 értékekkel tölti fel a tömböt
int[] tomb = new int[10];
// deklarálás és azonnali kezdőérték adás
int[] tomb = {1,2,3,4,5,6,7,8,9,10};
// adott indexű elem kiválasztása
tomb[5]
Ez a többdimenziós tömbök esetén is hasonló, de mivel ezek tömbök tömbjei, ezért ezt formailag is jelezni kell.
Kétdimenziós tömbök
// kétdimenziós tömb deklarálása és inicializálása
int[][] tomb = new int[2][3];
// kétdimenziós tömb adott elemének kiválasztása
tomb[1][2]
Az előző deklarálás azt jelenti, hogy létrehozunk egy 2 sorból és 3 oszlopból álló kétdimenziós tömböt. A sorok és oszlopok sorszámozása (indexelése) itt is 0-val indul, mint általában a tömbök esetén. Mint már említettem, a többdimenziós tömb valójában tömbök tömbje, de formailag ez hogy néz ki? Nézzük meg egy konkrét példán keresztül:
int[][] tomb = { { 2,4,6 }, { 3,7,8 } };
Mit is jelent ez? Adott két sor (a két kicsi tömb darabszáma, ami a számokat tartalmazza) és adott 3 oszlop (ami a kis tömbökben lévő számok darabszámát jelenti). Láthatod, hogy a kis tömbökben lévő számok darabszáma megegyezik, ez nem véletlen. Valójában ez a szám az oszlopok száma. Hogy jobban látható legyen, átrendezem az előző példában szereplő tömb szerkezetét:
int[][] tomb = {
{ 2,4,6 },
{ 3,7,8 }
};
Így már egyértelműbb, hogy mit jelent a sorok és oszlopok száma. A két kis belső tömb jelenti a sorokat, egymás alá írva őket, valóban sorokat alkotnak. A bennük lévő elemek száma pedig kötött, mert ez jelenti az oszlopok számát. A két sort összefogó külső tömb határolóit direkt külön sorba írtam, hogy az ne zavarjon, de az is a struktúra része. Amikor hivatkozunk egy elemre (tomb[1][2]), akkor azt mondjuk meg, hogy az 1-es indexű kis tömbnek (a másodiknak) a 2-es oszlopában (a harmadikban) lévő 8-as elemre gondolunk. Ne feledd, a sor és oszlop indexelése is 0-val kezdődik.
A kétdimenziós tömbök kezeléséhez szinte minden esetben két egymásba ágyazott ciklusra van szükség, olyanokra, mint amilyeneket a rendezéseknél is láthattál. A külső ciklus a sorszámot, a belső az oszlopszámot lépteti. Nézzük meg, hogy néz ez ki:
1
2
3
4
5
6
7
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*10);
}
}
Ez a példa végigmegy a tömb összes elemén, és mindegyiket egy [0;9] intervallumból sorsolt számmal tölt fel. Láthatod, hogy van egy tömbelem kiválasztás (tomb[i][j]), ami az előzőleg ismertetett módon [sor][oszlop] választja ki az adott elemet. Mivel a későbbiekben nagy valószínűséggel mindig ugyanolyan nevű változókat használsz, ezért jó ha megjegyzed, hogy az i változóval jelölöd a sorokat, és j-vel az oszlopokat. Ez a későbbiekben fontos lesz, hogy tudd, melyik melyik.
A kiemelt sorban van igazából az érdekesség, ami elsőre furcsa lehet. A tömb i indexű elemének tömbmérete? Kétdimenziós tömbben a tömb deklarálása után az inicializáláskor meg kell határozni a tömb méretét. Így van ez az alap tömbök esetén is, és így van ez itt is. A különbség az, hogy itt külön kell beállítani a sorok és oszlopok számát. Először a sorok, utána az oszlopok számát. De akkor a tomb.length melyiket adja meg a kettő közül, és hogy kapjuk meg a másikat? Tisztázzunk akkor pár sarokpontot az ilyen tömbök kezelésével kapcsolatban
tomb.length; // sorok száma (a kis tömbök darabszáma)
tomb[1]; // az 1-es indexű sor elemei (2. sor tömbje)
tomb[i].length; // oszlopok száma (az i indexű tömbben lévő elemek száma)
tomb[3][2]; // tömbben tárolt elem, ami a 4. sor 3. oszlopában van
Az oszlopok számát miért egy i indexű sor méretéből kapjuk meg, miért nem fixen a 0 indexű sor méretéből? Azért, mert létezik egy speciális többdimenziós tömbtípus, melyet nagyon ritkán használunk, és ott eltérhet az egyes sorok (kis tömbök) mérete, így mindig az aktuális sor méretével dolgozzunk.
Kétdimenziós tömbök bejárása
az összes elem bejárása:
Ebben az esetben két ciklusra van szükség, amire már láttál példát a tömb feltöltésénél.
egy sor bejárása:
Ekkor elég csak egy konkrét soron végigmenni egyetlen ciklussal. Ebben a példában a 3. sor összes elemét írjuk ki egymás mellé. Ez a következőképp néz ki:
for( int j = 0; j < tomb[2].length; j++ )
{
System.out.print(tomb[2][j]+" ");
}
Ebben az esetben láthatjuk, hogy a tomb[2]-re hivatkozok fixen, több helyen is. Először a ciklus fejében, ahol a 2-es indexű (3.) sor elemeit akarom kiírni. Valamint a konkrét elem kiválasztásánál is látszik, hogy csak a 2-es indexű sor szerepel, de azon belül a j-vel végiglépkedek a sor összes elemén (oszlopán). Technikailag a j helyett itt i is lehetne ciklusváltozó, a program akkor is tökéletesen működne. Logikailag azért szoktam javasolni, hogy j legyen, mert akkor jobban rögzül, hogy a j az oszlopokat jelenti, és most csak az oszlop változik, a sor kötött.
egy oszlop bejárása:
Az előzőhöz hasonlóan itt is elég egyetlen ciklus, hiszen egyetlen oszlopon kell csak végigmenni. Ekkor az oszlop száma kötött és csak a sorszám változik. Ez így néz ki:
for( int i = 0; i < tomb.length; i++ )
{
System.out.println(tomb[i][4]);
}
Láthatod, hogy a ciklus fejében máshogy szerepel a futási feltétel, csak tomb.length szerepel, ami a sorok számát jelenti. A ciklusmagban pedig az adott elem kiválasztásakor a oszlopszám fix (jelen esetben a 4-es indexű 5. sor) és az sorszám az, ami változik, ezért használtam i ciklusváltozót.
Most már tetszőleges kétdimenziós tömböt be tudunk járni, jöhetnek az ezzel kapcsolatos feladatok. Az első feladat a tömb feltöltése, a többi feladatban pedig ezzel a tömbbel dolgoznánk.
Gyakorló feladatok
Tölts fel egy 3×5-ös kétdimenziós tömböt a [-10;30] intervallumból:
int[][] tomb = new int[3][5];
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*41)-10;
}
}
Írd ki a tömböt sorokba és oszlopokba rendezve:
int[][] tomb = new int[3][5];
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// egymás mellé írom ki egy sor elemeit
System.out.print(tomb[i][j]+" ");
}
// ha végeztem egy sor kiírásával, akkor új sort kezdek
System.out.println();
}
Írd ki a tömbben szereplő számok összegét:
int osszeg = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
osszeg = osszeg + tomb[i][j];
// vagy osszeg += tomb[i][j];
}
}
System.out.println("A tomb elemeinek osszege"+osszeg);
Írd ki a 2. sor összegét:
int osszeg = 0;
for( int j = 0; j < tomb[1].length; j++ )
{
osszeg = osszeg + tomb[1][j];
// vagy osszeg += tomb[1][j];
}
System.out.println("A 2. sor osszege"+osszeg);
Számold meg, hány negatív szám szerepel a tömbben:
int db = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
if( tomb[i][j] < 0 )
{
db++;
}
}
}
System.out.println("A tombben "+db+" negativ szam van.");
Számold meg, hány páros szám található a 3. oszlopban:
int db = 0;
for( int i = 0; i < tomb.length; i++ )
{
if( tomb[i][2] % 2 == 0 )
{
db++;
}
}
System.out.println("A tomb 3. oszlopaban "+db+" paros szam van.");
Írd ki, melyik a legkisebb elem a tömbben:Ez a feladat nem teljesen ugyanaz, mint amit a minimumkeresésnél láthattál. Arra remélem emlékszel, hogy a minimumnak a helyét, és nem az értékét tároljuk, mert a helyéből két dologra is válaszolhatunk, ezt most nem írnám le újra. De itt a hely nem egy index, hanem kettő: [oszlop][sor]
Két dolgot tehetsz. Vagy két változót használsz a hely tárolására (egyet a sornak, egyet az oszlopnak), vagy egy két elemű tömbben tárolod, valahogy így:
int[] min = new int[2];
min[0] = sor;
min[1] = oszlop;
Vagy tárolhatod két változóban is:
int minI = sor;
int minJ = oszlop;
Rád bízom melyiket használod, a lényeg, hogy helyesen tedd. Lássunk akkor példát a bonyolultabbra:
int[] min = new int[2];
// ebben a két sorban állítom be, hogy az első elem az első minimum
min[0] = 0;
min[1] = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// ha a tömb aktuális eleme kisebb, mint az eddigi minimum
// ahol a minimum elem sora min[0], oszlopa min[1]
if( tomb[i][j] < tomb[ min[0] ][ min[1] ] )
{
min[0] = i;
min[1] = j;
}
}
}
// na itt ne keverd össze a [ ] jeleket...
System.out.println("A tomb legkisebb eleme: "+tomb[min[0]][min[1]]);
Azért hasonlítsuk ezt össze azzal, ha két külön változóban tárolod a minimum elem sorát és oszlopát:
// ebben a két sorban állítom be, hogy az első elem az első minimum
int minI = 0;
int minJ = 0;
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
// ha a tömb aktuális eleme kisebb, mint az eddigi minimum
// ahol a minimum elem sora min[0], oszlopa min[1]
if( tomb[i][j] < tomb[minI][minJ] )
{
minI = i;
minJ = j;
}
}
}
// na itt ne keverd össze a [ ] jeleket...
System.out.println("A tomb legkisebb eleme: "+tomb[minI][minJ]);
Talán a két külön változó kicsit barátságosabb.
Ha igazán figyeltél az eddigiekben, kiszúrhattad, hogy más különbség is van a minimumkereséshez képest, azon kívül, hogy itt a minimum helyét értelemszerűen két számként tároljuk. Figyeld meg, honnan indulnak itt a ciklusok. Nem 1-től! A minimumkeresésnél emlékezhetsz, hogy az első (0 indexű) elem a legkisebb, ezért a ciklus 1-es indextől kezdődik, hogy önmagával már ne hasonlítsuk össze. Itt ezt nem tehetjük meg. Miért?
Ha a külső ciklusban az i változó 1-től indulna, akkor az első (0 indexű) sor teljesen kimaradna a vizsgálatból. Ha a belső ciklusban a j változó indulna 1-től, akkor pedig minden sor első eleme, vagyis a teljes első (0. indexű) oszlop maradna ki. Itt kénytelenek vagyunk az első minimumot önmagával is összehasonlítani, ami azért valljuk be, nem túl nagy veszteség. De ha nem így oldod meg, akkor súlyos hiba.
Háromdimenziós tömbök
Többdimenziós tömböket 3 dimenzió felett nem igazán használunk. A 3. dimenzióval még van értelme dolgozni, mondjuk térbeli koordináták, vagy képfeldolgozás esetén mondjuk egy RGB kód tárolása esetén. Ebben az esetben formailag így néz ki a tömbünk:
// háromdimenziós tömb deklarálása és inicializálása
int[][][] tomb = new int[4][5][2];
// háromdimenziós tömb adott elemének kiválasztása
tomb[1][2][1]
Itt a 3. dimenzió mondjuk mint egyfajta magasság értelmezhető térbeli pontok tárolása esetén. Színkódoknál pedig a 3 színkomponens értékét tárolhatjuk a tömbben. Ezekben az esetekben a tömb teljes bejárása értelemszerűen 3 ciklust jelent, de csak az első sorbeli magasságadatok bejárása is két ciklust igényel. Akkor van szükség egy ciklusra, ha a 3 dimenzióból 2 rögzített. Például az első sor második eleméhez tartozó pontok (a tomb[0][1] magasságoszlopa) bejárása esetén.
Fűrészfogas tömbök
Láthattad, hogy a kétdimenziós tömbök esetén az oszlopok száma minden esetben megegyezik. Ez azonban nem mindig van így. Megadható az is, hogy az egyes sorok változó (de megadásuk után fix) hosszúak legyenek. Ezt a szerkezetet fűrészfogas tömbnek is szokás nevezni. Ilyen szerkezetet nagyon speciális esetekben használunk, de a kezelése a fentiek alapján meglehetősen egyszerű. Lássuk hogyan deklaráljuk ezt:
// először csak a sorok számát adjuk meg
int[][] tomb = new int[3][];
// ezután használat előtt egyenként adjuk meg a sorok méreteit
tomb[0] = new int[5];
tomb[1] = new int[7];
tomb[2] = new int[3];
// töltsük fel a tömböt a [0;9] intervallumból
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
tomb[i][j] = (int)(Math.random()*10);
}
}
// írjuk ki a tömböt
for( int i = 0; i < tomb.length; i++ )
{
for( int j = 0; j < tomb[i].length; j++ )
{
System.out.print(tomb[i][j]+" ");
}
System.out.println();
}
Ismétlés;
Egyszerű változók:
char - karakter
byte - numerikus egész
short - numerikus egész
int - numerikus egész
long - numerikus egész
float - numerikus lebegőpont
double - numerikus lebegőpont
boolean - boolean
literálok; A literál nem más, mint a program szövegében direkt módon beleírt adat
egész...
valós...
logikai...
karakter...
szöveg...
null"
Nincsenek megjegyzések:
Megjegyzés küldése