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

Gábor Dénes Főiskola (IAI)

A programozás alapjai (Java) - VI. / 1

18. Tömbök

19. Rendezés, keresés, karbantartás

20. Vector és Collections osztályok

18. Tömbök1. A tömb általános fogalma

2. Egydimenziós tömb

3. A tömb szekvenciális feldolgozása

4. Gyűjtés

5. Kétdimenziós tömb

6. Többdimenziós tömb

7. A tömb átadása paraméterként

8. A program paraméterei

9. Feladat – Szavazatkiértékelés

A tömb általános fogalma

Azonos típusú elemek sorozata Az elemek száma előre rögzített Az elemek indexelhetők (sorszámozhatók)

1. 2. 3. ... 12.

12 15 14 22hőmérs

hőmérs[3]==14

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

Létrehozás

new <elemtípus> [<elemszám>]

Indexelés

<tömbAzonosító> [index]

Deklarálás

<elemtípus>[] <tömbAzonosító>; vagy

<elemtípus> <tömbAzonosító>[];

A tömb hossza

<tömbAzonosító>.length

Példákint[] iArray = new int[5];

for (int i=0; i<iArray.length; i++)

iArray[i] = i*10;0. 1. 2. 3. 4.

0 10 20 30 40 iArray

double[] dArray = new double[20];

for (int i=0; i<dArray.length; i++)

dArray[i] = Console.readDouble();

String[] sArray = new String[4];

sArray[0] = "Panama";

sArray[1] = "Peru";

sArray[2] = "Pápua";

0. 1. 2.

sArray

:String

Panama

:String

Pápua

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:

iArray1 = iArray2; // iArray1 == {10,20}, iArray2 == {10,20}

oArray = sArray; // oArray == {"Get Back","Let It Be"}

iArray2

0. 1. 2. 3.

1 3 5 7iArray1

Szintaktikailag helytelen értékadások:

sArray = iArray; // Egyik elemei objektumok,másiké primitívek

sArray = oArray; // Az Object-nek nem őse a String!

Feladat – SzövegekKérjünk be szövegeket a konzolról az üres szöveg végjelig. Ha nem tudunk már több szöveget tárolni, informáljuk erről a felhasználót! Végül írjuk ki a szövegeket először a bekérés sorrendjében, azután pedig visszafelé!

import extra.*;

