objektumorientált programozás - címke

Kutatók éjszakája 2024

2024. szeptember 27. Szerző: Kaczur Sándor

A Kutatók éjszakája nemzetközi rendezvénysorozat 2005-ben indult. Magyarország 2006-ban csatlakozott. Azóta évről-évre egyre több intézmény nyitja meg hazánkban kapuit, szervez érdekes programokat, sok-sok településen, több száz helyszínen, több ezer eseményt meghirdetve sok tízezer érdeklődő/résztvevő látogatónak biztosít tartalmas estét.

Bár a kezdeményezés elsősorban a kutatói pálya népszerűsítését szolgálja, ezért leginkább a tizen- és huszonévesekre számít, az események vonzók és elég érdekesek ahhoz, hogy a kisgyerekektől a legidősebbekig mindenki megtalálja a számára izgalmas programokat. Korábban nagyobb felsőoktatási intézmények és kutatóintézetek szerepeltek döntően, de az utóbbi néhány évben egyre több kisebb intézmény, tehetséggondozással foglalkozó középiskola, cég, egyesület is csatlakozott a rendezvényhez. A Kutatók éjszakája rendezvény minden meghirdetett programja ingyenes.

Rendezvényünk plakátja

Az it-tanfolyam.hu 2024-ben is hirdetett programokat az eseményhez kötődően. Programjainkat elsődlegesen követőinknek, aktív hallgatóinknak és az alumni csoportunkban hirdettük meg, de persze nyílt rendezvényként valósult meg. Az eseményekre regisztrálni kellett a weblapon. A regisztrációs időszak két hétig tartott, szeptember 13-26-ig. Programjainkra szeptember 27-én 21:00-23:55-ig került sor.

21:00-21:25 – Kiss Balázs: OpenAI GPT nyelvi modell – tippek a hatékony használatához
Az előadó az egyike volt a Doktoranduszok programoznak – újratöltve 24 órás Mesterséges intelligencia modul oktatóinak. Saját tapasztalatait összegzi az alábbi hívószavak alapján. Alap AI funkcionalitás, megerősítéses és gépi tanulás lehetőségei és korlátai, nyelvi modellek képességei. Említ néhány generatív AI funkciót a kép, ábra, grafikon, térkép, hang, animáció, videó generálása és ezek tömeges feldolgozása kapcsán. Előkerülnek a programozási tételek, valamint alkalmazásuk multimédia analitikával együtt. Ha lesznek haladók a látogatók között, akkor az előadó bemutat néhány objektum- és aspektusorientált tervezés során használható AI eszközt, illetve igény esetén néhány kutatómunkát támogató AI eszközt is.

21:35-21:55 – Kaczur Sándor: Algoritmusok vesebeteg-donorok párosítására
Hogyan működik 2007 óta Nagy-Britanniában a vesebeteg-donorok párosítása? Sima csere 2 pár esetén adódik. 3 pár esetén körbeadják a vesét egymásnak – ez már jóval összetettebb. A felépített óriási adatbázisban akár több száz lehetőség is adódhat. A probléma megfelelő párosítási algoritmus és számítógép nélkül, pusztán emberi erővel megoldhatatlan lenne. Az implementált algoritmus futási ideje mindössze 30 perc. A párosítást követően a következő lépés a műtétek egyidejűsége, és a donor szervek „utaztatása” minden lehetséges földi, vízi, légi úton és lehetséges közlekedési eszközzel. Hogyan működik mindez a gyakorlatban? Milyen korlátok, problémák vannak? Milyen adatok alapján dönthető el a betegek „kompatibilitása”? Ezek közül mi kapcsolódik az egészségügyhöz és a szállításhoz? Az előadó próbál válaszokat adni, de lehet, hogy a végén több lesz a kérdés, mint a válasz. Vajon egyáltalán felmerül a párosítási algoritmus hatékonysága ekkora társadalmi hasznosság mellett? A program a Java tanfolyamaink orientáló moduljához kötődik. A tavalyi előadás anyaga kiegészült néhány igazán látványos animációval, szimulációval.

22:00-22:25 – Szegedi Kristóf: Játékprogramok nyerő stratégiáinak elemzése
A tudásalapú rendszerek elméleti alapjaihoz tartoznak a mesterséges intelligencia különböző megoldáskereső módszerei, az állapottér-reprezentáció és a klasszikus keresési stratégiák, heurisztikák. Egy játék állapotait nyilvántartjuk egy adatszerkezetben. Lehet, hogy néhány lépést előre kalkulálunk (kiterjesztünk) és ezek elágazásaiból fát (fa adatszerkezet) tudunk építeni. Ezeket hatékonyan karban kell tartani konstrukciós és szelekciós műveletekkel. Heurisztika alapján döntéseket kell hozni. Vajon melyik állapot a jobb, vagy kevésbé rossz, legalább olyan jó mint ahol járunk? Ki kell értékelni és abba az irányba érdemes haladni, amelyben végül a döntések sokasága igazolja és egyben adja a nyerő stratégiát. Ha ez nem megy, akkor még mindig játszhatunk nem vesztő stratégiával, azaz lehet cél a hosszabb játékmenet, vagy akár a döntetlen állapot is. Az előadás ismertet néhány tipikus problémaszituációt, játékteret leképező reprezentációs gráfbeli navigációt és összehasonlít néhány fabejáró/gráfbejáró stratégiát. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik. Előismeretként feltételezünk némi jártasságot a programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök témakörökből.

