Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

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

Hasonló előadás


Az előadások a következő témára: "Java - VI. / 1 18.Tömbök 19. Rendezés, keresés, karbantartás 20.Vector és Collections osztályok."— Előadás másolata:

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

2 Java - VI. / Tömbök 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 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) hőmérs hőmérs[3]==14 hó Például: hőmérs: number[hó:1..12]

4 Java - VI. / 4 Egydimenziós tömb Javában  Referencia típusú változó  Elemtípus primitív referencia osztály tömb

5 Java - VI. / 5 Létrehozás new [ ] Indexelés [index] Deklarálás [] ;vagy []; A tömb hossza.length

6 Java - VI. / 6 Példák int[] iArray = new int[5]; for (int i=0; i

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

8 Java - VI. / 8 Alapértelmezés szerinti kezdeti érték nullaszerű elemek Inicializáló blokk [] = {,,...} Például: int[] iArray = {0,10,20,30,40}; char[] maganhangzok = {'a','e','i','o','u'}; boolean[] szep = {true,false};

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

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

11 Java - VI. / 11 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 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++; }

13 Java - VI. / 13 void kiirElore() { for (int i=0; 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(); }

14 Java - VI. / 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... 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

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

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

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

18 Java - VI. / 18 Létrehozás new [ ][ ] Deklarálás [][] ; vagy [][]; Kétdimenziós tömb Indexelés [index1][index2]

19 Java - VI. / 19 Primitív elemtípusú kétdimenziós tömb int[][] szamok = new int[3][5]; szamok[0] szamok[1] szamok[2] szamok szamok[1][3]

20 Java - VI. / 20 Referencia elemtípusú kétdimenziós tömb Ember[][] versenyzok = new Ember[4][3]; versenyzok[0] versenyzok[1] versenyzok versenyzok[1][2] :Ember versenyzok[2] versenyzok[3] :Ember 1

21 Java - VI. / 21 Referencia elemtípusú kétdimenziós tömb Ember[][] versenyzok = new Ember[4]; versenyzok[0] = new Ember[3]; versenyzok[0] versenyzok[1] versenyzok versenyzok[0][0] = new Ember(...); versenyzok[2] versenyzok[3] :Ember 2

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

23 Java - VI. / 23 public class ParamTeszt { static void kiir(int[] tomb) { for (int i=0; i

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

25 Java - VI. / 25 Parancssor-paraméter public class ProgParamTeszt { public static void main(String[] args) { for (int i=0; i

26 Java - VI. / 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 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

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

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

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

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

32 Java - VI. / Egész rendezett Minimumkiválasztásos rendezés (folyt.)

33 Java - VI. / 33 Abafi Vilmos Bor Kázmér Cirok Emil Finn Aladár Murok Jenő Zentai Béla 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 Rendezés után (keresztnév szerint rendezett):

34 Java - VI. / 34 Indexsorozat (index szerint rendezett) 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: Indexes rendezés

35 Java - VI. / 35 Indexsorozat (keresztnév szerint rendezett) 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: Indexes rendezés (folyt.)

36 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

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

38 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

39 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 RendezetlenRendezett Van kulcsRendezetlen, van kulcsRendezett, van kulcs Nincs kulcsRendezetlen, nincs kulcsRendezett, nincs kulcs  Nincs kulcs  Lehet két azonos állapotú objektum

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

41 Java - VI. / 41 Törlés:... 12ElemSzámi... ElemSzám = ElemSzám - 1 Rendezetlen konténer (folyt.) Törlendő elem

42 Java - VI. / 42 Módosítás:... 12ElemSzámi... Módosított elem Rendezetlen konténer (folyt.)

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

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

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

46 Java - VI. / 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 Java - VI. / 47 PrimitivRendezetlen +main() Kontener -tomb: int[1000] -size: int +Kontener() +kiir() +indexOf(elem:int): int kontener Osztálydiagram

48 Java - VI. / 48 import extra.*; class Kontener { private int[] tomb = new int[1000]; private int size=0; public Kontener() { int elem; while ((size

49 Java - VI. / 49 public void kiir() { for (int i=0; i

50 Java - VI. / 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 Java - VI. / 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 Java - VI. / 52 PrimitivRendezett +main() Kontener -tomb: int[1000] -size: int +Kontener() +kiir() -rendez() +indexOf(elem:int): int kontener Osztálydiagram

53 Java - VI. / 53 import extra.*; class Kontener { private int[] tomb = new int[1000]; private int size=0; public Kontener() { int elem; while ((size

54 Java - VI. / 54 public void kiir() { for (int i=0; i elem) return -1; } return -1; }

55 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 59 import extra.*; class Kontener { private String[] tomb = new String[1000]; private int size=0; public Kontener() { String elem; while ((size

60 Java - VI. / 60 public void kiir() { for (int i=0; i 0) return -1; } return -1; }

61 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 64 (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

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

66 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 69 class Kontener { private Hordo[] hordok = new Hordo[1000]; private int size=0; public Kontener() { int atmero, magassag; while (size

70 Java - VI. / 70 public void kiir() { for (int i=0; i

71 Java - VI. / 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 Java - VI. / 72 // Adott méretű hordó keresése: public int indexOf(Hordo hordo) { for (int i=0; i

73 Java - VI. / 73 // Adott kapacitású hordó keresése az adott indextől: public int indexOf(int kap, int index) { for (int i=index; i kap) return -1; } return -1; } } // Kontener

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

75 Java - VI. / 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"); atmero = Console.readInt("\nAtmero: "); }

76 Java - VI. / 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 Java - VI. / 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 Java - VI. / 78 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 0) return false; } return false; }

82 Java - VI. / 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 Java - VI. / 83 // Beszúrás. A felette álló elemeket feljebb toljuk: public boolean add(String str) { if (isFull()) return false; if (contains(str)) return false; 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 Java - VI. / 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

85 Java - VI. / 85 // Elemek listázása: public void print() { for (int i=0; i

86 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 92 A konténer funkciói általában add(element) remove(element) size() isEmpty() contains(element) get(i) kliens:Konténer :AnyClass ((AnyClass)element).metódus element Object AnyClass +metódus

93 Java - VI. / 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 Java - VI. / 94 A Vector bővítése capacity() initialCapacitycapacityIncrement :Ember size() Vector emberek = new Vector(4,3); for (int i=0; i<5; i++) emberek.add(new Ember(...));

95 Java - VI. / 95 Vector(initialCapacity: int, capacityIncrement: int) Vector(initialCapacity: int) Vector() Konstruktorok (Vector) Vector(c: Collection)

96 Java - VI. / 96 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

97 Java - VI. / 97 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

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

99 Java - VI. / 99 indexOf(obj: Object): int indexOf(element: Object, index: int): int Keresések (Vector) 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! lastIndexOf(obj: Object): int lastIndexOf(obj: Object, index: int): int

100 Java - VI. / 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

101 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 105 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! Az equals metódus szerepe

106 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 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: "); }

112 Java - VI. / 112 void lista3() { // Listázás toString() nélkül System.out.println("\nEgyéni lista:"); for (int i=0; i

114 Java - VI. / 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 Java - VI. / 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 Java - VI. / 116 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;

117 Java - VI. / 117 «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 «interfész» 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 Java - VI. / 118 Comparable interfész Object «interfész» Comparable +compareTo(Object obj): int String +compareTo(Object obj): int... A String hasonlítható

119 Java - VI. / 119 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

120 Java - VI. / 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 - VI. / 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 - VI. / 122 * java::util:: Collections +sort(List list) +reverse(List list) +shuffle(List list)... «interfész» java::lang:: Comparable +compareTo(Object obj): int «interfész» 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 Java - VI. / 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 Java - VI. / 124 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 Java - VI. / 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 Java - VI. / 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 Java - VI. / 127 // Számok kiírása egyenként: for (int i=0; i

128 Java - VI. / 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


Letölteni ppt "Java - VI. / 1 18.Tömbök 19. Rendezés, keresés, karbantartás 20.Vector és Collections osztályok."

Hasonló előadás


Google Hirdetések