Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 1
18. Tömbök
19. Rendezés, keresés, karbantartás
20. Vector és Collections osztályok
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 2
18. Tömbök1. A tömb általános fogalma
2. Egydimenziós tömb
3. A tömb szekvenciális feldolgozása
4. Gyűjtés
5. Kétdimenziós tömb
6. Többdimenziós tömb
7. A tömb átadása paraméterként
8. A program paraméterei
9. Feladat – Szavazatkiértékelés
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 3
A tömb általános fogalma
Azonos típusú elemek sorozata Az elemek száma előre rögzített Az elemek indexelhetők (sorszámozhatók)
1. 2. 3. ... 12.
12 15 14 22hőmérs
hőmérs[3]==14
hó
Például:hőmérs: number[hó:1..12]
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 4
Egydimenziós tömb Javában
Referencia típusú változó
Elemtípus
• primitív
• referencia
• osztály
• tömb
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 5
Létrehozás
new <elemtípus> [<elemszám>]
Indexelés
<tömbAzonosító> [index]
Deklarálás
<elemtípus>[] <tömbAzonosító>; vagy
<elemtípus> <tömbAzonosító>[];
A tömb hossza
<tömbAzonosító>.length
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 6
Példákint[] iArray = new int[5];
for (int i=0; i<iArray.length; i++)
iArray[i] = i*10;0. 1. 2. 3. 4.
0 10 20 30 40 iArray
double[] dArray = new double[20];
for (int i=0; i<dArray.length; i++)
dArray[i] = Console.readDouble();
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 7
String[] sArray = new String[4];
sArray[0] = "Panama";
sArray[1] = "Peru";
sArray[2] = "Pápua";
0. 1. 2.
sArray
:String
Panama
:String
Peru
:String
Pápua
3.
null
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 8
Alapértelmezés szerinti kezdeti érték
nullaszerű elemek
Inicializáló blokk
<elemtípus>[] <tömbazonosító> =
{<érték1>, <érték2>, ...}Például:
int[] iArray = {0,10,20,30,40};
char[] maganhangzok =
{'a','e','i','o','u'};
boolean[] szep = {true,false};
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 9
Értékadási kompatibilitás tömbök között
t1=t2 megengedett, ha Primitív elemtípus esetén t1 és t2 elemtípusa
azonos; Referencia elemtípus esetén t2 elemtípusa t1
elemtípusával azonos, vagy annak leszármazottja.
Példa
int[] iArray1 = {1,3,5,7}, iArray2 = {10,20};
Object[] oArray = null;
String[] sArray = {"Get Back","Let It Be"};
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 10
Szintaktikailag helyes értékadások:
iArray1 = iArray2; // iArray1 == {10,20}, iArray2 == {10,20}
oArray = sArray; // oArray == {"Get Back","Let It Be"}
iArray2
0. 1.
10 20
0. 1. 2. 3.
1 3 5 7iArray1
Szintaktikailag helytelen értékadások:
sArray = iArray; // Egyik elemei objektumok,másiké primitívek
sArray = oArray; // Az Object-nek nem őse a String!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 11
Feladat – SzövegekKérjünk be szövegeket a konzolról az üres szöveg végjelig. Ha nem tudunk már több szöveget tárolni, informáljuk erről a felhasználót! Végül írjuk ki a szövegeket először a bekérés sorrendjében, azután pedig visszafelé!
import extra.*;
public class Szovegek {
String[] szovegek = new String[100];
int nSzoveg = 0;
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 12
void beker() {String szoveg;while (true) {
if (nSzoveg == szovegek.length) {System.out.println("Betelt");break;
}szoveg=Console.readLine(nSzoveg+1+". szöv:");if (szoveg.equals(""))
break;szovegek[nSzoveg] = szoveg;nSzoveg++;
}}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 13
void kiirElore() {for (int i=0; i<nSzoveg; i++)
System.out.print(szovegek[i]+" ");System.out.println();
}void kiirVissza() {
for (int i=nSzoveg-1; i>=0; i--)System.out.print(szovegek[i]+" ");
System.out.println();}public static void main(String[ ] args) {
Szovegek szovegek = new Szovegek();szovegek.beker();szovegek.kiirElore();szovegek.kiirVissza();
}}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 14
Feladat – Dobás-statisztikaKét ember, Bush és Gates dobókockával versenyez: saját kockájukkal mindketten 10-szer dobnak, és amelyiküknek az átlaga jobb, az nyer. A dobásokat véletlenszám-generátorral szimuláljuk! A verseny végén írjuk ki mindkét versenyző nevét, és azt, hogy hány darab 1-es, 2-es ... 6-os dobásuk volt, valamint dobásaiknak átlagát!
DobásStatisztika
+main(...)
DobóKocka
-n: int = 6 {kocka oldalszáma}-tulaj: String-felül: int {aktuális dobás}-dobások: int[n+1] {index 1..n}
+DobóKocka(tulaj:String)+dobás(): int+átlag(): double+toString(): String
2
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 15
import extra.*;class DoboKocka {
private static int n = 6;private String tulaj;private int felul;private int[] dobasok = new int[n+1]; public DoboKocka(String tulaj) {
this.tulaj = tulaj; felul = 1; }
public int dobas() {felul=(int) (Math.random() * n + 1);dobasok[felul]++; // gyűjtésreturn felul; // a dobott értéket visszaadja
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 16
public double atlag() {int osszeg=0, dobasSzam=0;for (int i=1; i<=n; i++) {
dobasSzam += dobasok[i];osszeg += dobasok[i]*i;
}return osszeg*1.0/dobasSzam;
}public String toString() {
String str=tulaj;for (int i=1; i<=n; i++)
str = str+" "+dobasok[i]; return str+" Atlag: "+atlag();}
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 17
public class DobasStatisztika {public static void main(String[ ] args) {
final int DOBASSZAM = 10;DoboKocka d1 = new DoboKocka("Bush ");DoboKocka d2 = new DoboKocka("Gates");for (int i=1; i<=DOBASSZAM; i++) {
d1.dobas();d2.dobas();
}System.out.println(d1);System.out.println(d2);
}}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 18
Létrehozás
new <elemtípus> [<méret1>][<méret2>]
Deklarálás
<elemtípus>[][] <tömbAzonosító>; vagy
<elemtípus> <tömbAzonosító>[][];
Kétdimenziós tömb
Indexelés
<tömbAzonosító> [index1][index2]
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 19
Primitív elemtípusú kétdimenziós tömb
int[][] szamok = new int[3][5];
0. 1. 2. 3. 4.
12 56 0 -9 26szamok[0]
1 53 0 19 2
2 7 0 -2 21
szamok[1]
szamok[2]
szamokszamok[1][3]
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 20
Referencia elemtípusú kétdimenziós tömb
Ember[][] versenyzok = new Ember[4][3];
0. 1. 2.
versenyzok[0]
versenyzok[1]
versenyzok
versenyzok[1][2]
:Ember
:Ember
:Ember
versenyzok[2]
versenyzok[3]
:Ember
1
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 21
Referencia elemtípusú kétdimenziós tömb
Ember[][] versenyzok = new Ember[4];
versenyzok[0] = new Ember[3];
0. 1. 2.
versenyzok[0]
versenyzok[1]
versenyzok
versenyzok[0][0] = new Ember(...);
versenyzok[2]
versenyzok[3]
:Ember2
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 22
A tömb átadása paraméterként
Feladat – Paraméter tesztÍrjunk eljárást, amely egy
int elemtípusú tömb elemeit kilistázza! Object elemtípusú tömb elemeit kilistázza!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 23
public class ParamTeszt {
static void kiir(int[] tomb) {
for (int i=0; i<tomb.length; i++)
System.out.print(tomb[i]+" ");
System.out.println();
}
static void kiir(Object[] tomb) {
for (int i=0; i<tomb.length; i++)
System.out.print(tomb[i]+" ");
System.out.println();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 24
public static void main(String[] args) {
int[] szamok1 = new int[2], szamok2 = new int[5];
szamok1[1] = 5;
szamok2[0] = 99; szamok2[4] = -5;
kiir(szamok1); kiir(szamok2);
String[] szerzok1 = {"Mozart","Wagner","Beethoven"};
StringBuffer[] szerzok2 = new StringBuffer[2];
szerzok2[0] = new StringBuffer("Monteverdi");
szerzok2[1] = new StringBuffer("Corelli");
kiir(szerzok1); kiir(szerzok2); }} Az aktuális paraméter tetszőleges hosszú tömb lehet!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 25
A program paraméterei
public class ProgParamTeszt {
public static void main(String[] args) {
for (int i=0; i<args.length; i++)
System.out.println(args[i]);}
}
Feladat – Program paraméter tesztKészítsen egy olyan programot, amely a program paramétereit kiírja a konzolra! Próbaként futtassa le a programot a következő három paraméterrel:java ProgParamTeszt Yellow Submarine Yesterday
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 26
19. Rendezés, keresés, karbantartás1. Rendezés
2. Keresés
3. Karbantartás
4. Primitív elemek rendezése, keresése
5. String objektumok rendezése, keresése
6. Saját osztályú objektumok rendezése, keresése
7. Szövegek rendezett karbantartása
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 27
Rendezés
Rendezés feltétele: elemek összehasonlíthatók
Összehasonlítás
• Primitív elemek: <, >, … hasonlító operátorokkal
• Objektumok: metódusokkal (compareTo()) Rendezési algoritmusok
• Minimumkiválasztásos, beszúrásos, buborékos rendezés, gyorsrendezés
• Direkt vagy indexes rendezés
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 28
...
Első lépés:
Legkisebb elem?
Minimumkiválasztásos rendezés
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 29
Második lépés:
Legkisebb elem?
Eddig rendezett
...
Minimumkiválasztásos rendezés (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 30
Harmadik lépés:
Legkisebb elem?
Eddig rendezett
...
Minimumkiválasztásos rendezés (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 31
Utolsó lépés:
Legkisebb?
Eddig rendezett
...
Minimumkiválasztásos rendezés (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 32
...
Egész rendezett
Minimumkiválasztásos rendezés (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 33
Abafi Vilmos
Bor Kázmér
Cirok Emil
Finn Aladár
Murok Jenő
Zentai Béla
1 2 3 4 5 6
Rendezés előtt (teljes név szerint rendezett):
Direkt rendezés
Finn Aladár
Zentai Béla
Cirok Emil
Murok Jenő
Bor Kázmér
Abafi Vilmos
1 2 3 4 5 6
Rendezés után (keresztnév szerint rendezett):
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 34
Indexsorozat (index szerint rendezett)
1 2 3 4 5 6
Fő sorozat (teljes név szerint rendezett)
Abafi Vilmos
Bor Kázmér
Cirok Emil
Finn Aladár
Murok Jenő
Zentai Béla
1 2 3 4 5 6
Rendezés előtt:
Indexes rendezés
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 35
Indexsorozat (keresztnév szerint rendezett)
4 6 3 5 2 1
Fő sorozat (teljes név szerint rendezett)
Abafi Vilmos
Bor Kázmér
Cirok Emil
Finn Aladár
Murok Jenő
Zentai Béla
1 2 3 4 5 6
Rendezés után:
Indexes rendezés (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 36
Keresés
Keresés feltétele: elemek azonosíthatók
Azonosítás
• Primitív elemek: ==, !=, … egyenlőségvizsgáló operátorokkal
• Objektumok: metódusokkal (equals()) Keresési algoritmusok
• Szekvenciális keresés
• Bináris keresés
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 37
Objektum keresése
6
:AutoAHA001Skodafehér
1
:AutoBOT490
Fiatezüst
2 3 4 5
:AutoBAK900Mazda
:AutoKOS215Mazda
:AutoTIT111Mazda
:AutoZAB200Mazda
piros fehér fehér fehér
K?????
Mazda
???
:AutoHasonlító objektum Mazda, a rendszám
első betűje K
auto.equals(hasonlitoAuto)?
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 38
Karbantartás
Karbantartás feltétele: elemek azonosíthatók Azonosítás: kulcs (egyedi!) Karbantartási műveletek
• Beszúrás (Felvitel)
• Törlés
• Módosítás Hatékonysági szempontok
• Gyorsaság
• Helyfoglalás
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 39
Rendezetlen konténer• beszúrás, törlés gyors• keresés lassú
Rendezett konténer• rendezett lista, keresés gyors• beszúrás, törlés, módosítás lassú
Van kulcs Az objektumok egyediek
Karbantartás esetei
Rendezetlen Rendezett
Van kulcs Rendezetlen, van kulcs Rendezett, van kulcs
Nincs kulcs Rendezetlen, nincs kulcs Rendezett, nincs kulcs
Nincs kulcs Lehet két azonos állapotú objektum
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 40
Felvitel (mindig az utolsó után):
... ...
1 2 ElemSzám
Új elem
ElemSzám = ElemSzám + 1
Rendezetlen konténer
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 41
Törlés:
... ...
1 2 ElemSzámi
...
ElemSzám = ElemSzám - 1
Rendezetlen konténer (folyt.)
Törlendő elem
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 42
Módosítás:
... ...
1 2 ElemSzámi
...
Módosított elem
Rendezetlen konténer (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 43
Felvitel:
... ...
1 ElemSzám
Új elem
ElemSzám = ElemSzám + 1
Rendezett konténer
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 44
Törlés:
... ...
1 ElemSzám
ElemSzám = ElemSzám - 1
Törlendő elem
Rendezett konténer (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 45
Módosítás:
Régi elem törlése + Új elem felvitele
Rendezett konténer (folyt.)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 46
Feladat – Primitív rendezett Kérjünk be a felhasználótól számokat 0 végjelig, majd írjuk ki a számokat értékük szerint növekvő sorrendben! Ezután tegyük lehetővé, hogy a felhasználó kereshessen számokat a bevitt számsorozatban: ha az általa megadott szám benne van a sorozatban, írjuk ki első előfordulásának indexét (nullától számozva), egyébként írjuk ki, hogy "Nincs ilyen szám"! Ha a megadott szám 0, legyen vége a programnak!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 47
PrimitivRendezett
+main(...)
Kontener
-tomb: int[1000]-size: int
+Kontener()+kiir()-rendez()+indexOf(elem:int): int
kontener
Osztálydiagram
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 48
import extra.*;
class Kontener {
private int[] tomb = new int[1000];
private int size=0;
public Kontener() {
int elem;
while ((size<tomb.length) && (elem =Console.readInt("Szam: "))!=0) {
tomb[size++] = elem;
}
rendez();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 49
public void kiir() { for (int i=0; i<size; i++)
System.out.print(tomb[i]+" ");System.out.println();
}
public int indexOf(int elem) { for (int i=0; i<size; i++) {
if (tomb[i] == elem)return i;
if (tomb[i] > elem)return -1;
}return -1;
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 50
private void rendez() {
for (int i=0; i<=size-2; i++) {
int minIndex = i;
for (int j=i+1; j<=size-1; j++)
if (tomb[j] < tomb[minIndex])
minIndex = j;
if (i != minIndex) {
int seged = tomb[i]; tomb[i] = tomb[minIndex];
tomb[minIndex] = seged;}
} }} // Kontener
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 51
public class PrimitivRendezett {public static void main(String[] args) {
Kontener kontener = new Kontener(); kontener.kiir();
int elem;while ((elem = Console.readInt("Ker. szam: "))!=0) {
int index = kontener.indexOf(elem); if (index >= 0)
System.out.println("Indexe: "+index);else
System.out.println("Nincs ilyen szam");}
}}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 52
String objektumok rendezése, keresése
A String osztály equals() és compareTo() metódusai:
boolean equals(Object anObject)
boolean equalsIgnoreCase(String str)
int compareTo(Object o)
int compareTo(String str)
int compareToIgnoreCase(String str)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 53
Feladat – String rendezettKérjünk be a felhasználótól szövegeket az üres szöveg végjelig, majd írjuk ki őket ábécé szerint növekvő sorrendben! Ezután tegyük lehetővé, hogy a felhasználó szövegeket kereshessen a bevitt sorozatban: ha az általa megadott szöveg benne van a sorozatban, írjuk ki első előfordulásának indexét (nullától számozva), egyébként írjuk ki, hogy "Nincs ilyen szöveg"! Ha üres szöveget adnak meg, legyen vége a programnak!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 54
import extra.*;
class Kontener {
private String[] tomb = new String[1000];
private int size=0;
public Kontener() {
String elem;
while ((size<tomb.length) && !(elem= Console.readLine("Szoveg: ")).equals("")) {
tomb[size++] = elem;
}
rendez();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 55
public void kiir() {for (int i=0; i<size; i++)
System.out.print(tomb[i]+" ");System.out.println();
}
public int indexOf(String elem) { for (int i=0; i<size; i++) {
if (tomb[i].compareTo(elem) == 0)return i;
if (tomb[i].compareTo(elem) > 0)return -1;
}return -1;
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 56
private void rendez() {for (int i=0; i<=size-2; i++) {
int minIndex = i;for (int j=i+1; j<=size-1; j++)
if (tomb[j].compareTo(tomb[minIndex])<0) minIndex = j;
if (i != minIndex) {String seged = tomb[i]; tomb[i] = tomb[minIndex];tomb[minIndex] = seged;
}}
} // rendez()} // Konténer
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 57
public class StringRendezett {public static void main(String[] args) {
Kontener kontener = new Kontener();kontener.kiir();
String elem; while (!(elem=Console.readLine
("Keresendo szoveg: ")).equals("")) {int index = kontener.indexOf(elem); if (index >= 0)
System.out.println("Indexe: "+index);else
System.out.println("Nincs ilyen szoveg");}
} // main} // StringRendezett
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 58
Saját típusú objektumok rendezése, keresése
Feladat – HordókeresésEgy borász különböző méretű henger alakú hordókba tölti borait. Egy hordóra jellemző annak átmérője és magassága (cm-ben), ezek együttesen meghatározzák a hordó kapacitását (literben). A borász a hordók feltöltése után sorba rendezi a hordókat, hogy így könnyebb legyen majd egy adott méretű, illetve kapacitású hordót megtalálni. Írjunk a borásznak egy olyan programot, amely segíti a hordók kiválasztásában!A program elején hozzuk létre a hordókat, majd keressünk a hordósorban adott méretű, illetve kapacitású hordókat!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 59
(30,80)57
(70,100)385
(100,40)314(60,20)
57
(30,70)49
(átmérő,magasság)kapacitás
(60,20)??
hasonlítóHordó
equals()?
Rendezés: compareTo(), azaz kapacitás szerint
Keresés: equals(), azaz pontos méret szerint
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 60
Hordókeresés – Együttműködési diagram
:HordoKereses :Kontener
:Hordo:Hordo
:HordoHordo(...)kapacitas()equals(...)compareTo(...)
Kontener()kiir()indexOf(kap)indexOf(hasonlitoHordo)
rendez()meretKereses()kapacitasKereses()
...
HordoKereses
main(...)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 61
Hordókeresés – Osztálydiagram
HordoKereses
HordoKereses()kapacitasKereses()meretKereses()+main(...)
Kontener
-hordok: Hordo[1000]-size: int
+Kontener()+kiir()-rendez()+indexOf(hordo): int+indexOf(kap): int+indexOf(kap,index):int
kontener
Hordo
-atmero: int-magassag: int
+Hordo(atmero, mag.)+kapacitas(): int+equals(hordo):boolean+compareTo(hordo):int+toString(): String
*
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 62
import extra.*;
class Hordo {
private int atmero, magassag; // cm-ben
public Hordo(int atmero, int magassag) {
this.atmero = atmero;
this.magassag = magassag;
}
public int kapacitas() { // literben
return (int)(Math.round(Math.pow(atmero/2.0,2) *Math.PI*magassag/1000));
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 63
public boolean equals(Hordo hordo) {return (hordo.atmero == atmero) &&
(hordo.magassag == magassag); }
public int compareTo(Hordo hordo) {return kapacitas()-hordo.kapacitas();
}
public String toString() {return "\nAtmero:"+Format.right(atmero,6)+
" Magassag:"+Format.right(magassag,6)+ " Kapacitas:"+Format.right(kapacitas(),8);
}} // Hordo
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 64
class Kontener {
private Hordo[] hordok = new Hordo[1000];
private int size=0;
public Kontener() {
int atmero;
while (size<hordok.length && (atmero=Console.readInt("\nAtmero: "))!= 0) {
hordok[size++] = new Hordo(atmero,Console.readInt("Magassag: "));
}
rendez();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 65
public void kiir() {
for (int i=0; i<size; i++)
System.out.print(hordok[i]+" ");
System.out.println();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 66
private void rendez() {
for (int i=0; i<=size-2; i++) {
int minIndex = i;
for (int j=i+1; j<=size-1; j++)
if (hordok[j].compareTo(hordok[minIndex])<0)minIndex = j;
if (i != minIndex) {
Hordo seged = hordok[i];
hordok[i] = hordok[minIndex];
hordok[minIndex] = seged;}
}}
kapacitások összehasonlítása
i. és minIndex. elemcseréje
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 67
// Adott méretű hordó keresése:
public int indexOf(Hordo hordo) {
for (int i=0; i<size; i++) {
if (hordok[i].equals(hordo))
return i;}return -1;
}
// Adott kapacitású hordó keresése elölrõl:
public int indexOf(int kap) {
return indexOf(kap,0);}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 68
// Adott kapacitású hordó keresése az adott indextől:
public int indexOf(int kap, int index) {
for (int i=index; i<size; i++) {
int iKap = hordok[i].kapacitas();
if (iKap == kap)
return i;
if (iKap > kap)
return -1;
}
return -1;
}
} // Kontener
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 69
public class HordoKereses {
private Kontener kontener;
public HordoKereses() {
kontener = new Kontener();
kontener.kiir();
meretKereses();
kapacitasKereses();
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 70
void meretKereses() { // Adott méretű hordók kereséseint atmero, magassag;Hordo hasonlitoHordo;atmero = Console.readInt("\nAtmero: ");while (atmero!=0) {
hasonlitoHordo = new Hordo(atmero,Console.readInt("Magassag: "));
int index = kontener.indexOf(hasonlitoHordo);
if (index >= 0)System.out.println("Indexe: "+index);
elseSystem.out.println("Nincs ilyen elem");
atmero = Console.readInt("\nAtmero: ");}
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 71
// Kapacitások keresése: void kapacitasKereses() {
int kap;while ((kap=Console.readInt("Ker. kapacitas: "))!=0) {
int index = kontener.indexOf(kap); if (index >= 0)
System.out.println("Indexe: "+index);else
System.out.println("Nincs ilyen hordo");}
}
public static void main(String[] args) {new HordoKereses();
}} // HordoKereses
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 72
20. Vector és Collections osztályok1. A konténer funkciói általában2. Vector osztály 3. Az equals metódus szerepe4. A konténer elhagyása az UML diagramról5. Interfészek – Collection, List, Comparable6. Collections osztály7. Feladat – Nobel díjasok8. Feladat – Városok9. Feladat – Autóeladás
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 73
A konténer funkciói általábanadd(element)remove(element)size()isEmpty()contains(element)get(i)
kliens :Konténer:AnyClass
:AnyClass
:AnyClass
.
.
.((AnyClass)element).metódus
element
Object
AnyClass
+metódus
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 74
Vector osztály Vektor = “változtatható méretű tömb” A vektor mérete az elemek hozzáadásával
automatikusan bővül A vektor elemei indexelhetők A vektor elemei rendezetlenek, lehetnek egyenlők
Keresések, törlések az equals() szerint Funkciók:
• beszúrások (add)• törlések (remove)• keresések (indexOf)
A Vector implementálja a Collection interfészt
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 75
A Vector bővítése
capacity()
initialCapacity capacityIncrement
0 1 2 3 4
:Ember :Ember :Ember :Ember :Ember size()
Vector emberek = new Vector(4,3);
for (int i=0; i<5; i++)
emberek.add(new Ember(...));
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 76
• Vector(initialCapacity: int, capacityIncrement: int)
• Vector(initialCapacity: int)
• Vector()
Konstruktorok (Vector)
• Vector(c: Collection)
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 77
• size(): int
• capacity(): int
• isEmpty(): boolean
Lekérdezések (Vector)
• get(index: int): Object
• contains(element: Object): boolean
• containsAll(c: Collection): boolean
• equals(obj: Object): boolean
• toString(): String
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 78
• setSize(newSize: int)
• set(index: int, element: Object): Object
Módosítások, bővítések (Vector)
• add(element: Object): boolean
• add(index: int, element: Object): boolean
• addAll(c: Collection): boolean
• addAll(index: int, c: Collection): boolean
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 79
• remove(element: Object): boolean
• remove(index: int) : Object
Törlések (Vector)
• removeAll(c: Collection): boolean
• retainAll(c: Collection): boolean
• clear()
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 80
• indexOf(obj: Object): int
• indexOf(element: Object, index: int): int
Keresések (Vector)
Feladat – Vector mintaPróbáljuk ki egy String objektumokat tároló vektor mű-ködését! Küldjünk a vektornak különböző üzeneteket!
• lastIndexOf(obj: Object): int
• lastIndexOf(obj: Object, index: int): int
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 81
// VectorMinta
import extra.*;
import java.util.*;
public class VectorMinta {
static void lista(String info,Vector v) {
System.out.println("\n"+info);
System.out.println("meret: "+v.size());
for (int i=0; i<v.size(); i++)
System.out.println(i+". "+v.get(i));
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 82
public static void main(String[] args) {
Vector v = new Vector();
v.add(new String("Marci"));
v.add(new String("Dani"));
v.add(new String("Peti"));
v.add(new String("Rudi"));
lista("4 elemu vektor",v); // Marci Dani Peti Rudi
if (v.contains("Peti")) { // true
System.out.print("Peti benne van, ");
System.out.println("indexe:"+v.indexOf("Peti"));
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 83
v.remove(2);
lista("2. torolve",v); // Marci Dani Rudi
v.remove("Rudi"); // a két Rudi egyenlő
lista("Rudi torolve",v); // Marci Dani
v.add(0,new String("Cili"));
v.add(1,new String("Marci"));
lista("Beszuras elore",v); // Cili Marci Marci Dani
int n=v.size();
System.out.println("\nUtolso ket objektum kiirasa");
System.out.println(v.get(n-2)+" "+v.get(n-1));
// Marci Dani
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 84
v.set(1,new String("Toni")); // Az eddigi 1. obj. elvész
lista("1. elem atirasa Toni-ra",v); // Cili Toni Marci Dani
Vector vv = new Vector(v);
lista("vv vektor:",vv); // Cili Toni Marci Dani
vv.clear();
lista("A vv vektor ures lett",vv); // (üres)
vv.add(new String("Marci"));
vv.add(new String("Lili"));
vv.addAll(v);
lista("Marci, Lili és a teljes v hozzáadása vv-hez",vv);
// Marci Lili Cili Toni Marci Dani
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 85
lista("v vektor:",v); // Cili Toni Marci Dani
if (vv.containsAll(v)) // true
System.out.println("\nvv tartalmazza v elemeit");
else
System.out.println("\nvv nem taralmazza v elemeit");
vv.retainAll(v);
lista("vv es v közös része:",vv);
//Marci Cili Toni Marci Dani
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 86
Feladat – TörpeprogramEmberek neveit és magasságait szeretnénknyilvántartani. A nyilvántartásban két egyforma nevűember nem szerepelhet!• Kérjük be konzolról a hét törpe nevét és magasságát
(végjel: névnél Enter).• Listázzuk ki a törpéket a bevitel sorrendjében!• Keressünk meg egy adott nevű törpét, és írjuk ki a
magasságát!
Az equals metódus szerepe
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 87
TorpeProgram – Együttműködési diagram
Ember()setMagassag()
main()
tp:TorpeProgram
:Ember
:Ember
:Ember
...
torpek:Vector
Vector()add(ember)contains(ember)get(poz)indexOf(keresettEmber)
equals()
getNev()
TorpeProgram
TorpeProgram() bevitel() lista() kereses()
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 88
TorpeProgram – Osztálydiagram
Vector
+Vector()
+add(Object): boolean
+contains(Object): boolean
+get(int): Object
+indexOf(Object): int
TorpeProgram
TorpeProgram()
bevitel()
lista()
kereses()
+main()
-nev: String
-magassag: int
Ember
+Ember(String,int)
+Ember(String)
+getNev(): String
+getMagassag():int
+setMagassag(int)
+equals(Object): bool.
+toString(): String
*torpek
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 89
class Ember {private String nev;private int magassag;public Ember(String nev, int magassag) {
this.nev = nev;this.magassag = magassag;
}public Ember(String nev) {
this(nev,0);}public String getNev() { return nev; }
public int getMagassag() { return magassag; }
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 90
public void setMagassag(int mag) { if (mag>0)
magassag = mag;} public boolean equals(Object obj) {return nev.equals(((Ember)obj).getNev());}public String toString() {
return Format.left(nev,10)+Format.right(magassag,3);}
} // Emberpublic class TorpeProgram {
private Vector torpek = new Vector();
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 91
void bevitel() { Ember torpe; String nev = Console.readLine("\nTorpe neve: ");while (!nev.equals("")) {
if (torpek.contains(torpe = new Ember(nev))) System.out.println("Van mar ilyen torpe!");
else {torpe.setMagassag(Console.readInt("magassag:"));torpek.add(torpe);
}nev = Console.readLine("Torpe neve: ");}
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 92
void lista1() { // Egyszerű lista, beépített módon
System.out.println("\nBeepitett lista:");
System.out.println(torpek);
}
void lista2() { // torpek listázása index szerint, toString()-gel
System.out.println("\nLista index szerint:");
for (int i=0; i<torpek.size(); i++) {
System.out.println(torpek.get(i));
}
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 93
void lista3() { // Listázás toString() nélkül
System.out.println("\nEgyéni lista:");
for (int i=0; i<torpek.size(); i++) {
Ember e = (Ember)(torpek.get(i));
System.out.println("Nev: "+e.getNev()+
" Magassag: "+e.getMagassag());
}
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 94
void kereses() { // Egy törpe megkeresése
System.out.println("\nKeresés:");
Ember keresettEmber = new Ember(
Console.readLine("Törpe neve: "));
int poz = torpek.indexOf(keresettEmber);
if (poz >= 0)
System.out.println("Van, magassága:"+
((Ember)(torpek.get(poz))).getMagassag());
else
System.out.println("Nincs ilyen");
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 95
// Vezérlés
public static void main(String[ ] args) {
TorpeProgram tp = new TorpeProgram();
tp.bevitel();
tp.lista1();
tp.lista2();
tp.lista3();
tp.kereses();
}
} // TorpeProgram
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 96
Konténer elhagyása az UML diagramról
-nev: String
-magassag: int
Ember
+Ember(String,int)
+Ember(String)
+getNev(): String
+getMagassag():int
+setMagassag(int)
+equals(Object): boolean
+toString(): String
TorpeProgram
TorpeProgram()
bevitel()
lista()
kereses()
+main()
*torpek
{Vector}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 97
Interfész
Egy interfészből nem lehet példányt létrehozni Az interfészek örökíthetők
Az interfész (interface) metódusfejeket definiál abból a célból, hogy valamely osztály azt a későbbiekben implementálja, megvalósítsa.
Értékadási kompatibilitás szempontjából az implementáció egyenértékű az örökléssel Pl.:Vector szamok = new Vector();Collection coll = szamok;
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 98
«interfész»java::util::Collection
size() : int isEmpty() : booleancontains() : booleanadd(element: Object) : boolean remove(element: Object): booleanequals(o: Object) : boolean containsAll(c: Collection): boolean addAll(c: Collection) : boolean removeAll(c: Collection) : booleanretainAll(c: Collection) : boolean clear()toArray() : Object[]toArray(a: Object[]) : Object[]iterator() : Iterator
«interfész»java::util::List
get(index: int) : Objectset(index: int, element: Object) : Objectadd(index: int, element: Object) remove (index: int) : Object addAll(index: int, c: Collection):boolean indexOf(o: Object) : intlastIndexOf(o: Object) : intlistIterator() : ListIteratorlistIterator(index: int) : ListIteratorsubList(fromIndex:int, toIndex:int) : List
java::util::Vector
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 99
Comparable interfész
Object
«interfész»Comparable
+compareTo(Object obj): int
String
+compareTo(Object obj): int...
A String hasonlítható
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 100
public final class String implements Comparable {
...
public int compareTo(Object o) {
return compareTo((String)o);
}
public int compareTo(String anotherString) {
...
}
}
Az interfész implementálása
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 101
Collections osztály
A Java kollekció keretrendszer része
A java.util csomagban található
Nem példányosítható
Statikus metódusai konténereken (kollekciókon listákon) értelmezett algoritmusok: rendezés, megfordítás, keverés, minimum- és maximumszámítás, bináris keresés
Bizonyos metódusok megkövetelik, hogy az elemek összehasonlíthatóak (Comparable) legyenek
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 102
java::util::Collections
+sort(list: List)
+reverse(list: List)
+shuffle(list: List)
+min(coll: Collection) : Object
+max(coll: Collection) : Object
+binarySearch(list: List, key: Object) : int
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 103
*
java::util:: Collections
+sort(list: List)+reverse(list: List)+shuffle(list: List)...
«interfész»java::lang::Comparable
+compareTo(obj:Object): int
«interfész»java::util::Collection
size(): intisEmpty(): booleancontains(...):boolean…
A sort, min, max és binarySearch metódusoknak paraméterül átadott kollekció elemeinek implementálniuk kell a Comparable interfészt!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 104
PéldáulVector szamok = new Vector(); // benne Integer elemek…
System.out.println(”min="+Collections.min(szamok));
System.out.println(”max="+Collections.max(szamok));
Collections.sort(szamok);
int index = Collections.binarySearch(szamok,
new Integer(Console.readInt("Keresendő: ")));
System.out.println("Indexe= "+index);
Collections.reverse(szamok);
Collections.shuffle(szamok);
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 105
Feladat – Valós számokKérjünk be tetszőleges sok valós számot 0 végjelig! Ezután írjuk ki
a számokat a bevitel sorrendjében! a számokat növekvő sorrendben! a legkisebb és a legnagyobb számot!
Végül keressünk meg egy számot a bevittek között!
A valós számokat be kell csomagolni!
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 106
import extra.*;
import java.util.*;
public class ValosSzamok {
public static void main(String[] args) {
Vector szamok = new Vector();
final double VEGJEL = 0;
double szam;
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 107
// Számok bekérése:
while (true) {
szam = Console.readDouble("Szam: ");
if (szam==VEGJEL)
break;
szamok.add(new Double(szam));
}
if (szamok.size()==0) {
System.out.println(”Egyetlen szamot sem adott meg!");
return;
}
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 108
// Számok kiírása egyenként:
for (int i=0; i<szamok.size(); i++)
System.out.print(szamok.get(i)+" ");
System.out.println();
// A vektor kiírása egyben, rendezés, újabb kiírás...
System.out.println("A szamok: "+szamok);
Collections.sort(szamok);
System.out.println("A szamok rendezve: "+szamok);
// Minimum- és maximumkeresés:
System.out.println("Legkisebb:"+Collections.min(szamok));
System.out.println("Legn.:"+Collections.max(szamok));
Gábor Dénes Főiskola (IAI)
A programozás alapjai (Java) - VI. / 109
// Egy szám keresése:
szam = Console.readDouble("Keresendo szam:");
int index = szamok.indexOf(new Double(szam));
if (index == -1)
System.out.println("Nincs ilyen szam");
else
System.out.println("Van ilyen szam, indexe: "+index);
} // main
} // ValosSzamok