22:30-22:55 – Hollós Gábor: Algoritmikus gondolkodás fejlesztése: mintaprogramok, esettanulmányok
Az előadó bemutat néhány olyan mintaprogramot/esettanulmányt – természetesen a fokozatosság elve alapján -, amelyek kiválóan alkalmasak a közös eszmecserére. Az algoritmusok átgondolása segíti a szabályalapú megközelítést. Sémák, programozási tételek is előkerülnek – sőt ezek egymásba ágyazása is előkerül. Iteráció vs. rekurzió. Különböző adatszerkezetek képességei, funkciói, konstrukciós és szelekciós műveletei. Az algoritmikus megközelítés szemléletmód állandóságot, stabilitást jelent gondolkodásunkban, tágítja szellemi tevékenységünk körét, célt és formát ad egy probléma megoldásának. Az előadó abban bízik, hogy a fentiek érzékeltetésére alkalmas problémákat, programokat gyűjtögetett össze.

23:00-23:25 – Falus Anita, Ménesi Viktor: Karrierváltás után – az álláskeresés és néhány hónap KKV-s tapasztalatai szoftverfejlesztőként
Mennyire könnyű ma szoftverfejlesztőként elhelyezkedni szakirányú felsőfokú végzettség nélkül? Milyen kihívásokkal találkozhatunk a felvételi folyamat során? Milyen elvárásokat támasztanak a munkaadók egy junior szakemberrel szemben? Hogyan telnek a beilleszkedés után a hétköznapok junior fejlesztőként kis létszámmal működő informatikai profilú kisvállalkozásnál? A tanfolyamainkon 2021-től 2023-ig végzett előadók karrierváltó junior szakemberként személyes tapasztalataikról számolnak be és válaszolnak a kérdésekre. A program a Java tanfolyamaink orientáló moduljához kötődik.

23:30-23:55 – Kaczur Sándor: Gondolkodjunk logikusan!
Az előadás során áttekintjük az intelligencia, a kreatív problémamegoldó és logikus gondolkodás összefüggéseit és izgalmas feladatokból válogatva közösen megoldunk néhány fejtörő feladatot. Néhány példa: Hány éves a kapitány?, CHOO + CHOO = TRAIN, Logikus gondolkodás teszt. Minden feladathoz adunk rávezető példákat – ha esetleg egyik-másik nem menne, akkor ebből ki fog derülni, hogy miket érdemes gyakorolni ahhoz, hogy sikerüljön. A korábbi évek anyagát az előadó kiegészítette néhány Java algebrai csomag funkcionalitásának bemutatásával és látványos, szinte önmagyarázó grafikus ábrákkal.

A programjaink népszerűek voltak. 52 érdeklődő látogatót fogadtunk. Többségük végig velünk tartott. Elgondolkodtató párbeszéd alakult ki a mesterséges intelligencia témakörében, illetve sok-sok kreatív megoldás került elő a logikus gondolkodás program fejtörőivel kapcsolatosan. Néhányan megragadták a lehetőséget, hogy több budapesti helyszínt is meglátogassanak – ahogyan ez megszokott a Kutatók éjszakája rendezvényeken hosszú évek óta. Kellemes hangulatban, tartalmasan töltöttük együtt ezt a három órát, aminek igazán örülök.

Szeretném megköszönni az előadó oktató kollégák és alumni hallgatóink színvonalas munkáját, igényes felkészülését. Köszönjük mindenkinek, aki részt vett a Kutatók éjszakája 2024 rendezvényünkön. Az előadások prezentációit tanfolyamaink hallgatói számára – a témához kapcsolódó témakörökhöz, ILIAS-ra feltöltve – tesszük elérhetővé.

Euler állatos feladata – geometriai megközelítés

2024. szeptember 2. Szerző: Kaczur Sándor

Valaki sertést, kecskét és juhot vásárolt, összesen 100 állatot, pontosan 100 aranyért. A sertés darabja 3 és fél arany, a kecskéé 1 és egyharmad, a juhoké fél arany. Hány darabot vehetett az egyes állatokból?

Tudjuk, hogy a feladatnak három megoldása van:

5 db sertés és 42 db kecske és 53 db juh
10 db sertés és 24 db kecske és 66 db juh
15 db sertés és 6 db kecske és 79 db juh

