Kaczur Sándor informatikus mérnök, matematika-informatika-közgazdásztanár, az it-tanfolyam.hu alapítója és oktatói csapatának szakmai vezetője. Részletes bemutatkozása az Oktatók lapon található. 2017 óta blogol velünk.
Az it-tanfolyam.hu szakmai blogjába 107 bejegyzést írt:
Ismert számos képfeldolgozó, képjavító effektus. Az egyszerűbb effektusok elérhetők ingyenes web- és mobil alkalmazásokban, PowerPointban. Az összetettebb (művészi) effektusokhoz, szűrőkhöz már érdemes professzionális eszközt használni, ilyen például az Adobe Photoshop. Ezek a belépő szint képeffektusai kulcsszavakban: élesítés (sharpen), homályosítás (blur), elmosódás (gaussian blur), folyadékszerű rajz (liquid), olajfestmény (oil painting), öregítés (sepia), szürkeskála (grayscale).
Lássuk, hogyan valósítható meg Java programozási nyelven a kép élesítése!
Adott egy képfájl. Formátuma a tipikus, feldolgozhatók (JPG, GIF, PNG, WebP) egyike. Ezek rasztergrafikus képformátumok. Lekérdezhető a dimenziója: ez képpontban (pixelben) jelenti a kép szélességét (width) és a kép magasságát (height). A vászontechnika meghatározza a kép origóját (0, 0) és a képpontok kétdimenziós koordinátapárját. A kép origója a bal felső sarokban van. A kép oszlopai (column) jobbra haladva növekvő módon, a kép sorai (row) lefelé haladva növekvő módon számozottak. Egy pixel koordinátapárja (c, r) alakban írható le. Minden pixel három szín kombinációjaként áll elő (r, g, b). Másképpen: a piros, zöld és kék összetevők aránya alapján meghatározott. A tipikus színmélység alapján a színek külön-külön 256-félék lehetnek, és ezeket 0-tól 255-ig egész szám képviseli. A 0 az adott szín hiányát, a 255 a szín teljes intenzitását jelenti.
A kép élesítése során szűrőt alkalmazunk a kép belső pixeleire. A kép 4 szélén lévő pixeleket nem változtatjuk. Többféle szűrő közül választhatunk, íme két példa:
A három színösszetevőre külön-külön kell alkalmazni a szűrőt. Az aktuális pixel – amire alkalmazzuk a szűrőt – a 3×3-as mátrix középső eleméhez igazítva szorzóértékeket tartalmaz. A konkrét eset: az a mátrix esetén az 5 érték a 2. sor 2. oszlopában helyezkedik el; ennek a közvetlen szomszédos pixeleire a -1 értékek, átlós szomszédaira pedig a 0 értékek vonatkoznak. Eredményül a szűrt pixel színeit kapjuk meg külön-külön. Ha a kapott értékek kisebbek 0-nál, akkor nullázzuk őket. Ha a kapott értékek nagyobbak 255-nél, akkor beállítjuk azokat 255-re. Az a szűrőmátrix kevésbé élesít, a b szűrőmátrix erősebben élesít.
Természetesen sok más képélességhez köthető szűrő is van még. Olyanok is vannak, ahol nem csak a közvetlen szomszédos pixeleket veszi figyelembe az algoritmus. További kulcsszavak a témához kötődően: digitális képfeldolgozás, lokális operátor, korreláció, konvolúció, átlagszűrő, mediánszűrő, zajszűrő, Laplace-szűrő.
A fenti a mátrixot a SHARP_FILTER konstans kétdimenziós tömb tárolja. A paraméterként átvett BufferedImage típusú img1 objektum kép pixeleinek végigjárását ütközőként segíti a w szélesség és h magasság. A data egydimenziós tömb sorfolytonosan tárolja a kép pixeleit. Az if elágazó utasítás igaz ága kezeli a kép 4 szélét (változatlanul hagyott másolt színek). Az if hamis ága a belső pixelekre alkalmazza a szűrőmátrixot. A red, green, blue változók tartalmazzák az aktuális pixel színeit, amelyekbe az eredeti pixelre alkalmazott szűrő által szorzott értékek kerülnek, „belekényszerítve” a 0-255 zárt intervallumba. Végül az eredményül visszaadott img2 kép pixelei kerülnek beállításra. Az alábbi sharpenEffect() függvény mindezt megoldja az alábbiak szerint:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
public static BufferedImage sharpenEffect(BufferedImage img1) { final int[][] SHARP_FILTER={ { 0, -1, 0}, {-1, 5, -1}, { 0, -1, 0} }; Color[][] colorArray=new Color[3][3]; int w=img1.getWidth(), h=img1.getHeight(), i=0; int[] data=new int[w*h]; for(int y=0; y<h; y++) for(int x=0; x<w; x++) { if(y==0 || x==0 || y==h-1 || x==w-1) data[i]=img1.getRGB(x, y); else { for(int c=y-1; c<=y+1; c++) for(int r=x-1; r<=x+1; r++) colorArray[x-r+1][y-c+1]=new Color(img1.getRGB(r, c)); int red=0, green=0, blue=0; for(int c=0; c<=2; c++) for(int r=0; r<=2; r++) { red+=SHARP_FILTER[r][c]*colorArray[r][c].getRed(); green+=SHARP_FILTER[r][c]*colorArray[r][c].getGreen(); blue+=SHARP_FILTER[r][c]*colorArray[r][c].getBlue(); } red=(red<0)?0:(red>255?255:red); green=(green<0)?0:(green>255?255:green); blue=(blue<0)?0:(blue>255?255:blue); Color c2=new Color(red, green, blue); data[i]=c2.getRGB(); } i++; } BufferedImage img2= new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); img2.setRGB(0, 0, w, h, data, 0, w); return img2; } |
A metódus meghívása a fájlkezelést is tartalmazó vezérlőmetódusban például így történhet:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public static void main(String[] args) { try { BufferedImage imageSource=ImageIO.read( new File("./images/Traditional-Japanese-Garden.jpg")); BufferedImage imageSharpen=sharpenEffect(imageSource); ImageIO.write(imageSharpen, "jpg", new File("./images/Traditional-Japanese-Garden-sharpen.jpg")); } catch(Exception e) { // } } |
A bal oldalon az eredeti kép, a jobb oldalon az a mátrixszal élesített kép látható:
A bal oldalon az eredeti kép, a jobb oldalon a b mátrixszal élesített kép látható:
A látvány alapján fontos kiemelni, hogy másképpen is lehet összehasonlítást végezni. Például: színtérkép, színmélység, színösszetevők aránya (hisztogram).
|
1 2 3 4 |
Color c1=new Color(img1.getRGB(x, y)); int gray=(int) (0.21*c1.getRed()+0.72*c1.getGreen()+0.07*c1.getBlue()); Color c2=new Color(gray, gray, gray); |
|
1 2 3 4 5 6 7 8 9 10 11 |
Color cTop=new Color(img1.getRGB(x, y-1)), cRight=new Color(img1.getRGB(x+1, y)), cBottom=new Color(img1.getRGB(x, y+1)), cLeft=new Color(img1.getRGB(x-1, y)); int r=(cTop.getRed()+cRight.getRed()+ cBottom.getRed()+cLeft.getRed())/4, g=(cTop.getGreen()+cRight.getGreen()+ cBottom.getGreen()+cLeft.getGreen())/4, b=(cTop.getBlue()+cRight.getBlue()+ cBottom.getBlue()+cLeft.getBlue())/4; Color c2=new Color(r, g, b); |
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 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 GUI programot tervezni, kódolni, tesztelni, kiegészítve a 37-44. óra Fájlkezelés alkalmaihoz kötődő példaprogramokkal.
Ebben a projektben táblázatos hőtérképet készítünk Java és JS nyelveken. Java programot készítünk az adatok véletlenszerű előállításához és a sablon alapján történő HTML fájl generálásához. JavaScript program fogja a grafikont megjeleníteni a weboldalon. Tervezünk, kódolunk, tesztelünk. Lássunk hozzá!
A hőtérkép (heatmap) olyan grafikon, amely könnyen áttekinthetővé tesz nagy mennyiségű adatot úgy, hogy kategorizál/csoportosít és az előfordulások tartományai alapján különböző színeket rendel azokhoz. A szín hozzárendelése egy intervallumból történik. Például a világosabb a ritkább, a sötétedő szín az egyre gyakoribb értékeket jelenti. A tipikus hőtérkép kétdimenziós és az előforduló adatok mennyiségét, azok arányait, eloszlását, szóródását (nem szórását), gyakoriságát jeleníti meg. A hőtérkép gyors vizuális összefoglalást, áttekintést biztosít. A projekt során sorokból és oszlopokból álló táblázatos hőtérképet készítünk.
A táblázatos hőtérkép nem összekeverendő a következő két megközelítéssel:
Adott egy konditerem, amely hétköznapokon egy megadott időintervallumban használható. Ehhez kulcsot kell felvenni és leadni. Az első belépő nyitja és az utolsó távozó zárja az ajtót. A teremhasználat offline nyilvántartott, így nehézkes bármiféle kimutatás, statisztika. A „menet közbeni” jövés-menést nem tudjuk követni. Természetesen adott számos szabály (felelősség, biztonság, balesetvédelem, létszámkorlát), amit most nem részletezek.
Elhelyezünk az ajtó mellett, belülről egy belépéshez és egy távozáshoz tartozó QR kódot. Készítünk egy egyszerű mobil alkalmazást és megkérjük a konditermek használóit, hogy belépéskor és távozáskor „csekkoljanak”. Anonim gyűjtjük a belépések és távozások időpontját (valahol egy szerveren, bármilyen fájlban, adatbázisban).
A konditermek használatára vonatkozó összesített adatokat könnyen átlátható módon szeretnénk weboldalon megjeleníteni: heti bontásban, a nyitva tartás időszakát órás blokkokra bontva az igénybevételtől függően jelenjenek meg az adatok táblázatos hőtérképen.
Ez az állapot átmeneti. Segítheti a konditermekbe tervezett – egyéni használattól független – események ütemezését. Ezeket akkor lenne célszerű időzíteni, amikor nem, alig, vagy kevésbé használt, foglalt az adott konditerem. A továbbfejlesztés következő állapotában könnyen lecserélhető a QR kód RFID alapú proximity kártyára, proxy kulcstartóra: először csak a jelenlét nyilvántartásához, később akár az ajtó nyitásához is.
Egyetlen konditeremre fókuszálunk. A hétköznaponként nyitva tartás legyen 16 órától 21 óráig. Aki edzésre jön, véletlenszerűen 20 és 40 perc közötti időszakot tölt a konditeremben. 16 órától lehet belépni. Az utolsó belépés 20:40-kor lehet (érdemes). 21 órakor mindenki elhagyja a konditermet. Nem fordul elő, hogy valaki nem jelzi a belépését vagy a távozását. Mivel anonim a nyilvántartás, így elegendő a dátum/időhöz, időbélyeghez egyetlen állapotot tárolni: be vagy ki. Valaki belépett nyitáskor vagy valamikor utána, majd távozott 20-40 perccel később, de legfeljebb záráskor.
A szükséges adatokat véletlenszerűen állítjuk elő. Egy hétre vonatkozó adatokat generálunk. Ezek a fenti paramétereknek megfelelő, összetartozó belépéshez és távozáshoz köthető időpontok. Kiegészítve a napok ciklusban való léptetésével hétfőtől péntekig. Az adatokat feldolgozva, összegyűjtve, csoportosítva, kategorizálva olyan (kimeneti) formátumra alakítjuk, amely kompatibilis a táblázatos hőtérkép adatmodelljével (bemenetével). Mindez Java nyelven valósul meg.
A webes megjelenítéshez szükséges egy HTML fájl, amelyben beágyazva található meg egy téglalap alakú területként megjelenő táblázatos hőtérkép. Ez sokféleképpen testre szabható: adható hozzá felirat, beállítható a sorokhoz és oszlopokhoz tartozó szöveg és a táblázat celláiban megjelenő értékek, adott a lebegő, az egér kurzor helyzetétől függő – cellánként különböző – jelmagyarázat, és persze mindennek van formátuma (betűtípus, méret, szín, igazítás, kitöltés). A fix, adatoktól nem függő beállításokat tartalmazó weboldalt sablonként elkészítjük. Mindez JavaScript nyelven történik. Ezután Java program a weboldal sablonját kiegészíti (cseréli, behelyettesíti, feltölti) a szükséges adatokkal.
A konditerem használatának alakulását követjük, amihez táblázatos hőtérképet készítünk. Ehhez a nyitva tartás időintervallumát órás blokkokra bontjuk. Blokkonként összesítjük a jelenlétet, azaz megszámoljuk, hogy éppen akkor hányan veszik igénybe a konditermet, hányan vannak jelen/benn.
A konkrét paraméterektől függően az alábbi képen látható 3 eset egyike fordulhat elő. A és B jelöli az órás blokk elejét és végén, tehát ez 60 perces intervallum. Tarthat például: 16:00:00-16:59:59-ig. X és Y jelöli a jelenlét intervallumát, azaz a belépés és távozás időpontjait. Ez 20 és 40 perc között alakul. Haladjunk balról jobbra az ábrán.
Az első esetben ugyanarra az órára esik a belépés és a távozás. Ez az eset egyértelmű. A másik két esetben átfedés van több órás blokk között, mert különböző órára esik a belépés és a távozás. El kell dönteni, hogy ekkor hogyan összesítjük a jelenlétet. Válasszunk az alábbi két módszer közül:
Az első módszert valósítjuk meg. Ez a döntés jelentősen befolyásolja, hogyan kell értelmezni később az elkészült táblázatos hőtérképet.
A koncepcionális terv alapján modellezünk. A szükséges adatok tárolására és alapfunkcióira fókuszálunk. Az osztály tárolja az összetartozó adatokat és megvalósít rajtuk értelmezhető műveleteket. Az időintervallum/időtartam kezelését a Duration ősosztály oldja meg. Tárolja a start és stop – naptól független időpontokat tároló – adatok és a rájuk vonatkozó FORMAT – megjelenítéshez kötődő – konstanst. Biztosítja a szükséges műveleteket: konstruktor, getterek, megvalósítja az időintervallumok átfedését az isOverlapped() függvénnyel, valamint ad szöveges reprezentációt a toString() függvénnyel. Az ősosztályból öröklődik az utódosztály. A DurationMap osztály a naptól független időpontokat kibővíti a hozzájuk tartozó day nappal, valamint képes tárolni az összesített, megszámolt jelenlétet a count változóban. Részt vesz a megszámolás folyamatában azzal, hogy lépésenként meghívható az incrementCount() eljárása.
A
java.time csomagbeli
LocalTime osztály képes a dátumtól független, napon belüli időpont tárolására és biztosít néhány alapvető funkciót a kezelésükre. Az adattárolás a napon belül eltelt időn alapul és nekünk (bőven) elegendő a másodperc alapú megjelenítés. A
DateTimeFormatter alkalmas ezen időpontok formátumának tárolására, például
óó:pp:mm alakban.
A Duration osztályból annyi objektum készül, ahány jelenlét adódik véletlenszerűen. Akár több száz is lehet. A DurationMap osztályból generált objektumok száma jóval kevesebb. Heti 5 napra, napi 5 órás blokkra 25 db készül belőle.
A vezérléshez kötődő osztály tervezését nem részletezem.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
public class Heatmap { private final DayOfWeek[] WORKDAYS=new DayOfWeek[] { DayOfWeek.MONDAY, DayOfWeek.TUESDAY, DayOfWeek.WEDNESDAY, DayOfWeek.THURSDAY, DayOfWeek.FRIDAY}; private final LocalTime ENTER_START_TIME=LocalTime.of(16, 0, 0); private final LocalTime ENTER_STOP_TIME=LocalTime.of(20, 40, 0); private final LocalTime EXIT_TIME=LocalTime.of(20, 59, 59); private final DateTimeFormatter FORMAT= DateTimeFormatter.ISO_LOCAL_TIME; private final Path HEATMAP_TEMPLATE_FILE= Paths.get("./files/heatmap-template.html"); private final Path HEATMAP_FILE=Paths.get("./files/heatmap.html"); private ArrayList<DurationMap> durationMapAllList=new ArrayList<>(); public Heatmap() { overlapTest(); createHeatmapFile(); } private void overlapTest() { for(DayOfWeek day: WORKDAYS) { LocalTime intervalStart=ENTER_START_TIME; LocalTime intervalStop= intervalStart.plusHours(1).minusSeconds(1); ArrayList<DurationMap> durationMapDayList=new ArrayList<>(); for(int i=1; i<=5; i++) { DurationMap interval= new DurationMap(day, intervalStart, intervalStop); durationMapDayList.add(interval); intervalStart=intervalStart.plusHours(1); intervalStop=intervalStop.plusHours(1); } ArrayList<Duration> durationList=new ArrayList<>(); for(int i=1; i<=10; i++) { int startSec=ENTER_START_TIME.toSecondOfDay(), stopSec=ENTER_STOP_TIME.toSecondOfDay(); int randomSec= (int)(Math.random()*(stopSec-startSec+1)+startSec); LocalTime startTime=LocalTime.ofSecondOfDay(randomSec); int presenceMin=(int)(Math.random()*21+20); LocalTime stopTime=LocalTime.ofSecondOfDay(Math.min( startTime.toSecondOfDay()+presenceMin*60, EXIT_TIME.toSecondOfDay())); durationList.add(new Duration(startTime, stopTime)); } durationMapDayList.stream().forEach((durationMap) -> { durationList.stream(). filter((duration) -> (duration.isOverlapped(durationMap))). forEach((duration) -> { durationMap.incrementCount(); }); }); durationMapAllList.addAll(durationMapDayList); } } private void createHeatmapFile() { String heatmapData=durationMapAllList.stream(). map(DurationMap::toString).collect(Collectors.joining(",\n")); try { String html=Files.readAllLines(HEATMAP_TEMPLATE_FILE).stream(). collect(Collectors.joining("\n")); html=html.replace("##HEATMAP_DATA##", heatmapData); Files.write(HEATMAP_FILE, html.getBytes(), StandardOpenOption.CREATE); } catch(IOException e) { e.printStackTrace(); } } public static void main(String[] args) { new Heatmap(); } } |
A Java forráskód minden megtervezett funkciót megvalósít, támogatva a koncepciót. Most nem részletezem a működését.
A lista görgethető:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
{x: "hétfő", y: "16:00:00-16:59:59", heat: 4}, {x: "hétfő", y: "17:00:00-17:59:59", heat: 6}, {x: "hétfő", y: "18:00:00-18:59:59", heat: 9}, {x: "hétfő", y: "19:00:00-19:59:59", heat: 6}, {x: "hétfő", y: "20:00:00-20:59:59", heat: 6}, {x: "kedd", y: "16:00:00-16:59:59", heat: 6}, {x: "kedd", y: "17:00:00-17:59:59", heat: 10}, {x: "kedd", y: "18:00:00-18:59:59", heat: 6}, {x: "kedd", y: "19:00:00-19:59:59", heat: 7}, {x: "kedd", y: "20:00:00-20:59:59", heat: 3}, {x: "szerda", y: "16:00:00-16:59:59", heat: 5}, {x: "szerda", y: "17:00:00-17:59:59", heat: 9}, {x: "szerda", y: "18:00:00-18:59:59", heat: 5}, {x: "szerda", y: "19:00:00-19:59:59", heat: 7}, {x: "szerda", y: "20:00:00-20:59:59", heat: 7}, {x: "csütörtök", y: "16:00:00-16:59:59", heat: 4}, {x: "csütörtök", y: "17:00:00-17:59:59", heat: 6}, {x: "csütörtök", y: "18:00:00-18:59:59", heat: 11}, {x: "csütörtök", y: "19:00:00-19:59:59", heat: 7}, {x: "csütörtök", y: "20:00:00-20:59:59", heat: 5}, {x: "péntek", y: "16:00:00-16:59:59", heat: 4}, {x: "péntek", y: "17:00:00-17:59:59", heat: 8}, {x: "péntek", y: "18:00:00-18:59:59", heat: 4}, {x: "péntek", y: "19:00:00-19:59:59", heat: 7}, {x: "péntek", y: "20:00:00-20:59:59", heat: 4} |
HTML és JavaScript nyelvű forráskód vegyesen. A Java program a fájl 31. sorában lévő ##HEATMAP_DATA## szöveget cseréli le a táblázatos hőtérkép megjelenítéséhez szükséges véletlenszerűen előállított adatokra.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
<html> <head> <title>Heatmap in JavaScript</title> <script src="https://cdn.anychart.com/releases/8.11.0/js/anychart-core.min.js"></script> <script src="https://cdn.anychart.com/releases/8.11.0/js/anychart-heatmap.min.js"></script> <style type="text/css"> html, body, #container { width: 80%; height: 80%; margin: 20pt; padding: 20pt; } </style> </head> <body> <div id="container"></div> <script> anychart.onDocumentReady(function () { let chart=anychart.heatMap(getData()); chart.title("Hogyan alakul a konditerem látogatottsága?"); chart.tooltip().useHtml(true).titleFormat(function () { return "Látogatottság: "+this.heat; }).format(function () { return ( '<span style="color: #CECECE">Nap: </span>'+this.x+"<br/>"+ '<span style="color: #CECECE">Időtartam: </span>'+this.y ); }); chart.container("container"); chart.draw(); }); function getData() { return [ ##HEATMAP_DATA## ]; } </script> </body> </html> |
További részletekért, beállításra vonatkozó, testre szabási lehetőségekért érdemes tanulmányozni az AnyChart dokumentáció Heat Map Chart fejezetét.
Az előállított weboldalt böngészőben megjelenítve ezt kaphatjuk eredményként (vagy a véletlenszerűen generált adatoktól függően hasonlót):
A táblázatos hőtérkép hasznos eszköz. Elemezve könnyen döntéseket hozhatunk a koncepcionális tervezés során vázoltak alapján.
A bejegyzéshez tartozó forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.
A projektfeladat – attól függően, milyen szinten valósítjuk meg – kapcsolódhat több tanfolyamunk tematikájához. A fenti forráskód a Java SE szoftverfejlesztő tanfolyam 17-28. óra: Objektumorientált programozás és a 37-44. óra Fájlkezelés alkalmaihoz kötődik. Ha többrétegű, elosztott alkalmazásként valósítjuk meg, akkor a Java EE szoftverfejlesztő tanfolyam a 9-16. óra: XML és JSON feldolgozás, dinamikusan generált weboldalba beépítve a 33-40. óra: Java Server Pages alkalmaihoz kapcsolódik. Ha fájlok helyett egyszerű adatbázist használnánk, akkor a Java SE szoftverfejlesztő tanfolyam 45-52. óra: Adatbázis-kezelés JDBC alapon, ha objektumrelációs leképezéssel oldanánk meg, akkor a Java EE szoftverfejlesztő tanfolyam 25-32. óra: Adatbázis-kezelés JPA alapon alkalmakhoz kötődhet.
Három különböző megközelítésben generálunk szövegeket és töltjük bele ezeket generikus listába. Olyan környezetet építünk, amely képes tesztelni/mérni a Java program/környezet memória használatát előtte/utána. A tárigény (memória, háttértár, feldolgozandó adatok mennyisége, adatforgalom) fontos eleme a hatékonyságnak. Gyakran előfordul, hogy a tárigényt csökkenteni kell egy program tervezése, implementációja vagy továbbfejlesztése során.
A Java program előállít 100000 db 20 hosszúságú szöveget véletlen kiválasztott angol ábécé-beli betűkből. A szövegeket generikus listába tölti be. A program méri az általa felhasznált memória méretét/nagyságát úgy, hogy a műveletek előtti és utáni eredményekből különbséget számol. Egyszerű következtetéssel, becsléssel nagy mennyiségű adatra/memóriaterületre számíthatunk, így érdemes megabájt mértékegységet használni.
Íme az első módszert megvalósító metódus. Futtatása 620 MB memóriát igényel:
|
1 2 3 4 5 6 7 8 9 10 11 |
private void method1() { List<String> stringList=new ArrayList<>(); for(int i=1; i<=STRING_COUNT; i++) { String generatedString=""; for(int j=1; j<=STRING_LENGTH_LIMIT; j++) generatedString+= (char)(int)(Math.random()*(MAX_LIMIT-MIN_LIMIT+1)+MIN_LIMIT); stringList.add(generatedString); } //System.out.println(stringList); } |
Ez a második módszer metódusa, amely futása során 235 MB memóriát használ:
|
1 2 3 4 5 6 7 8 9 10 11 |
private void method2() { List<String> stringList=new ArrayList<>(); for(int i=1; i<=STRING_COUNT; i++) { StringBuilder generatedString=new StringBuilder(); for(int j=1; j<=STRING_LENGTH_LIMIT; j++) generatedString.append( (char)(int)(Math.random()*(MAX_LIMIT-MIN_LIMIT+1)+MIN_LIMIT)); stringList.add(generatedString.toString()); } //System.out.println(stringList); } |
A harmadik módszer metódusa. 494 MB „memóriaterületbe kerül” lefuttatni:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
private void method3() { Random random=new Random(); List<String> stringList=new ArrayList<>(); for(int i=1; i<=STRING_COUNT; i++) { String generatedString=random.ints(MIN_LIMIT, MAX_LIMIT+1) .limit(STRING_LENGTH_LIMIT) .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append) .toString(); stringList.add(generatedString); } //System.out.println(stringList); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
private long getCurrentlyUsedMemory() { long totalMemory=Runtime.getRuntime().totalMemory(); long freeMemory=Runtime.getRuntime().freeMemory(); System.gc(); return (totalMemory-freeMemory)/1048576; } void run() { System.out.println("Felhasznált memória, adatok betöltése..."); System.out.println("1. teszt:"); long memoryStart=getCurrentlyUsedMemory(); System.out.println(" előtt: "+memoryStart+" MB"); method1(); long memoryStop=getCurrentlyUsedMemory(); System.out.println(" után: "+memoryStop+" MB"); System.out.println(" különbség: "+(memoryStop-memoryStart)+" MB"); //... } |
A tesztkörnyezet az alábbi eredményeket írta ki konzolosan:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Felhasznált memória, adatok betöltése... 1. teszt: előtt: 2 MB után: 622 MB különbség: 620 MB 2. teszt: előtt: 16 MB után: 251 MB különbség: 235 MB 3. teszt: előtt: 17 MB után: 511 MB különbség: 494 MB |
A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.
Bemutattunk többféle módszert, illetve teszteredményeket. Részletes magyarázatot/indoklást most nem adunk a szakmai blogban. A Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra Objektumorientált programozás alkalmain természetesen széles körű áttekintést adunk a témakörrel kapcsolatosan, valamint más módszereket is bemutatunk. A hatékonyság klasszikus dimenziói: időigény, tárigény, bonyolultság. Több esettanulmányunk is van, amely egy-egy algoritmus lépésszámát méri, memória- és/vagy sávszélesség igényt mér, illetve elvi és/vagy koncepcionális bonyolultságot próbál meghatározni. Ezek közül többször redukálunk, csökkentünk tipikusan lépésszámot, memóriaigényt.
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.
Az it-tanfolyam.hu 2023-ban 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 másfél hétig tartott, szeptember 18-28-ig. Programjainkra szeptember 29-én 21:00-23:55-ig került sor.
A programjaink népszerűek voltak. 43 érdeklődő látogatót fogadtunk. Többségükben végig velünk tartottak. Elgondolkodtató párbeszéd alakult ki a vesebeteg-donorok párosításáról, valamint sok-sok kreatív ötlet 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 az idő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 2023 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é.
Mennyi a valószínűsége, hogy n ember között van kettő, akiknek egy napon van a születésnapja? A meglepő a dologban az, hogy már 23 ember esetén a kérdéses valószínűség 1/2-nél nagyobb. Másképpen: már 23 ember esetén nagyobb annak az esélye, hogy megegyezik a születésnapjuk, mint az ellenkezőjének. Ez a 23 nagyon kevésnek tűnik. Ezért paradoxon.
Közismert néhány hétköznapi valószínűség. Íme néhány szabályos eset. A pénzfeldobás során 1/2 az esélye a fej és 1/2 az esélye az írás eredménynek (másképpen 50%-50%, azaz fifty-fifty). A kockadobás esetén 1/6 az esélye bármelyik számnak 1-től 6-ig. Két kocka esetén blogoltam már a dobott számok összegének alakulásáról, eloszlásáról: Kockadobás kliens-szerver alkalmazás.
Lássuk, hogyan alakul az azonos születésnap valószínűsége az emberek számától függően! Grafikonon ábrázolva:
A fenti grafikonhoz szükséges adatok könnyen előállíthatók az alábbi Java forráskóddal:
|
1 2 3 4 5 6 7 |
private static String scatterChartData() { List<String> list=IntStream.range(1, 71).boxed(). map(n->String.format(Locale.US, "%10c[ %d, %.4f ]", ' ', n, 1-Math.pow(364.0/365, n*(n-1)/2))). collect(Collectors.toList()); return String.join(",\n", list); } |
A fenti Google Chart típusú szórásgrafikon (Scatter Chart, korrelációs diagram) megjelenítéséhez adatpárok sorozata szükséges. Ezek a konkrétumok (70 db adatpár), görgethető:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
[ 1, 0.0000 ], [ 2, 0.0027 ], [ 3, 0.0082 ], [ 4, 0.0163 ], [ 5, 0.0271 ], [ 6, 0.0403 ], [ 7, 0.0560 ], [ 8, 0.0739 ], [ 9, 0.0940 ], [ 10, 0.1161 ], [ 11, 0.1401 ], [ 12, 0.1656 ], [ 13, 0.1926 ], [ 14, 0.2209 ], [ 15, 0.2503 ], [ 16, 0.2805 ], [ 17, 0.3114 ], [ 18, 0.3428 ], [ 19, 0.3745 ], [ 20, 0.4062 ], [ 21, 0.4379 ], [ 22, 0.4694 ], [ 23, 0.5005 ], [ 24, 0.5310 ], [ 25, 0.5609 ], [ 26, 0.5900 ], [ 27, 0.6182 ], [ 28, 0.6455 ], [ 29, 0.6717 ], [ 30, 0.6968 ], [ 31, 0.7208 ], [ 32, 0.7435 ], [ 33, 0.7651 ], [ 34, 0.7854 ], [ 35, 0.8045 ], [ 36, 0.8224 ], [ 37, 0.8391 ], [ 38, 0.8547 ], [ 39, 0.8690 ], [ 40, 0.8823 ], [ 41, 0.8946 ], [ 42, 0.9058 ], [ 43, 0.9160 ], [ 44, 0.9254 ], [ 45, 0.9339 ], [ 46, 0.9415 ], [ 47, 0.9485 ], [ 48, 0.9547 ], [ 49, 0.9603 ], [ 50, 0.9653 ], [ 51, 0.9697 ], [ 52, 0.9737 ], [ 53, 0.9772 ], [ 54, 0.9803 ], [ 55, 0.9830 ], [ 56, 0.9854 ], [ 57, 0.9875 ], [ 58, 0.9893 ], [ 59, 0.9909 ], [ 60, 0.9922 ], [ 61, 0.9934 ], [ 62, 0.9944 ], [ 63, 0.9953 ], [ 64, 0.9960 ], [ 65, 0.9967 ], [ 66, 0.9972 ], [ 67, 0.9977 ], [ 68, 0.9981 ], [ 69, 0.9984 ], [ 70, 0.9987 ] |
Hasonló grafikon készítéséről szintén blogoltam már: Céline Dion – Courage World Tour.
Az emberek születésnapjainak összehasonlítása párokban történik. 23 ember esetén 23*22/2=253 pár van. Általános esetben n ember esetén (n*(n-1))/2 pár adódik. A levezetés részletei a források között megtalálható. 59 ember esetén 1711 pár adódik és szinte garantált az előforduló azonos születésnap, hiszen már 0,99 ennek a valószínűsége.
Az alábbi Java forráskód – rekurzív módon – előállítja a 23 konkrét esetre a párokat, az embereket 1-23-ig sorszámozva. Kombinációk:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
private static void combinationsInternal( List<Integer> input, int k, List<List<Integer>> output, ArrayList<Integer> acc, int i) { int needToAcc=k-acc.size(), canAcc=input.size()-i; if(acc.size()==k) output.add(new ArrayList<>(acc)); else if(needToAcc<=canAcc) { combinationsInternal(input, k, output, acc, i + 1); acc.add(input.get(i)); combinationsInternal(input, k, output, acc, i + 1); acc.remove(acc.size()-1); } } public static List<List<Integer>> combinations( List<Integer> input, int k) { List<List<Integer>> output=new ArrayList<>(); combinationsInternal(input, k, output, new ArrayList<>(), 0); return output; } public static void main(String[] args) { for(int i=23; i<=23; i++) { List<Integer> list=IntStream.range(1, i+1). mapToObj(x->x).collect(Collectors.toList()); List<List<Integer>> combinationList=combinations(list, 2); Collections.reverse(combinationList); System.out.println( i+" db elemből:\n"+ list+"\n"+ combinationList.size()+" db pár:\n"+ combinationList); } } |
A main() metódusban az i változó paraméterezhető és a konkrét eset könnyen intervallumra változtatható. Eredményül ezt írja ki a program a konzolra, görgethető:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
23 db elemből: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] 253 db pár: [[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [1, 9], [1, 10], [1, 11], [1, 12], [1, 13], [1, 14], [1, 15], [1, 16], [1, 17], [1, 18], [1, 19], [1, 20], [1, 21], [1, 22], [1, 23], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [2, 9], [2, 10], [2, 11], [2, 12], [2, 13], [2, 14], [2, 15], [2, 16], [2, 17], [2, 18], [2, 19], [2, 20], [2, 21], [2, 22], [2, 23], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [3, 9], [3, 10], [3, 11], [3, 12], [3, 13], [3, 14], [3, 15], [3, 16], [3, 17], [3, 18], [3, 19], [3, 20], [3, 21], [3, 22], [3, 23], [4, 5], [4, 6], [4, 7], [4, 8], [4, 9], [4, 10], [4, 11], [4, 12], [4, 13], [4, 14], [4, 15], [4, 16], [4, 17], [4, 18], [4, 19], [4, 20], [4, 21], [4, 22], [4, 23], [5, 6], [5, 7], [5, 8], [5, 9], [5, 10], [5, 11], [5, 12], [5, 13], [5, 14], [5, 15], [5, 16], [5, 17], [5, 18], [5, 19], [5, 20], [5, 21], [5, 22], [5, 23], [6, 7], [6, 8], [6, 9], [6, 10], [6, 11], [6, 12], [6, 13], [6, 14], [6, 15], [6, 16], [6, 17], [6, 18], [6, 19], [6, 20], [6, 21], [6, 22], [6, 23], [7, 8], [7, 9], [7, 10], [7, 11], [7, 12], [7, 13], [7, 14], [7, 15], [7, 16], [7, 17], [7, 18], [7, 19], [7, 20], [7, 21], [7, 22], [7, 23], [8, 9], [8, 10], [8, 11], [8, 12], [8, 13], [8, 14], [8, 15], [8, 16], [8, 17], [8, 18], [8, 19], [8, 20], [8, 21], [8, 22], [8, 23], [9, 10], [9, 11], [9, 12], [9, 13], [9, 14], [9, 15], [9, 16], [9, 17], [9, 18], [9, 19], [9, 20], [9, 21], [9, 22], [9, 23], [10, 11], [10, 12], [10, 13], [10, 14], [10, 15], [10, 16], [10, 17], [10, 18], [10, 19], [10, 20], [10, 21], [10, 22], [10, 23], [11, 12], [11, 13], [11, 14], [11, 15], [11, 16], [11, 17], [11, 18], [11, 19], [11, 20], [11, 21], [11, 22], [11, 23], [12, 13], [12, 14], [12, 15], [12, 16], [12, 17], [12, 18], [12, 19], [12, 20], [12, 21], [12, 22], [12, 23], [13, 14], [13, 15], [13, 16], [13, 17], [13, 18], [13, 19], [13, 20], [13, 21], [13, 22], [13, 23], [14, 15], [14, 16], [14, 17], [14, 18], [14, 19], [14, 20], [14, 21], [14, 22], [14, 23], [15, 16], [15, 17], [15, 18], [15, 19], [15, 20], [15, 21], [15, 22], [15, 23], [16, 17], [16, 18], [16, 19], [16, 20], [16, 21], [16, 22], [16, 23], [17, 18], [17, 19], [17, 20], [17, 21], [17, 22], [17, 23], [18, 19], [18, 20], [18, 21], [18, 22], [18, 23], [19, 20], [19, 21], [19, 22], [19, 23], [20, 21], [20, 22], [20, 23], [21, 22], [21, 23], [22, 23]] |
Tekintsünk például 1000 esetet! Készítsünk Java programot, amely 23 db véletlen születésnapot generál! Legyen ez a születésnap sorszáma az évben (másképpen hányadik napon született az ember az évben). Ez lényegesen egyszerűsíti a megoldást, összevetve a dátumkezelésen alapuló megközelítéssel. Ajánljuk a szakmai blog dátumkezelés címkéjét az érdeklődőknek, ahol megtalálhatók a témához kapcsolódó Java forráskódrészletek részletes magyarázatokkal kiegészítve. Íme a többféle generikus listát és programozási tételt használó forráskód:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
public static void main(String[] args) { final int COUNT=1000; ArrayList<String> list1=new ArrayList<>(); int count2=0; for(int i=1; i<=COUNT; i++) { ArrayList<Integer> dayList=new ArrayList<>(); for(int n=1; n<=23; n++) { int day=(int)(Math.random()*365+1); //1-365 dayList.add(day); } Collections.sort(dayList); System.out.println(dayList); ArrayList<String> list2=new ArrayList<>(); int n=0; while(n<dayList.size()) { int currentDay=dayList.get(n), count1=0; while(n<dayList.size() && dayList.get(n)==currentDay) { count1++; n++; } if(count1>1) list2.add(i+","+currentDay+","+count1); } if(!list2.isEmpty()) { list1.add(list2.toString()); count2++; } } System.out.println("\n"+list1+"\n"+COUNT+" esetből "+ count2+" kedvező eset fordult elő"); } |
Érdemes elemezni, tesztelni a fenti forráskódot: milyen lépésekben, milyen adatszerkezeteket épít. Hasznos lehet lambda kifejezésekkel kiegészíteni, módosítani a programot. Részlet a program szöveges eredményéből:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
[4, 14, 31, 34, 73, 85, 88, 110, 119, 125, 132, 140, 148, 183, 241, 249, 255, 265, 272, 289, 303, 353, 355] [7, 16, 40, 67, 72, 72, 79, 89, 96, 128, 141, 142, 203, 215, 217, 219, 230, 243, 250, 272, 273, 321, 325] [63, 70, 70, 87, 92, 106, 112, 113, 115, 123, 124, 131, 138, 139, 164, 165, 173, 177, 179, 180, 241, 310, 357] [45, 48, 73, 75, 94, 103, 117, 161, 168, 170, 202, 223, 231, 235, 240, 252, 254, 255, 260, 272, 274, 284, 301] [2, 2, 3, 13, 39, 47, 66, 94, 148, 151, 153, 160, 161, 166, 179, 212, 223, 254, 280, 311, 316, 324, 340] [5, 32, 36, 71, 74, 80, 96, 115, 120, 150, 167, 167, 169, 219, 255, 259, 283, 289, 304, 306, 317, 336, 359] [4, 5, 17, 46, 65, 78, 78, 79, 95, 106, 116, 138, 189, 228, 251, 253, 304, 332, 332, 334, 337, 347, 362] [12, 14, 15, 67, 76, 77, 113, 126, 154, 161, 184, 195, 204, 214, 216, 225, 225, 225, 227, 229, 235, 236, 348] [5, 7, 18, 28, 55, 71, 83, 126, 126, 129, 150, 158, 169, 221, 224, 231, 242, 253, 267, 300, 321, 326, 329] [19, 37, 47, 49, 80, 89, 94, 122, 145, 165, 174, 190, 211, 215, 241, 265, 286, 287, 295, 297, 325, 354, 361] ... [[2,72,2], [3,70,2], [5,2,2], [6,167,2], [7,78,2, 7,332,2], [8,225,3], [9,126,2]... 1000 esetből 506 kedvező eset fordult elő. |
A 12. sorban lévő számhármasok jelentése: esetszám 1-től, azonos nap, előfordulás száma. Például: a kísérlet során a 8. esetben az év 225. napja azonos 3 embernél. Természetesen nincs garancia arra, hogy az 1000 eset vizsgálatánál mindig 500-nál nagyobb kedvező esetet kapunk.
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 17-28. óra Objektumorientált programozás alkalmaihoz kötődik.
