VI. Konténerek 18. Tömbök 19. Rendezés, keresés, karbantartás

Az előadások a következő témára: "VI. Konténerek 18. Tömbök 19. Rendezés, keresés, karbantartás"— Előadás másolata:

1 VI. Konténerek 18. Tömbök 19. Rendezés, keresés, karbantartás 20. Vector és Collections osztályok

2 18. Tömbök VI. Konténerek 1. 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. Parancssor-paraméter 9. Feladat – Szavazatkiértékelés

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 22 hőmérs hőmérs[3]==14 hó Például: hőmérs: number[hó:1..12]

4 Egydimenziós tömb Javában
Referencia típusú változó Elemtípus primitív referencia osztály tömb

5 Deklarálás Létrehozás Indexelés A tömb hossza
<elemtípus>[] <tömbAzonosító>; vagy <elemtípus> <tömbAzonosító>[]; Létrehozás new <elemtípus> [<elemszám>] Indexelés <tömbAzonosító> [index] A tömb hossza <tömbAzonosító>.length

6 Példák int[] iArray = new int[5];
for (int i=0; i<iArray.length; i++) iArray[i] = i*10; 0. 1. 2. 3. 4. 10 20 30 40 iArray double[] dArray = new double[20]; for (int i=0; i<dArray.length; i++) dArray[i] = Console.readDouble();

7 String[] sArray = new String[4]; sArray[0] = "Panama";
sArray[1] = "Peru"; sArray[2] = "Pápua"; 0. 1. 2. sArray :String Panama Peru Pápua 3. null

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};

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"};

10 Szintaktikailag helyes értékadások:
iArray2 0. 1. 10 20 2. 3. 1 3 5 7 iArray1 Szintaktikailag helyes értékadások: iArray1 = iArray2; // iArray1 == {10,20}, iArray2 == {10,20} oArray = sArray; // oArray == {"Get Back","Let It Be"} Szintaktikailag helytelen értékadások: sArray = iArray; // Egyik elemei objektumok,másiké primitívek sArray = oArray; // Az Object-nek nem őse a String!

11 public class Szovegek { String[] szovegek = new String[100];
Feladat – Szövegek Ké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;

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("")) szovegek[nSzoveg] = szoveg; nSzoveg++;

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--) public static void main(String[ ] args) { Szovegek szovegek = new Szovegek(); szovegek.beker(); szovegek.kiirElore(); szovegek.kiirVissza();

14 Feladat – Dobás-statisztika
Ké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 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

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és return felul; // a dobott értéket visszaadja

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();

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);

18 Kétdimenziós tömb Deklarálás Létrehozás Indexelés
<elemtípus>[][] <tömbAzonosító>; vagy <elemtípus> <tömbAzonosító>[][]; Létrehozás new <elemtípus> [<méret1>][<méret2>] Indexelés <tömbAzonosító> [index1][index2]