Klasszikus informatikai megközelítést – egymásba ágyazott ciklusokat – bemutattam már: Euler állatos feladata. A brute force alapgondolat fokozatos finomítását követően néhány ötleteket is adtam a továbbfejlesztéshez. Ez igazi örökzöld feladat. Látogatottsága alapján rendületlenül népszerű ez a blog bejegyzés az it-tanfolyam.hu szakmai blogban. Többek között ez inspirált a feladattal való további foglalkozásra.

Mit jelent a geometriai megközelítés?

Egy térbeli pont három koordinátával leírható. Az (s, k, j) ponthármas jelenti a sertések, kecskék és juhok számát. Az RGB színkockához hasonlóan (amibe belefér az összes ábrázolható színhez tartozó koordinátapont), most is elférünk egy kockában. Legyen a kocka egyik csúcsa az origó és az élei legyenek 100 egység hosszúak. A feladat megfogalmazása alapján két egyenlet (e1 és e2) írható fel 3-3 együtthatóval. Mindkét egyenlet meghatároz egy síkot (s1 és s2) a térben, amelynek ábrázoljuk a kockába eső síkmetszeteit. A két sík metszésvonala egyenes (e3), amire esnek a megoldások pontjai (m1, m2, m3). Lépésenként haladunk a geometriai ábrázolás során.

A grafikus felületen történő ábrázoláshoz, rajzoláshoz két korábbi projektünkből indulunk ki. A Kígyókocka grafikus felületen feladat ismertet egy grafikus keretrendszert JavaFX-ben megvalósítva. A három részből álló Naprendszer szimuláció esettanulmányunk pedig ismerteti az ábrázoláshoz szükséges elméleti hátteret, homogén transzformációkat, vetületi leképezést, Java forráskódot is bemutat a transzformációs mátrix alkalmazására. Az eddig említett három blog bejegyzést mind összeépítve készültek a továbbiak.

A geometriai megoldást lépésenként, saját fejlesztésű, grafikus felhasználói felülettel rendelkező, JavaFX alapú programról készült képernyőképek mutatják be – markáns Java forráskód-részletekkel.

Hogy jelenik meg a megoldásokat tartalmazó kocka?

Elegendő ábrázolni a kockának azt a három élét, amik egybeesnek a koordinátatengelyekkel. Az RGB színkockához hasonlóan piros, zöld, kék színekkel jelennek meg a három tengelyen lévő néhány pont. Az ábrázoláshoz érdemes kísérletezni egy kicsit: mekkora méretben (skála), honnan (nézőpont), milyen messziről (vetület, ideális pont, perspektíva, távolság) látszik a modelltérbeli objektum (igen, ez a kocka).

Az alábbi Java forráskód-részlet helyezi el a fenti pontokat. Mindhárom tengelyen 5-től 95-ig, 10-esével haladunk. Így elkerülhető, hogy az origóba kerüljön pont, hiszen az nem tudna egyszerre három színnel megjelenni. Mivel az állatok száma pozitív, így a koordinátapontok is nemnegatívak.

for(int i=5; i<=100; i+=10) {

Point3D cpS=new Point3D(i, 0, 0); //sertés

createPoint(cpS, 5, Color.RED);

Point3D cpK=new Point3D(0, i, 0); //kecske

createPoint(cpK, 5, Color.GREEN);

Point3D cpJ=new Point3D(0, 0, i); //juh

createPoint(cpJ, 5, Color.BLUE);

}

Hol vannak az első egyenlet síkjának pontjai?

A korábbi megoldásnál feltételként megfogalmazott első 3.5*s+4.0/3*k+0.5*j==100 egyenlet egyszerű átalakításokkal megadja a piros és zöld síkbeli ponthoz tartozó kék térbeli pontot: j=(600-21*s-8*k)/3. Ezek az s1 síkra esnek. A citromsárga pontokat páros koordinátapárokra vizsgált feltétel jelöli ki. A narancssárga vonal behatárolja ezt a síkmetszetet. Ez a négyszög (trapéz) esik bele a kockába.

A citromsárga pontokat az első egymásba ágyazott ciklusok adják hozzá az ábrázolt modelltérhez: érzékeltetve a síkbeli pontokat. A narancssárga pontokkal a második egymásba ágyazott ciklusok bővítik a modellteret: behatárolva a kockabeli négyszög síkrészletet. (A trapéz oldalait szakaszként is lehetne ábrázolni, de ez a kellően sűrű ponthalmaz is elegendő).

for(int s=0; s<=100; s+=2)

