Java forráskód - címke - Oldal 10 a 13-ből

Hány éves a kapitány?

2023. január 1.2018. március 22. Szerző: Kaczur Sándor

A problémamegoldó, logikus gondolkodásra nevelő képzések anyagában, illetve felvételi feladatsorokban is sokszor megtalálható – többféle változatban is.

Lássunk egyet a népszerű „Hány éves a kapitány?” típusú feladatok közül!

Három elefántot kell berakodnunk – szólt a hajóskapitány az első tiszthez.
És hány évesek ezek az elefántok? – kérdezte az első tiszt.
Mindegyik elmúlt már két éves és életkoraik szorzata 2450 – volt a válasz.
Hát életkoraik összege?
Azt fölösleges elárulnom, mert abból még nem tudnád megállapítani életkorukat – mondta a kapitány, majd hozzátette: Az egyikük idősebb nálam.
Akkor már tudom, hogy hány évesek az elefántok – mondta az első tiszt.

Feltéve, hogy tényleg tudta; … hány éves a kapitány?

Hogyan használhatnánk a feladat megoldásához programozáshoz kötődő ismereteinket?

Állítsunk elő olyan három szorzótényezőt, amelyek szorzata 2450 és egyben írassuk ki az összegüket is a konzolra!

public class Kapitany {

public static void main(String[] args) {

for(int i=3; i<=100; i++)

for(int j=i; j<=100; j++)

for(int k=j; k<=100; k++)

if(i*j*k==2450)

System.out.println(

i+"*"+j+"*"+k+"=2450\t"+i+"+"+j+"+"+k+"="+(i+j+k));

}

Az i, j, k a három elefánt életkorát jelöli. Mivel mindegyik elmúlt két éves (és feltételezzük, hogy életkoraik egész számmal kifejezhetők), így i=3-ról indul. Az elefántok lehetnek egyidősek, ezért j=i-ről és k=j-ről indul. Nincs kizárt életkor, így a változók léptethetők egyesével. Az i, j, k monoton növekvő sorozatot alkot, ezért a kiírásban nem lesznek olyan sorok, amelyek csupán a szorzótényezők sorrendjében térnek el. Durva felső becslés a 100, hiszen az elefántok általában 60-70 évig élnek. Eredményül ezt kapjuk:

5*5*98=2450 5+5+98=108

5*7*70=2450 5+7+70=82

5*10*49=2450 5+10+49=64

5*14*35=2450 5+14+35=54

7*7*50=2450 7+7+50=64

7*10*35=2450 7+10+35=52

7*14*25=2450 7+14+25=46

Az eredményből milyen következtetés(eke)t lehet levonni és mi a megoldás?

Az egyszer előforduló összegeket ki kell zárni, mert abból az első tiszt tudná az elefántok életkorát. Többször előforduló összegként marad a 64. Tehát az elefántok lehetnek 5, 10, 49, illetve 7, 7, 50 évesek. Mivel a kapitánynál idősebb az egyik elefánt, így a kapitány nem lehet 48 éves vagy fiatalabb (mert ekkor nem lenne egyértelmű az életkora), illetve nem lehet 50 éves vagy idősebb (mert ekkor nem lenne nála idősebb elefánt). Tehát a kapitány 49 éves.

(Másképpen megközelítve: a 2450 prímtényezős felbontása 2*5²*7², amiből ugyanezekre a következtetésekre juthatunk.)

A feladat további változatai

Egy hajó hosszának, az árbóc magasságának, a kapitány kisfia életkorának és a kapitány életkorának szorzata 303335. Hány éves a kapitány?
A kapitány most kétszer annyi idős, mint a hajója volt akkor, amikor a kapitány kétszer volt annyi idős, mint most a hajója. A kapitány és a hajója összesen 70 éves. Hány éves a kapitány?
A Fekete Kalóz néven elhíresült kalózkapitány egyik sikeres kalandja után kiszámíttatta saját maga és kisfia életkorának, valamint hajója hosszának a szorzatát. Az eredmény 26 159 lett, amelyet mint szerencseszámot egy medálra vésetett és mindig a nyakában hordott. Hány éves a kapitány? (A hajóhosszt méterekben mérték, és a mérőszám egész szám!)
Te vezeted az utasszállító repülőt. Budapesten felszáll 11 utas. Bécsben leszáll 5 és felszáll 9. Párizsban 1 kivételével mindenki leszáll. Hány éves a kapitány?
A kapitány hajója most 40 éves. Kétszer annyi idős, mint amennyi a kapitány volt akkor, amikor a hajó annyi idős volt, mint a kapitány most. Hány éves a kapitány?

A bejegyzéshez tartozó forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek alkalmához kötődik.

Ajánlott irodalom

Aki kedvet kapott és beszerezne néhány könyvet – tele érdekes, gondolkodtató, kreatív, logikai feladatokkal – ajánlom az alábbiakat:

Katona, R. (szerk): Logikai egypercesek – az elme játékai, 2. kiadás, DFT-Hungária Könyvkiadó, Budapest, 2006, ISBN 963 9473 55 3
Róka, S.: 2×2 néha 5? – Paradoxonok, hibás bizonyítások, Tóth Könyvkereskedés és Kiadó Kft., Debrecen, 2008, ISBN 963 5965 24 3
Károlyi, Zs.: Csak logIQsan!, 2. javított kiadás, Typotex Elektronikus Kiadó Kft., Budapest, 2017, ISBN 963 279 693 5
Róka, S.: Egypercesek – Feladatok matematikából 14-18 éveseknek, Tóth Könyvkereskedés Kft., Debrecen, 1997
G. Nagy, L.: A világ legújabb logikai rejtvényei, Magyar Könyvklub, H. n., 2001, ISBN 963 547 512 8

Haladóknak ajánlom

Smullyan, R.: A hölgy vagy a tigris? – és egyéb logikai feladatok, 2. javított kiadás, Typotex Kiadó Kft., Budapest, 2002, ISBN 963 7546 63 4
Smullyan, R.: Mi a címe ennek a könyvnek? – Drakula rejtélye és más logikai feladványok, Typotex Elektronikus Kiadó Kft., Budapest, 1996, ISBN 963 7546 64 2
Shasha, D.: Dr. Ecco talányos kalandjai, Typotex Kiadó – SHL Hungary Kft., 2000, ISBN 963 9132 72 1

Nemzetközi Pi nap

2024. március 17.2018. március 14. Szerző: Kaczur Sándor

A Pi-t ( $π$ ) mindenki ismeri. Talán sokaknak kedvenc története is van a $π$ -vel kapcsolatosan, amelyet iskolában vagy utazásai alatt szerzett. A $π$ Euklidesz geometriájában a kör kerületének és átmérőjének arányát jelöli. A $π$ irracionális szám, azaz végtelen, nem szakaszos tizedestört; másképpen számjegyei között nincs ismétlődés. A $π$ értékével a hétköznapokban 3,14-dal szokás számolni, de a tudomány területén ennél sokkal pontosabb közelítést szokás alkalmazni. A $π$ közelítése az informatikának köszönhetően akár több millió tizedesjegyig is lehetséges (például: S. Memphill: Pi to 1,000,000 places).

A nemzetközi Pi nap alkalmából (március 14) megvalósítottunk néhány – végtelen összeggel és szorzattal – $π$ közelítésre való képletet, algoritmust Java nyelven.

1. Viète-féle sor

private static void megold1() { //Viète-féle sor

double p=1, pi=1;

for(int i=11; i>1; i--) {

p=2;

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

p=2+Math.sqrt(p);

p=Math.sqrt(p);

pi=pi*p/2;

}

pi*=Math.sqrt(2)/2;

pi=2/pi;

System.out.println(pi);

}

A módszer néhány eredménye: i=5 esetén 3.140331156954752 (2 tizedesjegyre pontos), i=10-nél 3.1415914215112 (5 tizedesjegyre pontos), i=11 esetén 3.1415923455701176 (6 tizedesjegyre pontos).

2. Leibniz-féle sor

public static void megold2() { //Leibniz-féle sor

double s=0;

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

s+=Math.pow(-1, i)/(2*i+1);

double pi=s*4;

System.out.println(pi);

}

A módszer néhány eredménye: a 24. lépéstől stabil 1 tizedesjegyre, a 626. lépéstől stabil 2. tizedesjegyre, a 2453. lépéstől stabil 3 tizedesjegyre (hiszen alternál).

3. Wallis-formula

public static void megold3() { //Wallis-formula

double p=1;

for(int i=2; i<=17000; i+=2)

p*=(1.0*i/(i-1)*(1.0*i/(i+1)));

double pi=p*2;

System.out.println(pi);

}

A módszer néhány eredménye: A 38. lépéstől 1, a 986. lépéstől 2, a 2650. lépéstől 3, a 16954. lépéstől már 4 tizedesjegyre pontos.

4. Csebisev-sor

private static void megold8() { //Csebisev-sor, V1

double s=0;

for(int k=0; k<=20; k++)

s+=(Math.pow(-1, k)*Math.pow(Math.sqrt(2)-1, 2*k+1))/(2*k+1);

double pi=s*8;

System.out.println(pi);

}

A módszer k=10-re már 8 tizedesjegyig pontos.

A bejegyzéshez tartozó teljes forráskódot – további 8 közelítő módszer implementációjával együtt – ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek alkalmához kötődik.

Optikai csalódások

2023. január 1.2018. február 19. Szerző: Kaczur Sándor

A grafikus felülettel rendelkező Java programok (Swing, FX, webkomponensek, HTML+CSS) fejlesztése során igény adódhat arra, hogy a GUI komponensek saját beépített rajzoló/renderelő képességét felülírjuk/-definiáljuk, hogy egy-egy nyomógomb, menüpont, rádiógomb másképpen nézzen ki. Léteznek beépített rajzoló funkciók is.

Ha például grafikont kell beilleszteni egy alkalmazásba, akkor használjunk és igényeink szerint szabjunk testre egy JFreeChart csomagbeli grafikont, illetve előfordulhat, hogy találhatunk egy olyat a JFreeChart Demo-ban, ami éppen megfelel a megrendelő igényeinek.

Persze a műfaj nem ér itt véget. Időnként kreatívabb ábrák, rajzok, grafikák megjelenítésére is használhatjuk a beépített – általában téglalap alakú – komponenseket. Ehhez egyszerűen csak felül kell írni/definiálni a paint() metódusukat és vászontechnikával, a megszokott képernyős koordináta-rendszerben, grafikai primitíveket (pont, téglalap, ellipszis) és színeket kell megfelelően paraméterezni.

Az optikai csalódások igen népszerűek, és az egyszerűbb fiziológiai és kognitív illúziók könnyen lerajzolhatók a fenti eszköztárral, hiszen csupán színek, alakzatok, kontraszt, távolság, mélység, térhatás segítségével valósulnak meg.

Íme három egyszerű példa, hogyan állítható elő optikai csalódás Java implementációval!

1. példa

@Override

public void paint(Graphics g) {

int egyseg=20, sorDb=10, oszlopDb=20;

for(int i=1; i<=sorDb; i++) {

int eltolas=(i%2==1)?0:egyseg/2;

g.setColor(Color.BLACK);

for(int j=1; j<=oszlopDb; j+=2)

g.fillRect(eltolas+(j-1)*egyseg, (i-1)*egyseg+i, egyseg, egyseg);

g.setColor(Color.LIGHT_GRAY);

g.drawLine(0, (i-1)*egyseg+i-1, egyseg*(oszlopDb-1), (i-1)*egyseg+i-1);

}

2. példa

@Override

public void paint(Graphics g) {

int egyseg=50, koz=10, sorDb=6, oszlopDb=8;

g.setColor(Color.LIGHT_GRAY);

g.fillRect(0, 0, oszlopDb*(egyseg+koz)-koz, sorDb*(egyseg+koz)-koz);

g.setColor(Color.BLACK);

for(int i=1; i<=sorDb; i++)

for(int j=1; j<=oszlopDb; j++)

g.fillRect((j-1)*(egyseg+koz), (i-1)*(egyseg+koz), egyseg, egyseg);

g.setColor(Color.WHITE);

for(int i=1; i<sorDb; i++)

for(int j=1; j<oszlopDb; j++)

g.fillOval(j*(egyseg+koz)-koz-2, i*(egyseg+koz)-koz-2, koz+4, koz+4);

}

3. példa

@Override

public void paint(Graphics g) {

Point hely;

for(int i=1; i<=4; i++)

for(int j=1; j<=4; j++) {

hely=new Point((i-1)*180, (j-1)*120);

if((i+j)%2==1)

minta1(g, hely);

else

minta2(g, hely);

}

private void minta1(Graphics g, Point hely) {

Point pozicio;

for(int i=1; i<=4; i++)

for(int j=1; j<=4; j++) {

pozicio=new Point(hely.x+(i-1)*45, hely.y+(j-1)*30);

if((i+j)%2==1)

mintaAlap1(g, pozicio, Color.MAGENTA, Color.YELLOW);

else

mintaAlap2(g, pozicio, Color.YELLOW, Color.MAGENTA);

}

private void minta2(Graphics g, Point hely) {

Point pozicio;

for(int i=1; i<=4; i++)

for(int j=1; j<=4; j++) {

pozicio=new Point(hely.x+(i-1)*45, hely.y+(j-1)*30);

if((i+j)%2==1)

mintaAlap2(g, pozicio, Color.MAGENTA, Color.YELLOW);

else

mintaAlap1(g, pozicio, Color.YELLOW, Color.MAGENTA);

}

private void mintaAlap1(Graphics g, Point hely, Color kitolt, Color szin) {

g.setColor(kitolt);

g.fillRect(hely.x, hely.y, 45, 30);

g.setColor(szin);

g.fillRect(hely.x+2, hely.y+2, 13, 9);

g.fillRect(hely.x+30, hely.y+19, 13, 9);

}

private void mintaAlap2(Graphics g, Point hely, Color kitolt, Color szin) {

g.setColor(kitolt);

g.fillRect(hely.x, hely.y, 45, 30);

g.setColor(szin);

g.fillRect(hely.x+30, hely.y+2, 13, 9);

g.fillRect(hely.x+2, hely.y+19, 13, 9);

}

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Aki ezek után kedvet kapott, keressen hasonló ábrákat és tervezve, kódolva, tesztelve gyakoroljon! Ajánlom ezeket a weboldalakat:

Hasonló feladatok megoldásához a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 29-36. Grafikus felhasználói felület alkalma után bátran hozzá lehet fogni, illetve érintjük még a GUI témakört a Java adatbázis-kezelő tanfolyam 33-40. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon alkalommal is.

Telefonos billentyűzettel kódolunk/dekódolunk

2023. december 22.2018. február 3. Szerző: Friedel Attila

Nemrég egy betűket és számokat tartalmazó kódolt szöveget kaptam azzal a kéréssel, hogy próbáljam megfejteni. A titkosított szöveget a következő formátumban kaptam: 88.222.666.333.444.888.33.333. Azt is lehetett róla tudni, hogy a megfejtés csak az angol ábécé betűit és számokat tartalmazhat. Ilyen és ehhez hasonló kódok megfejtéseit az Ingress nevű AR (augmented reality) játékban lehet felhasználni (Android és iOS platformon is elérhető), ahol a játék fejlesztői mindig valamilyen egyszerűbb kódolással juttatják el a játékosok egy csoportja számára a kódokat, amiért a játékban extra felszereléshez lehet jutni. Az előző fordulókban már találkoztam Base64 és Morse-kódolással is, így gyanítottam, hogy a mostani feladvány megfejtése sem lehet nehéz feladat. Úgy gondoltam, hogy a számok közötti pontok egy-egy karakter elválasztását jelenthetik, míg a számjegyek darabszáma is hordozhat hasznos információt, nem csak az értékük. Informatikus lévén rögtön az ASCII tábla jutott eszembe, de bárhogy próbáltam valamilyen leképező függvényt alkotni, nem sikerült a számokat leszűkíteni a betűk és számok tartományára. A végső megoldást egy csapattársam segített megtalálni, aki a jobb oldalon látható képet küldte el nekem.

Például kódoljuk a SZOFTVERFEJLESZTES szöveget és ezt kapjuk: 7777.9999.666.333.8.888.33.777.333.33.5.555.33.7777.9999.8.33.7777, amit dekódolva természetesen visszakapjuk az eredeti szöveget. Hogyan működik mindez?

Tegyük fel, hogy a kódolás és dekódolás során csak az angol ábécé nagybetűit és a szóközt fogjuk használni. Hasznos néhány konstans deklarációja: a nyomógombok feliratai szövegként ( TABLE1) és tömbben ( TABLE2), szeparátorok nélküli ábécé ( TABLE3) a kódolás elvégzéséhez, valamint a dekódoláshoz szükséges szöveg ( TABLE4):

private static final

String TABLE1=" ;;ABC;DEF;GHI;JKL;MNO;PQRS;TUV;WXYZ";

private static final

String[] TABLE2=TABLE1.split(";");

private static final

String TABLE3=String.join("", TABLE2); //" ABCDEFGHIJKLMNOPQRSTUVWXYZ"

private static final

String TABLE4="023456789";

A kódolás (titkosítás) lépései

A kódolás elvégzését ellenőrzésnek kell megelőznie, hiszen a paraméterként átvett szöveg ( text) nem kódolható ha üres ( isEmpty()) vagy érvénytelen karaktert tartalmaz (olyat, ami nem szerepel a telefon nyomógombjain: ékezetes vagy írásjel). Bármilyen probléma esetén a kódoló metódus kivételt dob. A kódolás során a szöveget automatikusan nagybetűsként értelmezzük.
A kódolás során minden karakter (pl.: E) esetén ki kell választani, hogy a TABLE2 tömb melyik elemében szerepel (pl.: j=3, a nyomógomb felirata DEF) és a j-edik elemben tárolt szöveg hányadik pozícióján található (pl.: index=1). Tehát tudjuk, hogy a C karakter kódja 33, azaz ehhez a 3-as gombot kétszer ( index+1) kell lenyomni. A Java nyelvben tömbök indexelése és a szövegben lévő karakterek pozíciója is nulla bázisú sorszámmal történik. A karakterek 1-4 (változó) hosszú kódjai közé pont kerül ( coded).

public static String coding(String text)

throws IllegalArgumentException {

//ellenőrzés

if(text.isEmpty())

throw new IllegalArgumentException("Empty string for coding.");

text=text.toUpperCase();

if(!isValidText(text, TABLE3))

throw new IllegalArgumentException(

"Invalid character found in coding string.");

//kódolás

String coded="";

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

int j=0;

while(!TABLE2[j].contains(""+text.charAt(i)))

j++;

int index=TABLE2[j].indexOf(""+text.charAt(i));

for(int k=0; k<=index; k++)

coded+=j;

coded+='.';

}

return coded.substring(0, coded.length()-1);

}

A dekódolás (visszafejtés) lépései

A dekódolás elvégzését is ellenőrzésnek kell megelőznie, hiszen a paraméterként átvett szöveg ( text) nem dekódolható ha üres ( isEmpty()) vagy érvénytelen karaktert tartalmaz (olyat, ami nem feleltethető meg a telefon nyomógombjain található karakterek egyikének). Bármilyen probléma esetén a dekódoló metódus is kivételt dob.
A dekódolás során minden karakter kódja (pl.: 33) esetén szükség van annak hosszára ( length=2) és első karakterére számként ( index=3). Ezek alapján tudjuk, hogy a TABLE2 tömb index-edik ( DEF) elemének length-1-edik eleme a dekódolt karakter ( E). A dekódoló metódus nem tesz szeparátort a dekódolt karakterek ( decoded) összefűzése során. A változó hosszúságú kódolt szöveg elemeiből egykarakteres dekódolt szövegdarabok keletkeznek.

public static String decoding(String text)

throws IllegalArgumentException {

//ellenőrzés

if(text.isEmpty())

throw new IllegalArgumentException("Empty string for decoding.");

String[] text2=text.split("\\.");

String text3=String.join("", text2);

if(!isValidText(text3, TABLE4))

throw new IllegalArgumentException(

"Invalid character found in decoding string.");

//dekódolás

String decoded="";

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

int index=Integer.parseInt(""+text2[i].charAt(0));

int length=text2[i].length();

decoded+=TABLE2[index].charAt(length-1);

}

return decoded;

}

Az ellenőrzés lépései

A logikai értékkel visszatérő ellenőrző függvény ( isValidText()) feladata eldönteni, hogy a kódolás/dekódolás során használandó szöveg ( text) minden karaktere feldolgozható, azaz a folyamat során értelmezhető (másképpen: a validCharacters szöveg tartalmazza). Optimális esetben a text hossza megegyezik a benne lévő feldolgozható/értelmezhető karakterek számával (végighalad a ciklus a text-en), egyébként leáll a ciklus az első problémás karakternél.

private static boolean isValidText(

String text, String validCharacters) {

int i=0;

while(i<text.length() && validCharacters.contains(""+text.charAt(i)))

i++;

return (i==text.length());

}

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Ez a feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás, 2. rész alkalmához, valamint minden tanfolyamunk orientáló moduljának 1-4. óra: Programozási tételek alkalmához kapcsolódik.

Fát építünk

2023. január 1.2018. január 7. Szerző: Kaczur Sándor

Az adatok strukturális és könnyen értelmezhető formában való megjelenítése egy szoftver felhasználói felületén átgondolt tervezést igényel. Az adatokhoz hozzá kell jutni, ki kell választani a megfelelő grafikus komponenst, a mögötte lévő adatmodellt, össze kell ezeket kötni. Gyakran előforduló feladat, hogy táblázatosan is ábrázolható adatokból – felhasználva az adatok közötti összefüggéseket és kapcsolatokat – csoportosítva jelenítsünk meg hierarchikusan, fa struktúrában, kinyitható-becsukható formában, ahogyan ezt a felhasználók jól ismerik a fájl- és menürendszereket használva.

Fát építünk kétféleképpen

Adatbázisból, az Oracle HR sémából lekérdezünk két összetartozó nevet: részleg és alkalmazott. A lekérdezés során figyelünk a megfelelő sorrendre, ami a későbbi feldolgozást megkönnyíti. Adatainkat részlegnév szerint növekvő, azon belül alkalmazott neve szerint is növekvő – ábécé szerinti – sorrendbe rendezzük. A vezérlő rétegben két függvényt írunk, amely a modell rétegtől jut hozzá az adatokat tartalmazó generikus listához – átvett paraméterként –, és a visszaadott érték a nézet réteghez kerül.

A csoportváltás algoritmust használjuk, amely 5 blokkból épül fel. A külső ciklus előtti 1. blokk és utáni 5. blokk egyszer hajtódik végre, az előkészítő és lezáró tevékenységek tartoznak ide. A külső ciklus elején és végén található 2. és 4. blokk a belső cikluson kívül fut le, csoportonként, kategóriánként, részlegenként egyszer (most összesen 11-szer mindkettő). A 3. blokk a belső cikluson belül található, és alkalmazottanként egyszer hajtódik végre (most összesen 106-szor).

Háromszintű fát építünk: a gyökérbe (0. szint) fix, beégetett szövegként kerül a cég neve és a teljes létszám. Az 1. szinten jelennek meg a részlegek nevei és a hozzájuk tartozó létszámok. A 2. szint az alkalmazottak neveiből áll.

1. megoldás

A megoldás faKeszit1() függvénye szöveges adatot eredményez. Ez jól használható teszteléshez: megvan-e az összes adat, megfelelő-e a részlegek sorrendje azon belül az alkalmazottak sorrendje, működik-e a csoportosítás, rendben van-e a megszámolás?

public String faKeszit1(ArrayList lista) {

//1

StringBuilder faGyoker=

new StringBuilder("Cég ("+lista.size()+" fő)");

int i=0;

while(i<lista.size()) {

//2

String aktReszleg=lista.get(i).getReszleg();

ArrayList faReszlegAlkalmazott=new ArrayList<>();

while(i<lista.size() &&

lista.get(i).getReszleg().equals(aktReszleg)) {

//3

faReszlegAlkalmazott.add(lista.get(i).getNev());

i++;

}

//4

String faReszleg="\n "+aktReszleg+

" ("+faReszlegAlkalmazott.size()+" fő)\n ";

faGyoker.append(faReszleg+" "+

String.join("\n ",faReszlegAlkalmazott));

}

//5

return faGyoker.toString();

}

A faKeszit1() függvény egy sok lépésben összefűzött (konkatenált) szöveget ad vissza. Az 1. blokkban előkészítjük a fa gyökerét, ami StringBuilder típusú, hiszen sokszor manipuláljuk és inicializáljuk a lista indexelésére használt i ciklusváltozót. A 2. blokkban megjegyezzük az aktuális részleget és előkészítjük az ehhez tartozó alkalmazottak nevét tároló generikus listát ( faReszlegAlkalmazott). Az aktReszleg-hez tartozó alkalmazottak neveit összegyűjtjük a 3. blokkban. Egy részleg feldolgozását a 4. blokkban fejezzük be a fa aktuális 1. és 2. szinten lévő elemeinek szövegbe való beszúrásával. A belső ciklushoz kötődően megszámolást nem kell alkalmaznunk, hiszen az adott részlegben dolgozó alkalmazottak száma a generikus listától elkérhető ( size()). Építünk arra, hogy a külső ciklusból nézve az egymás után végrehajtódó 2. és 4. blokkban az aktReszleg nem változik meg. A 2. blokkban még nem tudjuk a fa aktuális 1. szintjét hozzáfűzni a szöveghez, hiszen a létszám csak a belső ciklusban felépülő kollekciótól kérhető el utólag. Szükséges némi késleltetés, hiszen a szöveg összefűzése és lényegesen egyszerűbb (mint utólag manipulálni megfelelő helyeken). Az 5. blokkban a csoportváltás algoritmushoz kötődő tevékenységünk nincs.

Az 1. megoldás eredménye

Cég (106 fő)

Accounting (2 fő)

Shelley Higgins

William Gietz

Administration (1 fő)

Jennifer Whalen

Executive (3 fő)

Lex De Haan

Neena Kochhar

Steven King

...

2. megoldás

A faKeszit2() függvénynél alkalmazkodunk ahhoz, hogy a JTree vizuális komponenshez DefaultTreeModel observable típusú modell szükséges, így ezzel térünk vissza ( faModell). A fa csomópontjai DefaultMutableTreeNode osztályú objektumok lesznek, amelyeknek a userObject tulajdonsága szükség esetén manipulálható. Az 1 blokkban beszúrjuk a fa gyökerét ( faGyoker), amihez a későbbiekben csatlakozik a fa többi eleme. A 2. blokkban megjegyezzük az aktuális részleget és előkészítjük – megjelenítendő szöveg nélkül – a faReszleg csomópontot. A 3. blokkban fabeli csomópontként a fa 1. szintjén megjelenő részleghez névtelenül hozzáadjuk a fa 2. szintjére kerülő – aktuális részleghez tartozó – alkalmazottak nevét. A 4. blokkban utólag módosítjuk a faReszleg csomópont megjelenítendő szövegét. Az aktuális részleg létszámát itt sem kell külön megszámolni, mert a faReszleg-től elkérhető ( getChildCount()). Az 5. blokkban itt sincs különösebb teendőnk.

public DefaultTreeModel faKeszit2(ArrayList<Alkalmazott> lista) {

//1

DefaultMutableTreeNode faGyoker=

new DefaultMutableTreeNode("Cég ("+lista.size()+" fő)");

DefaultTreeModel faModell=new DefaultTreeModel(faGyoker);

int i=0;

while(i<lista.size()) {

//2

String aktReszleg=lista.get(i).getReszleg();

DefaultMutableTreeNode faReszleg=new DefaultMutableTreeNode();

while(i<lista.size() &&

lista.get(i).getReszleg().equals(aktReszleg)) {

//3

faReszleg.add(new DefaultMutableTreeNode(lista.get(i).getNev()));

i++;

}

//4

faReszleg.setUserObject(

aktReszleg+" ("+faReszleg.getChildCount()+" fő)");

faGyoker.add(faReszleg);

}

//5

return faModell;

}

A 2. megoldás eredménye

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Attól függően, hogyan jutunk hozzá a megjelenítéshez szükséges adatokhoz, több tanfolyamunkhoz is kapcsolódik a feladat és a modell rétegben mindig másképpen tervezünk és implementálunk:

A Java SE szoftverfejlesztő tanfolyam 45-48. óra: Adatbázis-kezelés JDBC alapon, 1. rész alkalmán hagyományos SQL lekérdező utasítást készítünk JDBC környezetben.
A Java EE szoftverfejlesztő tanfolyam 25-32. óra: Adatbázis-kezelés JPA alapon alkalommal a perzisztencia szolgáltatásait vetjük be.
A Java adatbázis-kezelő tanfolyam 13-16. óra: Konzolos kliensalkalmazás fejlesztése JDBC alapon, 1. rész, 33-36. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon, 2. rész alkalmain hierarchikus lekérdezéseket használunk.