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

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. A program paraméterei 9. Feladat – Szavazatkiértékelés

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]

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

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

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

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

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

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

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!

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;

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

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

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

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

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

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

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]

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]

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

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

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!

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

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!

A program paraméterei 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]); }

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

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

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

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

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

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

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

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

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:

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

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

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

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

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

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

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

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

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

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

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

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!

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

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

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;

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

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

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)

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!

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

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;

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

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

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!

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

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() ... HordoKereses main(...)

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 *

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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!

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

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

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

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

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 }

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!

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

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

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

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

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

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

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

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

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

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}

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;

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

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

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

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

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

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

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

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!

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

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

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

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