for(int k=0; k<=100; k+=2) {

int j=(600-21*s-8*k)/3;

if(0<=j && j<=100) {

Point3D cpE1=new Point3D(s, k, j);

createPoint(cpE1, 3, Color.YELLOW);

}

for(double s=0; s<=100; s+=0.1)

for(double k=0; k<=100; k+=0.1) {

long j=Math.round((600-21*s-8*k)/3);

if(((s==0 || s==100) && 0<=j && j<=100) ||

((k==0 || k==100) && 0<=j && j<=100) ||

(j==0 || j==100)) {

Point3D cpE1=new Point3D(s, k, j);

createPoint(cpE1, 2, Color.ORANGE);

}

Hol vannak a második egyenlet síkjának pontjai?

Hasonlóan az eddigiekhez. A korábbi s+k+j==100 feltételből adódik a szintén feltételként megfogalmazott j==100-s-k egyenlet. Ezek az s2 síkra esnek. Világosszürke pontok érzékeltetik a síkot és sötétszürke pontok adják a síkrészlet határait. A síkból ez a háromszög esik bele a kockába.

A Java forráskód nagyon hasonló az előzőhöz.

Hogyan helyezkedik el a két sík a kockában?

Egyben kirajzoltatva a fentieket, könnyen adódik ez az ábra:

Hol van a két sík metszésvonala?

Mivel a két sík nem esik egybe, így van metszésvonaluk. Ez egy egyenes, amiből csak az az e3 szakasz rész szükséges, ami a kockába esik. Bíbor (magenta) szín jelöli az alábbi ábrán:

Ahol a két egyenlethez tartozó konkrét pontok egybeesnek, ott van a metszésvonal. A behelyettesítést behatároló ciklusok szervezéséből (a ciklusváltozók alsó és felső és határaiból) adódik, hogy csak a kockabeli szakaszt rajzolja ki az alábbi Java forráskód-részlet:

for(double s=0; s<=100; s+=0.1)

for(double k=0; k<=100; k+=0.1) {

long j1=Math.round((600-21*s-8*k)/3);

long j2=Math.round(100-s-k);

if(j1==j2) {

Point3D cpE1=new Point3D(s, k, j1);

createPoint(cpE1, 2, Color.MAGENTA);

}

Hol jelenik meg a feladat három megoldása?

A két egyenlethez tartozó síkok kockába eső metszésvonalán helyezkednek el az egész koordinátákkal ábrázolható, koordináta-hármasként megjelenő pontok. Nagyobb fehér pontok jelölik ezeket az alábbi ábrán:

Az eddigiek alapján könnyen adódik a három pont/megoldást ábrázoló Java forráskód-részlet:

Point3D m1=new Point3D(5, 42, 53);

createPoint(m1, 10, Color.WHITE);

Point3D m2=new Point3D(10, 24, 66);

createPoint(m2, 10, Color.WHITE);

Point3D m3=new Point3D(15, 6, 79);

createPoint(m3, 10, Color.WHITE);

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 5-8. óra: Vezérlési szerkezetek, illetve 9-12. óra: Metódusok, rekurzió alkalmához, a 29-36. óra Grafikus felhasználói felület alkalmaihoz, valamint minden tanfolyamunk orientáló moduljának 1-4. óra: Programozási tételek alkalmához kapcsolódik.

Tanfolyamainkon JavaFX grafikus felülettel hangsúlyosan nem foglalkozunk, de egy-egy kész forráskódot közösen megbeszélünk, és össze is hasonlítjuk a swing-es változattal. Fejlesztünk játékprogramot, de inkább konzolosan, vagy swing-es ablakban, vagy webes alkalmazásként.

A grafikus felületek felépítésének megismerése fontos lépcső az objektumorientált programozás elmélyítéséhez, gyakorlásához. A grafikus felületekhez egy másik lényeges szemléletváltás is kapcsolódik, hiszen a korábbi algoritmusvezérelt megközelítést felváltja az eseményvezérelt (eseménykezelés). A GUI-s feladatainkat tudatosan hangsúlyozott MVC-s projektekben készítjük el.

Skandináv lottó előállítása változókkal és rekurzióval

2024. augusztus 19. Szerző: Kiss Balázs

Újra skandináv lottó (heteslottó) szelvényt generálunk Java programmal. Két különböző elven megvalósuló megoldást hasonlítunk össze. A megoldást lépésenként bemutató, grafikus felhasználói felületű, saját fejlesztésű programunkról blogoltunk már: Skandináv lottó demóprogram. Most másképpen gondolkodunk – reméljük közösen.

Építünk az alábbi tipp() függvényre:

static int tipp() {

return (int)(Math.random()*35+1);

}

Ennek a függvénynek lokális felelőssége van, azaz előállít egyetlen olyan véletlenszámot, ami megfelelő a skandináv lottószelvényre. Másképpen 1 és 35 közötti (zárt intervallum) egész szám.

A globális felelősség a megoldások során azt biztosítja, hogy minden szám egyedi/különböző legyen és 7 db véletlenszám legyen.

1. megoldás

Az első megoldás során csupán egyszerű változók jelentik az emlékezetet. Külön adatszerkezet (tömb, lista, halmaz) nincs. A lotto1() metódus valósítja meg az alábbiak szerint:

static void lotto1() {

int a=tipp(), b, c, d, e, f, g;

b=tipp();

while(a==b);

c=tipp();

while(a==c || b==c);

d=tipp();

while(a==d || b==d || c==d);

e=tipp();

while(a==e || b==e || c==e || d==e);

f=tipp();

while(a==f || b==f || c==f || d==f || e==f);

g=tipp();

while(a==g || b==g || c==g || d==g || e==g || f==g);

System.out.println("Lottószelvény: "+

a+", "+b+", "+c+", "+d+", "+e+", "+f+", "+g);

}

Az a egész ( int) típusú változó ellenőrzés nélkül előállítható, mert az első szám biztosan egyedi. A b változót csak az a-val kell összehasonlítani. Célszerű a do while hátultesztelő ciklus alkalmazása. A b-t addig tippeltetjük újra és újra, amíg szükséges. Másképpen: amíg a megegyezik b-vel ( a==b), addig nem jó a b és ezért újra kell generálni. A c változó esetében már a korábban előállított a-val és b-vel is össze kell hasonlítani, hiszen c-nek mindkettőtől különböznie kell. Másképpen (1): amíg a==c vagy b==c, addig nem jó a c és ezért újra kell generálni. Másképpen (2): amíg nem igaz, hogy a különbözik c-től és b is különbözik c-től, addig meg kell ismételni a c előállítását. Kiválóan megérhető a gondolatmenet alapján a megoldás során használt De Morgan azonosság. És így tovább a többi változóval is: d, e, f, g. Nehézkes a sok változó külön-külön való kezelése és figyelmesen kell megírni Java nyelven a hosszú forráskódot. Az eredmény a konzolon jelenik meg, például így:

1	Lottószelvény: 10, 26, 1, 17, 23, 2, 32

Kompromisszum, hogy a lottószelvényre kerülő véletlenszámok sorrendje is véletlen. Másképpen: a véletlenszámok nem „emelkedő számsorrendben” jelennek meg.

2. megoldás

Most nem használunk ciklus utasítást. Persze a lottószelvényre kerülő véletlenszámok előállítása megköveteli az ismétlést a vezérlés megvalósítása során. Az ismétlést rekurzív vezérlés oldja meg. Az emlékezetet most TreeSet jelenti. Ez egy generikus, Integer típusú adatszerkezet, amely a java.util csomagbeli kollekció keretrendszer része. Rendezett halmazként működik. Cím szerinti paraméterátadással kapja meg a metódus és kezdetben üres. Addig kell beletenni újonnan előállított véletlenszámot, amíg „egyszer csak” eléri az elemszáma a 7-et. Ha olyan elem kerül a halmazba, ami már benne van, akkor az add() halmazbővítő művelet hatástalan.

static TreeSet<Integer> lotto2(TreeSet<Integer> halmaz) {

if(halmaz.size()==7)

return halmaz;

halmaz.add(tipp());

return lotto2(halmaz);

}

A rekurzió során a lotto2() függvény saját magát hívja meg. Működése során kihasználja, hogy az adatszerkezet „menet közben” megváltozik (bővül). A lottószelvényre kerülő véletlenszámok sorrendje egyfajta mellékhatásként valósul meg, mert a TreeSet típusú kollekció automatikus képessége. Az eredmény a konzolon jelenik meg, például így:

1	Lottószelvény: [3, 8, 10, 11, 15, 27, 29]

Ha érdekelnek bennünket a részletek, akkor a rekurzív vezérlés kiegészíthető a lotto3() metódusnál látható szint paraméterrel és néhány kiírással az alábbiak szerint:

static TreeSet<Integer> lotto3(TreeSet<Integer> halmaz, int szint) {

if(halmaz.size()==7)

return halmaz;

System.out.print("szint: "+szint);

int tipp=tipp();

System.out.print(", tipp: "+tipp);

halmaz.add(tipp);

System.out.println(", halmaz: "+halmaz);

return lotto3(halmaz, szint+1);

}

Az önmagyarázóvá tett forráskód például az alábbi eredményt írhatja ki a konzolra:

szint: 0, tipp: 15, halmaz: [15]

szint: 1, tipp: 14, halmaz: [14, 15]

szint: 2, tipp: 5, halmaz: [5, 14, 15]

szint: 3, tipp: 9, halmaz: [5, 9, 14, 15]

szint: 4, tipp: 5, halmaz: [5, 9, 14, 15]

szint: 5, tipp: 7, halmaz: [5, 7, 9, 14, 15]

szint: 6, tipp: 15, halmaz: [5, 7, 9, 14, 15]

szint: 7, tipp: 14, halmaz: [5, 7, 9, 14, 15]

szint: 8, tipp: 15, halmaz: [5, 7, 9, 14, 15]

szint: 9, tipp: 34, halmaz: [5, 7, 9, 14, 15, 34]

szint: 10, tipp: 13, halmaz: [5, 7, 9, 13, 14, 15, 34]

Lottószelvény: [5, 7, 9, 13, 14, 15, 34]

Jól látható, hogy mennyi lépést igényel a lottószelvény előállítása, mikor fordult elő ismétlődés a véletlenszámok előállítása során.

A bejegyzéshez tartozó teljes 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 9-12. óra: Metódusok, rekurzió alkalomhoz, illetve a 21-24. óra: Objektumorientált programozás, 2. rész alkalomhoz kötődik.

Dátumok csoportosítása

2024. július 8.2024. július 8. Szerző: Kiss Balázs

Ebben a Java projektben dátumok csoportosítását oldjuk meg, többféleképpen is. Mikor van erre szükség? Jelentés, kimutatás, riport, lista készítése során.

Példaként tekintsünk egy blogot. A blogban rendszeresen jelenik meg új tartalom (bejegyzés, poszt). Azért, hogy a blog hosszabb távon, sok bejegyzéssel is könnyen kereshető, átlátható, böngészhető legyen/maradjon a felhasználók, látogatók számára, célszerű:

taxonómia kialakítása. Ez kategóriákat és címkéket jelent. Ebből címkefelhő vagy szófelhő is készíthető, ahogyan erről blogoltunk már: Címkefelhő generálása.
marketing analitika használata. Ezek általában toplisták valamilyen könnyen hozzáférhető adat alapján. Például: látogatottság, népszerűség, eltöltött idő, hozzászólások száma, megosztások száma, egérmutató mozgása alapján hőtérkép. Ezek általában toplisták, amelyek eleje listázódik csökkenő sorrendben.
dátum szerint is csoportosítani a blog bejegyzéseit. Érdemes megjeleníteni a legújabbtól a régebbi felé haladó (retrospektív) listát, hierarchikus fa struktúrát, lenyíló panelt. Mindez kombinálható toplistával. A csoportosítás elvégezhető igény szerint tetszőlegesen, például évente, negyedévente, havonta.

Lássuk, hogyan lehet megvalósítani a dátumok csoportosítását Java programozás nyelven!

Milyen adatokra van szükség?

Egy megadott zárt dátumtartományban véletlenszerűen előállítunk néhány dátumot. Nem számít, hogy különböznek-e. A dátumokat tároló listát érdemes csökkenő sorrendben tárolni. Minden dátum múltbeli, így ez a sorrend a jelenhez legközelebbitől halad a legtávolabbi felé. Például a Java program ezekkel a dátumokkal dolgozik (lapozható):

2024.03.25.

2024.03.22.

2024.02.26.

2024.01.30.

2024.01.25.

2024.01.23.

2024.01.16.

2024.01.13.

2024.01.02.

2023.11.29.

2023.11.25.

2023.11.24.

2023.11.07.

2023.10.02.

2023.09.14.

2023.08.31.

2023.08.04.

2023.07.13.

2023.06.15.

2023.06.14.

2023.06.08.

2023.04.22.

2023.04.01.

2023.03.26.

2023.02.11.

2023.02.08.

2023.01.26.

2022.12.14.

2022.12.10.

2022.11.09.

2022.10.14.

2022.10.04.

2022.09.24.

2022.09.23.

2022.09.20.

2022.09.09.

2022.09.01.

2022.08.31.

2022.08.20.

2022.07.29.

2022.07.03.

2022.06.30.

2022.06.07.

2022.05.16.

2022.05.15.

2022.04.18.

2022.04.14.

Milyen eredményeket kaphatunk?

Az évenkénti csoportosítás így jelenik meg:

Csoportosítás évente

2024. év (9)

2023. év (20)

2022. év (21)

A havonkénti csoportosítás így jelenik meg (lapozható):

Csoportosítás havonta

2024. március hó (2)

2024. február hó (1)

2024. január hó (6)

2023. november hó (5)

2023. október hó (1)

2023. szeptember hó (1)

2023. augusztus hó (2)

2023. július hó (1)

2023. június hó (3)

2023. április hó (2)

2023. március hó (1)

2023. február hó (2)

2023. január hó (2)

2022. december hó (3)

2022. november hó (1)

2022. október hó (2)

2022. szeptember hó (5)

2022. augusztus hó (2)

2022. július hó (2)

2022. június hó (2)

2022. május hó (2)

2022. április hó (2)

Természetesen blog esetén gyűjtőoldalra mutató hivatkozást kell tenni a megjelenő elemekre. Azok az évek és hónapok nem jelennek meg, ahol nincs dátum (blog bejegyzés).

Hogyan kapjuk meg az eredményeket?

Természetesen Java nyelven programozva készítünk megoldást, sőt többféle megoldást. Ezek szépen összevethetők és mindenki kiválaszthatja azt, amit szívesen használna. A dátumobjektumok tárolása generikus listában történik, aminek típusa LocalDate. A dátumok formátuma: DateTimeFormatter.ofPattern("yyyy.MM.dd.").

1. megoldás

Ez a hagyományosnak tekinthető megoldás. Végigjárja a dátumobjektumokat tartalmazó dateList dátumlista adatszerkezetet. Két egymásba ágyazott ciklussal csoportváltást valósít meg. Feltételezi – nem ellenőrzi -, hogy az adatok sorrendje megegyezik az eredmény kiírásának megfelelő sorrenddel. Amíg két egymást követő dátum GROUP_BY_FORMAT formátuma azonos, addig ugyanabba a csoportba tartoznak. A csoportváltáskor az eredmény TYPE_FORMAT formátumú. Közben a beépített megszámolás programozási tétel is működik.

static void groupByDate1(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter GROUP_BY_FORMAT,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

int i=0;

while(i<dateList.size()) {

LocalDate currentDate=dateList.get(i);

String typeGroup=currentDate.format(TYPE_FORMAT);

String currentGroup=currentDate.format(GROUP_BY_FORMAT);

int count=0;

while(i<dateList.size() && dateList.get(i).

format(GROUP_BY_FORMAT).equals(currentGroup)) {

count++;

i++;

}

System.out.println(typeGroup+groupText+" ("+count+")");

}

A groupByDate1() függvény képes az évente és havonta csoportosítás megvalósítására. Mindez a paraméterezésén múlik. Évente csoportosít, ha így hívja meg a vezérlés:

groupByDate1("Csoportosítás évente", "év", dateList,

DateTimeFormatter.ofPattern("yyyy"),

DateTimeFormatter.ofPattern("yyyy. "));

Évenkénti csoportosítás során például a 2024.02.26. és a 2024.01.30. (dátumként, nem szövegként értelmezve) azért tartozik egy csoportba, mert a dátumobjektumoktól elkért év "2024" szövegként mindkettő esetében megegyezik.

A groupByDate1() függvény havonta csoportosít, ha így hívja meg a vezérlés:

groupByDate1("Csoportosítás havonta", "hó", dateList,

DateTimeFormatter.ofPattern("yyyyMM"),

DateTimeFormatter.ofPattern("yyyy. MMMM "));

Havonkénti csoportosítás során például a 2023.06.14. és a 2023.06.08. (szintén dátumként értelmezve) azért tartozik egy csoportba, mert mindkettő illeszkedik a "202306" szövegmintára.

2. megoldás

Ez a Stream API-t és funkcionális programozást használó, újabb megoldás. Ciklus helyett beépített műveletek vannak. A groupByDate2() függvény a dátumok évenkénti csoportosítását képes megoldani:

static void groupByDate2(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

List<String> list=dateList.stream().

map(e -> e.format(TYPE_FORMAT)).

collect(Collectors.groupingBy(

Function.identity(), Collectors.counting())).

entrySet().stream().sequential().map(

e -> e.getKey()+groupText+" ("+e.getValue()+")").

sorted().

collect(Collectors.collectingAndThen(Collectors.toList(), e -> {

Collections.reverse(e);

return e;

}));

list.forEach((date) -> {

System.out.println(date);

});

}

A groupByDate3() függvény a dátumok havonkénti csoportosítására készült. A YearMonth osztály beépített ( java.time csomag). A DateCount saját POJO. Konstruktora 4 paramétert kap: YearMonth key, Long value, DateTimeFormatter format és String groupText, valamint van két hasznos metódusa. Az egyik az örökölt és felüldefiniált toString() a formázott kiíráshoz, a másik pedig a Comparable interfésztől implementált compareTo() a sorrend kialakításához szükséges összehasonlításhoz.

static void groupByDate3(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

List<DateCount> list=dateList.stream().

map(e -> YearMonth.from(e)).

collect(Collectors.groupingBy(

Function.identity(), Collectors.counting())).

entrySet().stream().map(e -> new DateCount(

e.getKey(), e.getValue(), TYPE_FORMAT, groupText)).

sorted().collect(Collectors.toList());

list.forEach((date) -> {

System.out.println(date);

});

}

A funkcionális programozáshoz kötődő lambda műveletekről többször is blogoltunk már, így azokat most nem részletezem. Helyette ajánlom a szakmai blog lambda kifejezés címkéjét.

Továbbfejlesztés

Érdemes átgondolni az 1. és 2. megoldás markáns különbözőségeit, illetve egymást kiegészítő gondolatmenetét. Zárjuk két ötlettel a továbbfejlesztésre vonatkozóan:

A 2. megoldás két függvénye megoldható egyetlen függvénnyel, amely hasonlóan paraméterezhető, mint az 1. megoldás függvénye. Ezáltal univerzális(abb)nak tekinthető megoldás is készülhetne. Aki kellően motivált és végiggyakorolja a fentieket, biztosan meg tudja oldani. Várjuk hozzászólásban, vagy az ILIAS-ban a megoldást!
A csoportosítás egyben hierarchiát jelent, amiből fa szerkezet építhető. A fa vizuális komponensen is megjeleníthető, ahogyan blogoltunk is róla: Fát építünk.

A bejegyzéshez tartozó teljes 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, a Java EE szoftverfejlesztő tanfolyam és a Java adatbázis-kezelő tanfolyam szakmai moduljának több alkalmához és az orientáló moduljának 1-4. óra: Programozási tételek alkalmához is kötődik. A Stream API-val és a lambda kifejezésekkel sokszor foglalkozunk.

INFIMUM 2024

2024. június 19.2024. június 14. Szerző: Kaczur Sándor

Az INFIMUM 2024 Konferenciát a Neumann János Egyetem GAMF Műszaki és Informatikai Karán került megrendezésre, Kecskeméten, 2024. június 14-15-én.

A konferencia céljai

A rendezvény elsődleges célja annak elősegítése, hogy a felsőoktatási intézmények oktatói és kutatói az informatika, a fizika, a matematika és a logisztika korszerű és hatékony oktatásáról és tudományos eredményeiről előadások, poszter-bemutatók és személyes találkozás révén tapasztalatot cserélhessenek, valamint kapcsolatot építhessenek.

A konferencia tervezett főbb témakörei

a korszerű matematika-, fizika-, logisztika- és informatikatanítás és tanulás új útjai és távlatai, oktatásfejlesztési tapasztalatai,
a felsőoktatás alapozó tárgyainak oktatás-módszertani problémái,
mesterképzésbe való bekapcsolódás, a duális képzés gondjai és tapasztalatai,
matematika, fizika, informatika, logisztika tudományos eredményei,
új és innovatív kutatási irányok, problémák és gyakorlati alkalmazások bemutatása a fenti tudományterületeken.

A konferencia programja

A letölthető absztraktkötet tartalmazza a szervezőbizottság által összeállított programot. Pénteken került sor a szakmai programra. Szombaton zajlott a Strázsa túra, utána az EB meccset lehetett megnézni a GAMF udvarán, végül borkóstolóval zárul a rendezvény.

A konferenciára 37 résztvevő regisztrált és tartott plenáris vagy szekcióelőadást. A Matematika oktatása szekció 18 előadásból, az Informatika szekció és a Fizika szekció pedig egyaránt 5-5 előadásból állt.

Az absztraktok ISBN 978-615-6435-83-5 számmal rendelkező absztraktkötetben jelentek meg. Lehetőség volt hosszabb, 1-2 oldalas összefoglalók megjelentetésére is. A szakmai cikkek a Gradus lektorált, online folyóiratba egyénileg nyújthatók be magyar vagy angol nyelven, maximum 10 oldal terjedelemben (utólag is). A folyóirat (ISSN 2064-8014) eredeti publikációkat közöl számos témakörben, beleértve a természettudományok minden területét, mindenféle műszaki tudományt, számítástechnikát, kertészetet, környezetmérnökséget, pedagógiát, didaktikát és közgazdaságtant. A számítástechnika és a matematika elméleti és alkalmazott területeit is befogadja. A folyóirat csak kutatási cikkeket közöl, és minden cikk az esettanulmányok, kísérletek, vagy a gyakorlatban már alkalmazott megközelítésekkel való szisztematikus összehasonlítások révén előrehaladó ötletek gyakorlati alkalmazását tárgyalja.

Részt vettem a konferencián

2024-ben egy szakmai előadást tartottam 20 percben Letöltés szimuláció – esettanulmány Java nyelven címmel. Erről a témáról szól korábbi blog bejegyzésem, lásd: Letöltés szimuláció.

Szakmai előadásom összefoglalója

A szerző letöltési folyamatot szimulál. A paraméterek rugalmasan beállíthatóak. Előre beállított mennyiségű adatokat, párhuzamos szálakon/folyamatokon keresztül tölt le, miközben méri az eltelt időt. A folyamatok állapota lehet inaktív, aktív és befejezett. Az aktív folyamatok esetében megjelenő százalék fejezi ki, hogy a folyamat hol tart a rá jutó részfeladat végrehajtásával. Összesített formában követhető a hiányzó és a letöltött adat mennyisége MB-onként és százalékosan is. A folyamat szimulációjához objektumorientált szemléletű, grafikus felhasználói felületű Java kliensprogram készült, egyszerű GUI komponensekkel. Az előadás/cikk bemutatja feladatspecifikációt, a tervezés és megvalósítás lépéseit, ismertet tesztelési és továbbfejlesztési lehetőségeket. A szimuláció megközelítése elvi/általános szintű. Az esettanulmány konkrét adatokkal paraméterezett. Kitér az elosztott alkalmazások különböző felépítési, tervezési, megvalósíthatósági lehetőségeire.

A konferencia a korábbi MAFIOK konferenciasorozat hagyományait követi. Ezen 2023-ban is részt vettünk és beszámoltunk róla az it-tanfolyam.hu szakmai blogban, lásd: MAFIOK 2023. Ott korábbi, MAFIOK-os publikációinkat is felsoroltuk.

A Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb szimulációs programot tervezni, kódolni, tesztelni. A Java EE szoftverfejlesztő tanfolyamunkon, a szakmai modul 5-8. óra Szálkezelés, párhuzamosság alkalommal többféle elosztott stratégiát ismertetünk, és a 17-24. óra Socket és RMI alapú kommunikáció alkalommal pedig megvalósíthatjuk többféle protokoll szerint a hálózati kapcsolatot, letöltést/feltöltést.