public class Szovegek {

String[] szovegek = new String[100];

int nSzoveg = 0;

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

void kiirElore() {for (int i=0; i<nSzoveg; i++)

System.out.print(szovegek[i]+" ");System.out.println();

}void kiirVissza() {

for (int i=nSzoveg-1; i>=0; i--)System.out.print(szovegek[i]+" ");

System.out.println();}public static void main(String[ ] args) {

Szovegek szovegek = new Szovegek();szovegek.beker();szovegek.kiirElore();szovegek.kiirVissza();

Feladat – Dobás-statisztikaKét ember, Bush és Gates dobókockával versenyez: saját kockájukkal mindketten 10-szer dobnak, és amelyiküknek az átlaga jobb, az nyer. A dobásokat véletlenszám-generátorral szimuláljuk! A verseny végén írjuk ki mindkét versenyző nevét, és azt, hogy hány darab 1-es, 2-es ... 6-os dobásuk volt, valamint dobásaiknak átlagát!

DobásStatisztika

+main(...)

DobóKocka

-n: int = 6 {kocka oldalszáma}-tulaj: String-felül: int {aktuális dobás}-dobások: int[n+1] {index 1..n}

+DobóKocka(tulaj:String)+dobás(): int+átlag(): double+toString(): String

import extra.*;class DoboKocka {

private static int n = 6;private String tulaj;private int felul;private int[] dobasok = new int[n+1]; public DoboKocka(String tulaj) {

this.tulaj = tulaj; felul = 1; }

public int dobas() {felul=(int) (Math.random() * n + 1);dobasok[felul]++; // gyűjtésreturn felul; // a dobott értéket visszaadja

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

Létrehozás

new <elemtípus> [<méret1>][<méret2>]

Deklarálás

<elemtípus>[][] <tömbAzonosító>; vagy

<elemtípus> <tömbAzonosító>[][];

Kétdimenziós tömb

Indexelés

<tömbAzonosító> [index1][index2]

Primitív elemtípusú kétdimenziós tömb

int[][] szamok = new int[3][5];

0. 1. 2. 3. 4.

12 56 0 -9 26szamok[0]

1 53 0 19 2

2 7 0 -2 21

szamok[1]

szamok[2]

szamokszamok[1][3]

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]

:Ember

Referencia elemtípusú kétdimenziós tömb

Ember[][] versenyzok = new Ember[4];

versenyzok[0] = new Ember[3];

0. 1. 2.

versenyzok[0]

versenyzok[1]

versenyzok

versenyzok[0][0] = new Ember(...);

versenyzok[2]

versenyzok[3]

:Ember2

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

for (int i=0; i<tomb.length; i++)

System.out.print(tomb[i]+" ");

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

public class ProgParamTeszt {

for (int i=0; i<args.length; i++)

System.out.println(args[i]);}

Feladat – Program paraméter tesztKészítsen egy olyan programot, amely a program paramétereit kiírja a konzolra! Próbaként futtassa le a programot a következő három paraméterrel:java ProgParamTeszt Yellow Submarine Yesterday

19. Rendezés, keresés, karbantartás1. Rendezés

2. Keresés

3. Karbantartás

4. Primitív elemek rendezése, keresése

5. String objektumok rendezése, keresése

6. Saját osztályú objektumok rendezése, keresése

7. Szövegek rendezett karbantartása

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

Első lépés:

Legkisebb elem?

Minimumkiválasztásos rendezés

Második lépés:

Legkisebb elem?

Eddig rendezett

Minimumkiválasztásos rendezés (folyt.)

Harmadik lépés:

Legkisebb elem?

Eddig rendezett

Utolsó lépés:

Legkisebb?

Eddig rendezett

Egész 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):

Direkt rendezés

Finn Aladár

Zentai Béla

Cirok Emil

Murok Jenő

Bor Kázmér

Abafi Vilmos

1 2 3 4 5 6

Rendezés után (keresztnév szerint rendezett):

Indexsorozat (index szerint rendezett)

1 2 3 4 5 6

Fő sorozat (teljes név szerint rendezett)

Abafi Vilmos

Bor Kázmér

Cirok Emil

Finn Aladár

Murok Jenő

Zentai Béla

1 2 3 4 5 6

Rendezés előtt:

Indexes rendezés

Indexsorozat (keresztnév szerint rendezett)

4 6 3 5 2 1

Fő sorozat (teljes név szerint rendezett)

Abafi Vilmos

Bor Kázmér

Cirok Emil

Finn Aladár

Murok Jenő

Zentai Béla

1 2 3 4 5 6

Rendezés után:

Indexes rendezés (folyt.)

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

Objektum keresése

:AutoAHA001Skodafehér

:AutoBOT490

Fiatezüst

2 3 4 5

:AutoBAK900Mazda

:AutoKOS215Mazda

:AutoTIT111Mazda

:AutoZAB200Mazda

piros fehér fehér fehér

K?????

:AutoHasonlí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 konténer• beszúrás, törlés gyors• keresés lassú

Rendezett konténer• rendezett lista, keresés gyors• beszúrás, törlés, módosítás lassú

Van kulcs Az objektumok egyediek

Karbantartás esetei

Rendezetlen Rendezett

Van kulcs Rendezetlen, van kulcs Rendezett, van kulcs

Nincs kulcs Rendezetlen, nincs kulcs Rendezett, nincs kulcs

Nincs kulcs Lehet két azonos állapotú objektum

Felvitel (mindig az utolsó után):

... ...

1 2 ElemSzám

Új elem

ElemSzám = ElemSzám + 1

Rendezetlen konténer

Törlés:

... ...

1 2 ElemSzámi

ElemSzám = ElemSzám - 1

Rendezetlen konténer (folyt.)

Törlendő elem

Módosítás:

... ...

1 2 ElemSzámi

Módosított elem

Rendezetlen konténer (folyt.)

Felvitel:

... ...

1 ElemSzám

Új elem

ElemSzám = ElemSzám + 1

Rendezett konténer

Törlés:

... ...

1 ElemSzám

ElemSzám = ElemSzám - 1

Törlendő elem

Rendezett konténer (folyt.)

Módosítás:

Régi elem törlése + Új elem felvitele

Rendezett konténer (folyt.)

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!

PrimitivRendezett

+main(...)

Kontener

-tomb: int[1000]-size: int

+Kontener()+kiir()-rendez()+indexOf(elem:int): int

kontener

Osztálydiagram

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;

}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 rendezettKérjünk be a felhasználótól szövegeket az üres szöveg végjelig, majd írjuk ki őket ábécé szerint növekvő sorrendben! Ezután tegyük lehetővé, hogy a felhasználó szövegeket kereshessen a bevitt sorozatban: ha az általa megadott szöveg benne van a sorozatban, írjuk ki első előfordulásának indexét (nullától számozva), egyébként írjuk ki, hogy "Nincs ilyen szöveg"! Ha üres szöveget adnak meg, legyen vége a programnak!

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;

}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("Nincs ilyen szoveg");}

} // main} // StringRendezett