19 Primitív elemtípusú kétdimenziós tömb
int[][] szamok = new int[3][5]; 0. 1. 2. 3. 4. 12 56 -9 26 szamok[0] 1 53 19 2 7 -2 21 szamok[1] szamok[2] szamok szamok[1][3]

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 versenyzok[2] versenyzok[3] 1

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] :Ember 2

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!

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) {

24 Az aktuális paraméter tetszőleges hosszú tömb lehet!
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!

25 Parancssor-paraméter
Feladat – Program paraméter teszt Ké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 public class ProgParamTeszt { public static void main(String[] args) { for (int i=0; i<args.length; i++) System.out.println(args[i]); }

26 19. Rendezés, keresés, karbantartás
VI. Konténerek 19. Rendezés, keresés, karbantartás 1. 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

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

28 Minimumkiválasztásos rendezés
Első lépés: Legkisebb elem? ...

29 Minimumkiválasztásos rendezés (folyt.)
Második lépés: Legkisebb elem? ... Eddig rendezett

30 Minimumkiválasztásos rendezés (folyt.)
Harmadik lépés: Legkisebb elem? ... Eddig rendezett

31 Minimumkiválasztásos rendezés (folyt.)
Utolsó lépés: Legkisebb? ... Eddig rendezett

32 Minimumkiválasztásos rendezés (folyt.)
... Egész rendezett

33 Direkt rendezés Rendezés előtt (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 (teljes név szerint rendezett): 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):

34 Indexes rendezés Rendezés előtt:
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 Rendezés előtt:

35 Indexes rendezés (folyt.)
Indexsorozat (keresztnév 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 Rendezés után:

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

37 Mazda, a rendszám első betűje K
Objektum keresése 6 :Auto AHA001 Skoda fehér 1 BOT490 Fiat ezüst 2 3 4 5 BAK900 Mazda KOS215 TIT111 ZAB200 piros K????? ??? Hasonlító objektum Mazda, a rendszám első betűje K auto.equals(hasonlitoAuto)?

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

39 Rendezetlen, nincs kulcs
Karbantartás esetei Rendezetlen Rendezett Van kulcs Rendezetlen, van kulcs Rendezett, van kulcs Nincs kulcs Rendezetlen, nincs kulcs Rendezett, nincs kulcs 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 Nincs kulcs  Lehet két azonos állapotú objektum

40 Rendezetlen konténer Felvitel (mindig az utolsó után): Új elem ...
ElemSzám = ElemSzám + 1 ... 1 2 ElemSzám

41 Rendezetlen konténer (folyt.)
Törlés: Törlendő elem ElemSzám = ElemSzám - 1 ... 1 2 ElemSzám i

42 Rendezetlen konténer (folyt.)
Módosítás: Módosított elem 1 2 i ElemSzám ... ... ...

43 Rendezett konténer Felvitel: ... ... Új elem 1 ElemSzám
ElemSzám = ElemSzám + 1 ... ...

44 Rendezett konténer (folyt.)
Törlés: Törlendő elem ... 1 ElemSzám ElemSzám = ElemSzám - 1

45 Rendezett konténer (folyt.)
Módosítás: Régi elem törlése + Új elem felvitele

46 Primitív elemek rendezése, keresése
Feladat – Primitív rendezetlen Kérjünk be a felhasználótól számokat 0 végjelig, majd írjuk ki a számokat a bevitel sorrendjében! 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!

47 Osztálydiagram Kontener PrimitivRendezetlen -tomb: int[1000]
+main() Kontener -tomb: int[1000] -size: int +Kontener() +kiir() +indexOf(elem:int): int kontener

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; }

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; return -1; } // Kontener

50 public class PrimitivRendezetlen {
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"); }

51 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!

52 Osztálydiagram Kontener PrimitivRendezett -tomb: int[1000] -size: int
+main() Kontener -tomb: int[1000] -size: int +Kontener() +kiir() -rendez() +indexOf(elem:int): int kontener

53 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();

54 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;

55 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

56 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"); }

57 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)

58 Feladat – String rendezett
Ké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!

59 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();

60 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;

61 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

62 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

63 Saját típusú objektumok rendezése, keresése
Feladat – Hordókeresés Egy 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!

64 Rendezés: compareTo(), azaz kapacitás szerint
Keresés: equals(), azaz pontos méret szerint (30,80) 57 (70,100) 385 (100,40) 314 (60,20) (30,70) 49 (átmérő,magasság) kapacitás ?? hasonlítóHordó equals()?

65 Hordókeresés – Együttműködési diagram
:HordoKereses :Kontener :Hordo Hordo() kapacitas() equals() compareTo() Kontener() kiir() indexOf(kap) indexOf(hasonlitoHordo) rendez() meretKereses() kapacitasKereses()

66 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() +kapacitas(): int +equals(hordo):boolean +compareTo(hordo):int +toString(): String *

67 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));

68 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

69 class Kontener { private Hordo[] hordok = new Hordo[1000]; private int size=0; public Kontener() { int atmero, magassag; while (size<hordok.length && (atmero=Console.readInt("\nAtmero: "))!= 0) { hordok[size++] = new Hordo(atmero, Console.readInt("Magassag: ")); } rendez();

70 public void kiir() { for (int i=0; i<size; i++) System.out.print(hordok[i]+" "); System.out.println(); }

71 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. elem cseréje

72 // 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);

73 // 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; } } // Kontener

74 public class HordoKereses {
private Kontener kontener; public HordoKereses() { kontener = new Kontener(); kontener.kiir(); meretKereses(); kapacitasKereses(); }

75 void meretKereses() { // Adott méretű hordók keresése
int 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); else System.out.println("Nincs ilyen elem"); }

76 // 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

77 Szövegek rendezett karbantartása
Feladat – Karbantartás, rendezett Neveket szeretnénk nyilvántartani. Készítsünk olyan programot, amely lehetővé teszi a nevek rendezett karbantartását és listázását. Két egyforma név nem szerepelhet a nyilvántartásban. A következő funkciókat menüből lehet kérni: Név felvitele Név keresése Név törlése Névsor rendezetten

78 SortedStringContainer
Osztálydiagram KarbRendezett beszúrás() keresés() törlés() listázás() +main() nevek SortedStringContainer -array: String[] -capacity, size : int -current : int +SortedStringContainer(capacity) +SortedStringContainer() +capacity() : int +size(): int +isEmpty() : boolean +isFull() : boolean +contains(String str) : boolean +indexOf(String str) : int +add(String str) : boolean +remove(String str) : boolean +print()

79 import extra.*; class SortedStringContainer { private String[] array; // konténer tömb private int capacity; // konténer kapacitása private int size; // konténer aktuális mérete private int current; // keresés után felhasználható mutató

80 public SortedStringContainer(int capacity) {
this.capacity = capacity; size = 0; array = new String[capacity]; } public SortedStringContainer() { this(100); public int capacity() { return capacity; } public int size() { return size; } public boolean isEmpty() { return size == 0; } public boolean isFull() { return size == capacity; }

81 // Megmondja, van-e már ilyen elem. current az a
// mutató, ahol az elem van, vagy lenne: public boolean contains(String str) { for (current=0; current<size; current++) { if (array[current].compareTo(str) == 0) return true; if (array[current].compareTo(str) > 0) return false; }

82 // Visszaadja az elem indexét. -1, ha nincs.
// A contains keres a tömbben, és állítja current értékét. public int indexOf(String str) { if (contains(str)) return current; else return -1; }

83 // Beszúrás. A felette álló elemeket feljebb toljuk:
public boolean add(String str) { if (isFull()) return false; if (contains(str)) else { // current-et a contains adja for (int i=size; i>current; i--) array[i] = array[i-1]; array[current] = str; size++; return true; }

84 // Törlés. A törölt elemre húzzuk a felette álló elemeket:
public boolean remove(String str) { if (contains(str)) { size--; for (int i=current; i<size; i++) array[i] = array[i+1]; return true; } else return false;

85 // Elemek listázása: public void print() { for (int i=0; i<size; i++) System.out.println(array[i]); } } // SortedStringContainer

86 // Nevek rendezett karbantartása és listázása:
public class KarbRendezett { private SortedStringContainer nevek = new SortedStringContainer(20); void beszuras() { String nev = Console.readLine("Uj nev: "); if (nevek.isFull()) System.out.println("Nincs tobb hely"); else if (nevek.contains(nev)) System.out.println("Van mar ilyen nev"); else nevek.add(nev); }

87 void kereses() { String nev = Console.readLine("Keresendo nev: "); int n = nevek.indexOf(nev); if (n == -1) System.out.println("Nincs ilyen nev"); else System.out.println(n+". nev"); }

88 void torles() { String nev = Console.readLine("Torlendo nev: "); if (nevek.indexOf(nev)>=0) { if (Character.toUpperCase(Console.readChar ("Biztosan torolni akarja? (I/N) "))=='I') nevek.remove(nev); } else System.out.println("Nincs ilyen nev!");

89 void listazas() { System.out.println("Nevek:"); nevek.print(); } void menu() { char menu; do { System.out.print("\nU(j) K(eres) T(orol) L(ista) V(ege)? "); menu = Character.toUpperCase(Console.readChar());

90 switch (menu) { case 'U' : { beszuras(); break; } case 'K' : { kereses(); break; } case 'T' : { torles(); break; } case 'L' : { listazas(); break; } } } while (menu != 'V'); public static void main(String[] args) { new KarbRendezett().menu(); } // KarbRendezett

91 20. Vector és Collections osztályok
VI. Konténerek 20. Vector és Collections osztályok 1. A konténer funkciói általában 2. Vector osztály 3. Az equals metódus szerepe 4. A konténer elhagyása az UML diagramról 5. Interfészek – Collection, List, Comparable 6. Collections osztály 7. Feladat – Nobel díjasok 8. Feladat – Városok 9. Feladat – Autóeladás

92 A konténer funkciói általában
add(element) remove(element) size() isEmpty() contains(element) get(i) Object AnyClass +metódus :AnyClass kliens :Konténer :AnyClass . ((AnyClass)element).metódus element :AnyClass

93 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

94 A Vector bővítése Vector emberek = new Vector(4,3);
capacity() initialCapacity capacityIncrement 1 2 3 4 :Ember size() Vector emberek = new Vector(4,3); for (int i=0; i<5; i++) emberek.add(new Ember(...));

95 Konstruktorok (Vector)
Vector(initialCapacity: int, capacityIncrement: int) Vector(initialCapacity: int) Vector() Vector(c: Collection)

96 Lekérdezések (Vector)
size(): int capacity(): int isEmpty(): boolean get(index: int): Object contains(element: Object): boolean containsAll(c: Collection): boolean equals(obj: Object): boolean toString(): String

97 Módosítások, bővítések (Vector)
setSize(newSize: int) set(index: int, element: Object): Object add(element: Object): boolean add(index: int, element: Object): boolean addAll(c: Collection): boolean addAll(index: int, c: Collection): boolean

98 Törlések (Vector) remove(element: Object): boolean
remove(index: int) : Object removeAll(c: Collection): boolean retainAll(c: Collection): boolean clear()

99 Keresések (Vector) indexOf(obj: Object): int
indexOf(element: Object, index: int): int lastIndexOf(obj: Object): int lastIndexOf(obj: Object, index: int): int Feladat – Vector minta Próbáljuk ki egy String objektumokat tároló vektor mű- ködését! Küldjünk a vektornak különböző üzeneteket!

100 // 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)); }

101 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")); }

102 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

103 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

104 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 }

105 Az equals metódus szerepe
Feladat – Törpeprogram Emberek neveit és magasságait szeretnénk nyilvá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!

106 TorpeProgram – Együttműködési diagram
Ember() setMagassag() main() tp:TorpeProgram :Ember ... torpek:Vector Vector() add(ember) contains(ember) get(poz) indexOf(keresettEmber) equals() getNev() TorpeProgram TorpeProgram() bevitel() lista() kereses()

107 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

108 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; }

109 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); } // Ember public class TorpeProgram { private Vector torpek = new Vector();

110 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: ");

111 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));

112 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()); }

113 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"); }

114 // Vezérlés public static void main(String[ ] args) { TorpeProgram tp = new TorpeProgram(); tp.bevitel(); tp.lista1(); tp.lista2(); tp.lista3(); tp.kereses(); } } // TorpeProgram

115 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}

116 Interfész 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. Egy interfészből nem lehet példányt létrehozni Az interfészek örökíthetők É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;

117 java::util::Collection
«interfész» java::util::Collection size() : int isEmpty() : boolean contains() : boolean add(Object element) : boolean remove(Object element) : boolean equals(Object o): boolean containsAll(Collection c) : boolean addAll(Collection c) : boolean removeAll(Collection c) : boolean retainAll(Collection c) : boolean clear() toArray() : Object[] toArray(Object a[]) : Object[] iterator() : Iterator java::util::List get(int index) : Object set(int index, Object element) : Object add(int index, Object element) remove (int index) : Object addAll(int index, Collection c):boolean indexOf(Object o) : int lastIndexOf(Object o) : int listIterator() : ListIterator listIterator(int index) : ListIterator subList(int fromIndex, int toIndex) : List java::util::Vector

118 Comparable interfész A String hasonlítható «interfész» Comparable
Object «interfész» Comparable +compareTo(Object obj): int String ...

119 Az interfész implementálása
public final class String implements Comparable { ... public int compareTo(Object o) { return compareTo((String)o); } public int compareTo(String anotherString) {

120 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

121 java::util::Collections
+sort(List list) +reverse(List list) +shuffle(List list) +min(Collection coll): Object +max(Collection coll): Object +binarySearch(List list,Object key): int

122 * java::util:: Collections +sort(List list) +reverse(List list) +shuffle(List list) ... «interfész» java::lang:: Comparable +compareTo(Object obj): int java::util:: Collection size(): int isEmpty(): boolean contains(): boolean … A sort, min, max és binarySearch metódusoknak paraméterül átadott kollekció elemeinek implementálniuk kell a Comparable interfészt!

123 Például Vector 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);

124 A valós számokat be kell csomagolni!
Feladat – Valós számok Ké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!

125 import extra.*; import java.util.*; public class ValosSzamok { public static void main(String[] args) { Vector szamok = new Vector(); final double VEGJEL = 0; double szam;

126 // 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;

127 // 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));

128 // 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