Saját típusú objektumok rendezése, keresése

Feladat – HordókeresésEgy borász különböző méretű henger alakú hordókba tölti borait. Egy hordóra jellemző annak átmérője és magassága (cm-ben), ezek együttesen meghatározzák a hordó kapacitását (literben). A borász a hordók feltöltése után sorba rendezi a hordókat, hogy így könnyebb legyen majd egy adott méretű, illetve kapacitású hordót megtalálni. Írjunk a borásznak egy olyan programot, amely segíti a hordók kiválasztásában!A program elején hozzuk létre a hordókat, majd keressünk a hordósorban adott méretű, illetve kapacitású hordókat!

(30,80)57

(70,100)385

(100,40)314(60,20)

(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

Hordókeresés – Együttműködési diagram

:HordoKereses :Kontener

:Hordo:Hordo

:HordoHordo(...)kapacitas()equals(...)compareTo(...)

Kontener()kiir()indexOf(kap)indexOf(hasonlitoHordo)

rendez()meretKereses()kapacitasKereses()

HordoKereses

main(...)

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

-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]+" ");

private void rendez() {

for (int i=0; i<=size-2; i++) {

int minIndex = i;

for (int j=i+1; j<=size-1; j++)

if (hordok[j].compareTo(hordok[minIndex])<0)minIndex = j;

if (i != minIndex) {

Hordo seged = hordok[i];

hordok[i] = hordok[minIndex];

hordok[minIndex] = seged;}

kapacitások összehasonlítása

i. és minIndex. elemcseréje

// 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éseint atmero, magassag;Hordo hasonlitoHordo;atmero = Console.readInt("\nAtmero: ");while (atmero!=0) {

hasonlitoHordo = new Hordo(atmero,Console.readInt("Magassag: "));

int index = kontener.indexOf(hasonlitoHordo);

if (index >= 0)System.out.println("Indexe: "+index);

elseSystem.out.println("Nincs ilyen elem");

atmero = Console.readInt("\nAtmero: ");}

// 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("Nincs ilyen hordo");}

public static void main(String[] args) {new HordoKereses();

}} // HordoKereses

20. Vector és Collections osztályok1. A konténer funkciói általában2. Vector osztály 3. Az equals metódus szerepe4. A konténer elhagyása az UML diagramról5. Interfészek – Collection, List, Comparable6. Collections osztály7. Feladat – Nobel díjasok8. Feladat – Városok9. Feladat – Autóeladás

A konténer funkciói általábanadd(element)remove(element)size()isEmpty()contains(element)get(i)

kliens :Konténer:AnyClass

:AnyClass

.((AnyClass)element).metódus

element

Object

AnyClass

+metódus

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

capacity()

initialCapacity capacityIncrement

0 1 2 3 4

:Ember :Ember :Ember :Ember :Ember size()

Vector emberek = new Vector(4,3);

for (int i=0; i<5; i++)

emberek.add(new Ember(...));

• Vector(initialCapacity: int, capacityIncrement: int)

• Vector(initialCapacity: int)

• Vector()

Konstruktorok (Vector)

• Vector(c: Collection)

• 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

• 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

• remove(element: Object): boolean

• remove(index: int) : Object

Törlések (Vector)

• removeAll(c: Collection): boolean

• retainAll(c: Collection): boolean

• clear()

• indexOf(obj: Object): int

• indexOf(element: Object, index: int): int

Keresések (Vector)

Feladat – Vector mintaPróbáljuk ki egy String objektumokat tároló vektor mű-ködését! Küldjünk a vektornak különböző üzeneteket!

• lastIndexOf(obj: Object): int

• lastIndexOf(obj: Object, index: int): int

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

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

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

Feladat – TörpeprogramEmberek neveit és magasságait szeretnénknyilvántartani. A nyilvántartásban két egyforma nevűember nem szerepelhet!• Kérjük be konzolról a hét törpe nevét és magasságát

(végjel: névnél Enter).• Listázzuk ki a törpéket a bevitel sorrendjében!• Keressünk meg egy adott nevű törpét, és írjuk ki a

magasságát!

Az equals metódus szerepe

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

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

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

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;

«interfész»java::util::Collection

size() : int isEmpty() : booleancontains() : booleanadd(element: Object) : boolean remove(element: Object): booleanequals(o: Object) : boolean containsAll(c: Collection): boolean addAll(c: Collection) : boolean removeAll(c: Collection) : booleanretainAll(c: Collection) : boolean clear()toArray() : Object[]toArray(a: Object[]) : Object[]iterator() : Iterator

«interfész»java::util::List

get(index: int) : Objectset(index: int, element: Object) : Objectadd(index: int, element: Object) remove (index: int) : Object addAll(index: int, c: Collection):boolean indexOf(o: Object) : intlastIndexOf(o: Object) : intlistIterator() : ListIteratorlistIterator(index: int) : ListIteratorsubList(fromIndex:int, toIndex:int) : List

java::util::Vector

Comparable interfész

Object

«interfész»Comparable

+compareTo(Object obj): int

String

+compareTo(Object obj): int...

A String hasonlítható

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

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::lang::Comparable

+compareTo(obj:Object): int

«interfész»java::util::Collection

size(): intisEmpty(): booleancontains(...):boolean…

A sort, min, max és binarySearch metódusoknak paraméterül átadott kollekció elemeinek implementálniuk kell a Comparable interfészt!

PéldáulVector szamok = new Vector(); // benne Integer elemek…

System.out.println(”min="+Collections.min(szamok));

System.out.println(”max="+Collections.max(szamok));

Collections.sort(szamok);

int index = Collections.binarySearch(szamok,

new Integer(Console.readInt("Keresendő: ")));

System.out.println("Indexe= "+index);

Collections.reverse(szamok);

Collections.shuffle(szamok);

Feladat – Valós számokKérjünk be tetszőleges sok valós számot 0 végjelig! Ezután írjuk ki

a számokat a bevitel sorrendjében! a számokat növekvő sorrendben! a legkisebb és a legnagyobb számot!

Végül keressünk meg egy számot a bevittek között!

A valós számokat be kell csomagolni!

import extra.*;

import java.util.*;

public class ValosSzamok {

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

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

System.out.println("Van ilyen szam, indexe: "+index);

} // main

} // ValosSzamok

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

Documents

Felhasználói felület, keresés

4. Keresés, rendezés egyszerű struktúrában (tömb)matha/adatstr_6ea.pdf · 4. Keresés, rendezés egyszerű struktúrában (tömb) 4.1. Keresés 4.1.1. Lineáris keresés A tömb

hét ismét megrendezésre kerül, amelyetKRESZ-tábla keresés, activity, térképes feladatok, szinonima keresés, számítógépes feladatok vártak ránk. Csapatunk „Agymenők”

Munkaerő keresés napjainkban

Tartalom - ISZEM I Internet: (keresés témák szerint) Internet: (keresés té-mák szerint) Fejlesztendő képességek, készségek A programok fejlesztik a rendszerező, megfigyelőképességet,

Keresés a WorldVentures kinálatában

Nem szakrendszerű oktatás kompetenciafejlesztő mód- szerekkel · ritmusok, rendezés, keresés, rekurzió illetve fájlkeze-lés használata. Gráfalgoritmusok, gráfbejárás,

A könyvtári keresés: Katalógusok és teljes szövegű adatbázisok

Dinamikus tömbök

Fejlesztői dokumentáció · Web viewAz adott algoritmushoz tartozó script egy osztály leírását és annak példányosítását tartalmazza. Az osztályszerkezetbe való rendezés

A CD-ROM a CompLex CD Jogtáron megszokott keresési funkciókra képes, azaz: szabad szavas keresés ,

Keresés a gyakorlatban az Információkeresés és –közlés c. tantárgyhoz

Emlő MR...Emlő MR - Indikációk • Legjobb indikációk –implantátum repedés keresés –okkult primer tumor keresés (+familiáris szűrés) –multifokalitás, bilateralitás

Shainin-kísérlettervezés - kkft.bme.hukkft.bme.hu/attachments/article/28/Shainin.pdf · 105 Shainin-kísérlettervezés Sokváltozós Alkatrész- Páronkénti diagram keresés

Program ozási módszerek Backtracking (Visszalépéses keresés) Általános bemutató

POZICIONÁLÁS - Sas István · Pozicionálás Átpozicionálás Újrapozicionálás Depozicionálás egyediség keresés a versenytársak közt űrkeresés, vagy alkalmazkodás a

Feladatmegoldási stratégiák Visszalépéses keresés II.alg1.elte.hu/downloads/eloadas/Strategia2.pdf · 2019-04-15 · Feladatmegoldási stratégiák Visszalépéses keresés

8. Rendezés - uni-obuda.hu

Objektivitás keresés a fizioterápiában

Intertextualitás...1. csoporttag: keresés a könyvtárban, katalógusok, kézikönyvek (könyvtári rész) 2. csoporttag: keresés a világhálón: elektronikus könyvtárak, dokumentumok