2018 - címke - Oldal 2 a 5-ből

Programozási Hét 2018 – CodeWeek.eu

2023. július 26.2018. október 10. Szerző: Kaczur Sándor

Az Európai Programozási Hét idén 2018. október 6-21-ig került megrendezésre. Ez egy önkéntesek által működtetett, alulról szerveződő kezdeményezés. Az önkéntesek saját országukban a Programozási Hét nagyköveteként népszerűsítik a programozást. Ehhez nyílt és ingyenes eseményeket hirdetnek meg a CodeWeek.eu weboldalon.

A Programozási Hét célja

a programozással való alkotás megünneplése,
az emberek felvértezése képességekkel,
az emberek összekapcsolása,
még több ember érdeklődésének felkeltése a tudomány, a technológia, a mérnöki ismeretek és a matematika iránt.

Miért jó ez az érdeklődőknek/résztvevőknek?

A programozás szórakoztató!
Programozni kreatív tevékenység! Az emberiség a kezdetektől fogva alkot: agyagból, kőből, téglából, papírból vagy fából. Manapság programozással is alkotunk.
A programozás felvértez! Sokkal többre is képesek vagyunk annál, hogy csak fogyasszuk a digitális tartalmat; programozással sokféle dolgot alkothatunk, és azokat milliók számára elérhetővé tehetjük. Létrehozhatunk weboldalakat, játékokat, irányíthatunk egy számítógépet vagy egy robotot.
Értsük meg a világot! Manapság egyre több minden össze van kapcsolva. Ha némi rálátásunk van arra, hogy mi történik a színfalak mögött, akkor a világot is jobban megérthetjük.
A programozás megtanítja nekünk a számítógépes gondolkodást, fejleszti a problémamegoldást, kreativitást, kritikus érvelést, analitikus gondolkodást, valamint csapatmunkára késztet.
Manapság a munkahelyek 90%-a digitális készségeket, köztük programozási ismereteket követel a munkavállalóktól.

Én 2015-től veszek részt az esemény szervezésében, programozást népszerűsítő előadások, laborgyakorlatok meghirdetésével és megtartásával. 2017-ben 50+ országban 1,2 millió érdeklődő résztvevő csatlakozott.

Meghirdetett eseményeink

2018-ban három it-tanfolyam.hu-s eseményt hirdettünk meg Programozási Hét 2018 rendezvényen.
Helyszín: 1056 Budapest, Váci utca 47., 3. emelet 309-es terem, megközelítés
Dátum és időpont: 2018. október 10. 9:00-12:00-ig
Az események ingyenesek voltak, de a részvétel előzetes regisztrációhoz kötött.

Rendezvényünk plakátja

A rendezvény jó hangulatban telt, 53-an látogattak el hozzánk. Volt közöttük emelt szintű informatika érettségire készülő középiskolás csoport informatikatanárával együtt, tanfolyamaink iránt érdeklődő és jelentkezést fontolgató, Java SE szoftverfejlesztő tanfolyamunkat korábban sikeresen teljesítő hallgatók és olyan is, aki két hete járt nálunk először a Kutatók éjszakája 2018 rendezvényünkön. Az egyszerűbb lottószelvényes előadásnál elhangzott sok-sok kérdés és ötlet, az absztraktabb témákhoz már lényegesen kevesebb hozzászólás/kérdés érkezett, de azért elhangzott néhány. Igazán tartalmasan telt el ez a három óra. Köszönjük mindenkinek, aki részt vett a Programozási hét 2018 – CodeWeek.eu 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é.

9:00-10:00 – Kaczur Sándor: Generáljunk lottószelvényeket és hasonlítsuk össze megoldásainkat!
Véletlenszám-generátorral lottószelvényeket állítunk elő. Többféle ötletet, módszert, algoritmust, adatszerkezetet, tesztelési módszert összehasonlítva vizsgáljuk, hogy melyik a hatékonyabb lépésszámot, memóriaigényt, bonyolultságot tekintve. Java nyelven implementálunk és az érdeklődők javaslatait is azonnal beépíthetjük a forráskódba. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kapcsolódik. Előismeretként feltételezünk némi jártasságot programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök témakörökből.

10:00-11:00 – Kaczur Sándor: Írjunk hatékony adatbázis-lekérdezéseket!
Az Oracle HR sémában, először tipikus, hétköznapi szavakkal megfogalmazunk néhány lekérdezést, majd SQL nyelven megvalósítjuk és elemezzük, hogy helyesek-e, hatékonyak-e, mit adnak vissza. Szükség esetén optimalizáljuk, testre szabjuk ezeket. Kategóriák: egyszerű, összetett, aggregáló, soktáblás, hierarchikus/rekurzív lekérdezések. Ha lehet, grafikusan is megjelenítjük a lekérdezések eredményeit Java swing felületen, beépített JTable és JTree komponensekkel, illetve JFreeChart grafikonnal is. A Java adatbázis-kezelő tanfolyamunk tematikájához kötődik a program. Előismeretként feltételezünk némi jártasságot adatbázis-kezelés, SQL, Java swing felhasználói felület témakörökből.

11:00-12:00 – Kaczur Sándor: Építsünk látványos weboldalt XML fájlból megszerzett adatokból!
XML adatforrásban kapjuk egy cég alkalmazottainak adatait, amelyeket Java programmal feldolgozva, látványosan, animálhatóan megjelenítjük böngészőben az eredményt. Például: ki melyik részlegben dolgozik, kik dolgoznak az egyes részlegekben. Az érdeklődők igénye szerint a feladatot megoldhatjuk a következő technológiák közül választva: JavaScript, Bootstrap, jQuery. A Java EE szoftverfejlesztő tanfolyamunk tematikájához kötődik a program. Előismeretként feltételezünk némi jártasságot Java fájlkezelés, kivételkezelés, adatfeldolgozás, HTML, JavaScript témakörökből.

Kutatók éjszakája 2018

2023. augusztus 4.2018. szeptember 28. 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 sem maradt ki a sorból. Két oktatónk és két tanfolyamunkon résztvevő hallgatónk képviselt bennünket és meghirdettünk hat programot a kutatokejszakaja.hu weblapon. Az eseményekre regisztrálni kellett a weblapon, ami talán szervezőként ránk keresve bizonyult legegyszerűbbnek. A regisztrációs időszak szeptember 12-27-ig tartott és a programjainkra szeptember 28-án 17-21 óráig került sor.

A programjaink népszerűek voltak, 40 érdeklődő látogatót fogadtunk X generációtól szinte Alfákig. A többség több programon is részt vett, néhányan kifejezetten egy-egy adott program iránt érdeklődtek. Sok-sok kérdés is elhangzott és kellemes hangulatú szakmai párbeszéd alakult ki, aminek igazán örülök.

Szeretném megköszönni az előadók színvonalas munkáját, igényes felkészülését. 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é.

17:10-17:40 – Kaczur Sándor: Modellezzünk objektumorientáltan, közelítsünk többféle nézőpontból!
Az eseményen egy konkrét programozási feladat specifikációjából kiindulva tervezünk. Az objektumorientált szoftverfejlesztés eszközeit használjuk. Ötféle tervet készítünk el és hasonlítunk össze. Mindegyik terv Java nyelvű megvalósítását is ismertetjük. Adatfeldolgozást végzünk, fájlból olvasunk, saját adatszerkezetet építünk és azt feldolgozva adunk választ a specifikáció által megfogalmazott kérdésekre. Szembesülünk azzal, hogy a különböző terveknek mekkora hatása van az elkészült forráskódra, annak mennyiségére, áttekinthetőségére, karbantarthatóságára. Megpróbálunk következtetéseket is levonni, hogyan érdemes modellezni, tervezni, amikor hozzáfogunk egy-egy programozási feladat megoldásához.

17:50-18:20 – Friedel Attila: Egyszerű fizettető automata program fejlődése a programozó ismereteinek bővülése tükrében
Az előadás egy egyszerűen működő fizettető automata program három változatát mutatja be, ahogyan a programozó egyre több ismeretet szerez a Java nyelvről, és egyre gazdagabban tudja elkészíteni ugyanazt a feladatot. Először emlékezet nélkül, primitív típusú változókkal készül el az alapfunkciókkal rendelkező változat. A második verzió már tömböt is tartalmaz, emiatt új funkciók jelenhetnek meg. A harmadik, véglegesnek tekinthető változat nem hoz új funkciót, de a forráskód már objektumorientált szemlélettel készül el. A fokozatosság elvét szem előtt tartva követhetjük végig a gondolatmenet fejlődését, építve új eszközökre/lehetőségekre/funkciókra.

18:30-18:50 – Fejős Ibolya: Karrierváltás után: az első hónapok junior szoftverfejlesztőként egy kisvállalatnál
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 egy 20 fő alatti létszámmal működő informatikai profilú kisvállalkozásnál?
Az előadó karrierváltó junior szakemberként személyes tapasztalatairól számol be.

19:00-19:30 – Kaczur Sándor: Írjunk SQL lekérdezéseket és dolgozzuk fel webes Java kliensprogrammal az eredménytáblát!
A lekérdezések az Oracle HR sémát használják. Előfordulnak közöttük egyszerűbbek, klasszikus 1:N kapcsolatra építők, bölcsész mondatosak, hierarchikusak/rekurzívak. Különböző eredménytáblákat adnak vissza a kliensprogramnak. A kliensprogram többrétegű MVC tervezési mintával készül, böngészőben fut, alkalmazásszerveren, JSP technológiával.
Az előadás bemutatja a tervezési szempontokat, az SQL lekérdező utasításokat, az eredménytáblák feldolgozási módszereit, valamint a megjelenítés lehetőségeit.

19:40-20:10 – Sztefanov Ádám: Biztonságos weboldal készítése Java EE technológiával
Az előadás betekintést nyújt egy felhasználó számára, hogy miként válik egy weblap biztonságossá. Egy Java technológiát használó weboldal projekten keresztül láthatjuk azt, hogy miként működik a két lépcsős azonosítás.

Hálózati adatforgalom bemutatása, fogalmak tisztázása
Egy webalkalmazás sebezhető pontjai
Védekezési módszerek
Biztonságos bejelentkezés folyamatának bemutatása példa alkalmazáson keresztül
Tippek internetes fiókjaink biztonságosabbá tételéhez

20:20-20:50 – 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.

HWSW – Szeptemberi dupla – Android/Kotlin és full-stack JavaScript fejlesztői meetup

2023. december 22.2018. szeptember 13. Szerző: Friedel Attila

2018. szeptember 11-én és 12-én délután a HWSW szervezésében a Szeptemberi dupla: Android/Kotlin és full-stack JavaScript fejlesztői meetup-okon vettem részt az AnKERT-ben.

Kedd – Android/Kotlin fejlesztői meetup

Kedden az első előadó Ekler Péter volt, Android Pie újdonságai fejlesztői szemszögből című előadásával. Az általános újdonságokat követte néhány példa az energiafogyasztáshoz és testreszabáshoz kötődően: az Android rendszer:

úgy működjön, ahogyan a felhasználók jobban szeretnék használni – és persze ezáltal a Google még jobban megismerjen bennünket ;-),
alkalmazkodik a rendszer a mi életstílusunkhoz,
adaptívan korlátozni tudja a ritkán használt appoknál az akkumulátor-használatot (digitális jólét néven eladva),
adaptívan képes a fényerő beállítására (szürkeárnyalatos esti megjelenítés),
támogat új notification-öket (ez örökösen átalakul).

Elhangzó körkérdések voltak:

Mennyi ideig használunk egy-egy mobil alkalmazást?
Hány darab mobil alkalmazást használ a felhasználók többsége?
Ki találja hasznosnak a digitális jólét szolgáltatásokat?
Vajon mennyi változott (hány százalékot) az API 25-26-ra, 26-27-re, illetve 27-28-ra?

A válaszok érdekesnek, néha meglepőnek hatottak. Hasznos ötleteket kaptunk appok fejlesztéséhez, alkalmazkodva a felhasználói szokásokhoz.

A második előadás címe Kotlin 1.3 újdonságok volt, Balogh Tamás tartotta. Hasznos tippeket kaptunk a Kotlin konfigurációhoz, illetve függőségeinek megoldásához többféle fejlesztői eszközt érintve a gyakorló fejlesztő tapasztalataira építve. Újdonságok:

coroutine-ok experimental megjegyzéssel (működik, stabil, de egy későbbi új API verzióban fenntartott a jog, hogy megváltozhatnak és így törődni kell még velük),
előjel nélküli adattípusok példákkal (nem mintha ez lenne a legfontosabb, de néha kifejezetten hasznos lehet),
inline class-ok, intelligens bájtkód-beillesztésként magyarázható analógiával, mintegy kibővítve a korábbi inline function-ök lehetőségeit (nagyon tanulságos és eltalált volt a példaként bemutatott forráskód),
contract-ok (szerződés a fejlesztő és a fordító között).

A harmadik előadó Polacsek Attila volt és A pontonhíd az RxJava és a Data Binding között című bemutatójában körüljárta a reaktív UI-ban rendelkezésre álló adatkötés lehetőségeit, korlátjait, mindezt sok apró részletet is tartalmazó forráskód-részletekkel ismertetve.

Szerda – Full stack JavaScript fejlesztői meetup

Szerdán négy előadást hallgattam meg a JavaScript nyelvhez kapcsolódóan. Az első előadó Szabolcsi-Tóth Szabolcs volt, aki a nyelv eredetét, fejlődését ismertette. A JavaScript nyelv az Európai Számítógépgyártók Szövetsége (ECMA) által felügyelt, ECMA-262 számon és ECMA Script néven gondozott szabvány (https://www.ecma-international.org/publications-and-standards/standards/ecma-262/) egyik implementációja. Elsősorban webes alkalmazások számára készült. Az ECMA évente jelentet meg új változatot a szabványból. A nyelv fejlesztése teljesen nyitott, bárki küldhet be ajánlást egy-egy új funkció beépítésére. A koordináció github-on (https://tc39.es/ecma262/) keresztül zajlik. Az ECMA-262 tagok döntésén múlik, hogy az egyes ajánlások közül mi kerül be ténylegesen a nyelvbe – szigorúan szabályozott lépések sorozatát követően.

A második előadó Czibik Péter volt, aki 4 év full stack fejlesztői tapasztalatait osztotta meg velünk. Elmondta, hogy mi a különbség egy specialista és a full stack fejlesztő között, milyen előnyökkel illetve hátrányokkal járnak az egyes szerepek. Megerősített minket abban a hitünkben, hogy bár mindenhez nem lehet egyszerre érteni, ennek ellenére lehetséges olyan szerteágazó tudásra szert tenni (itt az adatbázis-backend-frontend hármasra gondolok) ami hatékonyan használható a munkában. Tapasztalata szerint náluk a RisingStack nevű cégnél először specialistákat képeznek, és onnan indulhatnak el a munkatársak a full stack irányba. Ismeretes náluk, hogy a full stack-es kollégák közül ki melyik szakterülethez ért a leginkább és ezen információ birtokában hatékonyabban tudnak együtt dolgozni az egyes projektek kivitelezése közben.

A harmadik előadóként Séra Bálint következett. Ő egy saját tapasztalatát mutatta be: hogyan lehet egy frontend-es számára optimális sorrendben betölteni a weboldalon az egyes JavaScript modulokat a lehető leggyorsabban úgy, hogy ne kelljen a felhasználónak egy üresnek látszó weboldal előtt várakoznia. Saját kódpéldákon keresztül mutatta be azt a folyamatot, ahogyan a JavaScript nyelv fejlődésével párhuzamosan bővültek a programozó lehetőségei. Először csak statikusan lehetett felsorolni a modulokat az oldal kódjában, ezzel rögtön egy sorrendiséget is meghatározva. Később erre a feladatra különböző keretrendszerek készültek. Az ES6-os JavaScript verziótól kezdve pedig szabványos eszköz áll a fejlesztő rendelkezésére, az import formájában.

Utolsó előadóként Miklós Bertalant hallgattuk meg. Ő is a nyelv fejlődésére épített, de sokkal inkább a felhasználó által tapasztalt élmény szemszögéből megközelítve a fejlesztő lehetőségeit. A JavaScript nyelv irányába is régebb óta megvolt az az igény, hogy gazdag animációs lehetőségeket tudjon biztosítani, mint a mára már elavult Flash vagy Silverlight technológiák. Ahogy ezek a lehetőségek elkezdtek megjelenni a nyelvben, úgy kezdtek megszületni a különböző keretrendszerek is, mint például a React, az Angular vagy a Single-page alkalmazások. Szerinte a mai weboldalak a progresszív megközelítést kell, hogy használják, ami egy-egy keretrendszerrel való megoldások készítése helyett inkább sok-sok kicsi ötletre épít, figyelembe véve az adott projekt szükségleteit, és ennek megfelelően alkalmazva néhány – a tarsolyban lapuló – eszköz keverékét.

Néhány előadás prezentációja letölthető.

Stream API lambda kifejezésekkel

2022. február 22.2018. augusztus 26. Szerző: Balogh Péter

Korábban blogoltunk már a Stream API-ról és a lambda kifejezésekről: Ismerkedjünk lambda kifejezésekkel! Most másképpen közelítve újra foglalkozunk a témával.

Tanfolyamainkon szinte minden adatszerkezethez, tömbhöz, kollekcióhoz, fájlkezeléshez kötődő témakörben használjuk mindkettőt. Áttekintjük az ezekhez szükséges minimális verziószámot, a szintaktika fejlődését, az együttes használat elvi és gyakorlati lehetőségeit. A szükséges alapfogalmakat definiáljuk: hozzárendelési szabály, funkcionális interfész, metódus referencia, alapértelmezett metódusok, típus kikövetkeztetés képessége, generikus és funkcionális programozás. párhuzamos adatfeldolgozás lehetőségei.

Összehasonlításokat is végzünk: a lambda előtti verziók lehetőségei, korlátai, tipikus lambda hibák, mikor mit érdemes és mit nem érdemes használni, paraméterek típusait megadjuk vagy elhagyjuk, hagyományos kollekciós műveletek (azért a generikusság előtti időkre már nem térünk ki) és folyam feldolgozás (adatforrás meghatározása, közbenső és végső műveletek).

Most azokat a Stream API-hoz és lambda kifejezésekhez kötődő bevezető mintapéldákat ismertetjük, amiket részletesen elemzünk tanfolyamaink szakmai moduljának kontakt óráin. Ezek közül közösen meg is írunk néhányat, kombinálunk is néhányat egy-egy összetett adatfeldolgozó művelet megvalósítása során. Programozási tételenként specifikáljuk a feladatokat és megmutatunk néhány megoldást.

1. Adatforrás

100 db olyan véletlen kétjegyű számot állítunk elő generikus listában, amelyek között biztosan előfordul legalább egyszer a 80.

List<Integer> list=new Random().ints(100-1, 10, 99+1).

boxed().collect(Collectors.toList());

list.add(80);

System.out.println("100 db kétjegyű véletlenszám\n"+

list.stream().sorted().map(Number::toString).

collect(Collectors.joining(", ")));

2. Elemi programozási tételek

2.1. Sorozatszámítás

Kiírjuk, hogy mennyi a listában lévő számok összege:

System.out.print("Mennyi a számok összege? ");

System.out.print("V1: "+

list.stream().reduce(0, Integer::sum)+", ");

System.out.print("V2: "+

list.stream().reduce(0, (a, b) -> a+b)+", ");

System.out.print("V3: "+

list.stream().mapToInt(Integer::intValue).sum()+", ");

System.out.println("V4: "+

list.stream().collect(Collectors.summingInt(Integer::intValue)));

2.2. Eldöntés

Két kérdésre adunk választ. Van-e a listában lévő számok között 35 (konkrét elem), illetve páros (adott tulajdonságú elem)?

System.out.print("Van-e a számok között 35? ");

System.out.print("V1: "+

(list.stream().anyMatch(n -> n==35)?"Van.":"Nincs.")+", ");

System.out.print("V2: "+

(list.stream().filter(n -> n==35).count()>0)+", ");

System.out.print("V3: "+

(list.stream().filter(n -> list.contains(35)).count()>0)+", ");

System.out.println("V4: "+

list.stream().filter(n -> n==35).findFirst().isPresent());

System.out.println("Van-e a számok között páros? "+

(list.stream().anyMatch(n -> n%2==0)?"Van.":"Nincs."));

2.3. Kiválasztás

Kiírjuk, hogy a biztosan előforduló (legalább 1 db közül balról az első) 80, hányadik helyen (index) található meg:

System.out.println("Melyik a(z első) 80 sorszáma? "+

IntStream.range(0, list.size()).

filter(i -> list.get(i)==80).mapToObj(i -> i).findFirst().get());

2.4. Keresés

Keressük a 35-öt az eldöntés és a kiválasztás összeépítésével:

System.out.println("Van-e 35? Ha igen, melyik a(z első) sorszáma? "+

(list.stream().anyMatch(n -> n==35) ?

"Van, a(z első) sorszáma: " + IntStream.range(0, list.size()).

filter(i -> list.get(i)==35).mapToObj(i -> i).findFirst().get() :

"Nincs."));

2.5. Megszámolás

Kiírjuk, hogy hány db öttel osztható szám (adott tulajdonságú elem) található a listában:

1 2	System.out.println("Az öttel osztható számok száma: "+ list.stream().filter(n -> n%5==0).count());

2.6. Szélsőérték-kiválasztás

Kiírjuk a listában lévő legkisebb számot (értéket, nem indexet):

1 2	System.out.println("A legkisebb szám: "+ list.stream().mapToInt(n -> n).min().getAsInt());

3. Összetett programozási tételek

3.1. Másolás

Készítünk egy másolatot a lista elemeiről (közben esetleg mindegyiket meg is változtathatjuk):

List<Integer> copyList=

list.stream()./*map(n -> 2*n).*/collect(Collectors.toList());

System.out.println("Másolat a listáról: "+

copyList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.2. Kiválogatás

A listában lévő számok közül kiválogatjuk az öttel osztható számokat:

List<Integer> selectedList=new ArrayList<>();

list.stream().filter(n -> n%5==0).forEach(selectedList::add);

System.out.println("Az öttel osztható számok (V1): "+

selectedList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

System.out.println("Az öttel osztható számok (V2): "+

list.stream().filter(n -> n%5==0).

map(Number::toString).collect(Collectors.joining(", ")));

3.3. Szétválogatás

Külön-külön szétválogatjuk a listában lévő páros és páratlan számokat:

List<Integer> evenList=new ArrayList<>(); //páros

List<Integer> oddList=new ArrayList<>(); //páratlan

list.stream().forEach(n -> ((n%2==0) ? evenList : oddList).add(n));

System.out.println("Szétválogatás után:\n"+

"párosak: "+

evenList.stream().map(Number::toString).

collect(Collectors.joining(", "))+"\n"+

"páratlanok: "+

oddList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.4. Unió

A korábban szétválogatott páros és páratlan számokat tartalmazó halmazok unióját állítjuk elő:

List<Integer> unionList=new ArrayList<>();

Stream.concat(evenList.stream().distinct(),

oddList.stream().distinct()).

distinct().forEach(unionList::add);

System.out.println("Párosak és páratlanok uniója:\n"+

unionList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.5. Metszet

A korábban szétválogatott páros és páratlan számokat tartalmazó halmazok metszetét állítjuk elő:

List<Integer> intersectionList=new ArrayList<>();

evenList.stream().distinct().filter(oddList::contains).

forEach(intersectionList::add);

System.out.println("Párosak és páratlanok metszete:\n"+

intersectionList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

3.6. Összefésülés

A korábban szétválogatott páros és páratlan számokat összefésüljük:

List<Integer> mergedList=new ArrayList<>();

Stream.concat(evenList.stream(),

oddList.stream()).forEach(mergedList::add);

System.out.println("Párosak és páratlanok összefésülve:\n"+

mergedList.stream().map(Number::toString).

collect(Collectors.joining(", ")));

4. A program eredménye a konzolon

100 db kétjegyű véletlenszám

10, 10, 10, 11, 13, 14, 16, 16, 18, 19, 19, 20, 21, 22, 23, 23, 24, 25, 25, 25, 26, 29, 29, 30, 30, 31, 32, 33, 34, 35, 36, 38, 38, 39, 39, 40, 42, 45, 45, 46, 47, 48, 49, 49, 50, 50, 51, 51, 53, 53, 54, 54, 54, 55, 56, 59, 61, 62, 62, 63, 63, 64, 67, 67, 68, 68, 69, 70, 72, 72, 73, 77, 77, 77, 77, 77, 79, 79, 79, 80, 81, 83, 84, 85, 85, 87, 87, 89, 89, 89, 89, 93, 95, 95, 95, 96, 97, 97, 98, 99

Mennyi a számok összege? V1: 5430, V2: 5430, V3: 5430, V4: 5430

Van-e a számok között 35? V1: Van., V2: true, V3: true, V4: true

Van-e a számok között páros? Van.

Melyik a(z első) 80 sorszáma? 99

Van-e 35? Ha igen, melyik a(z első) sorszáma? Van, a(z első) sorszáma: 22

Az öttel osztható számok száma: 23

A legkisebb szám: 10

Másolat a listáról: 20, 69, 48, 96, 19, 98, 11, 77, 49, 81, 79, 95, 70, 77, 67, 36, 23, 72, 38, 38, 54, 89, 35, 51, 83, 64, 26, 25, 51, 30, 89, 50, 22, 62, 95, 39, 42, 14, 10, 87, 54, 84, 24, 89, 16, 72, 97, 25, 85, 61, 59, 19, 13, 68, 55, 31, 79, 32, 47, 29, 18, 56, 10, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 40, 50, 29, 77, 16, 46, 99, 63, 45, 77, 97, 87, 89, 23, 30, 93, 95, 49, 68, 10, 34, 54, 33, 62, 79, 73, 80

Az öttel osztható számok (V1): 20, 95, 70, 35, 25, 30, 50, 95, 10, 25, 85, 55, 10, 25, 85, 45, 40, 50, 45, 30, 95, 10, 80

Az öttel osztható számok (V2): 20, 95, 70, 35, 25, 30, 50, 95, 10, 25, 85, 55, 10, 25, 85, 45, 40, 50, 45, 30, 95, 10, 80

Szétválogatás után:

párosak: 20, 48, 96, 98, 70, 36, 72, 38, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 54, 84, 24, 16, 72, 68, 32, 18, 56, 10, 40, 50, 16, 46, 30, 68, 10, 34, 54, 62, 80

páratlanok: 69, 19, 11, 77, 49, 81, 79, 95, 77, 67, 23, 89, 35, 51, 83, 25, 51, 89, 95, 39, 87, 89, 97, 25, 85, 61, 59, 19, 13, 55, 31, 79, 47, 29, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 29, 77, 99, 63, 45, 77, 97, 87, 89, 23, 93, 95, 49, 33, 79, 73

Párosak és páratlanok uniója:

20, 48, 96, 98, 70, 36, 72, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 84, 24, 16, 68, 32, 18, 56, 40, 46, 34, 80, 69, 19, 11, 77, 49, 81, 79, 95, 67, 23, 89, 35, 51, 83, 25, 39, 87, 97, 85, 61, 59, 13, 55, 31, 47, 29, 53, 21, 45, 63, 99, 93, 33, 73

Párosak és páratlanok metszete:

Párosak és páratlanok összefésülve:

20, 48, 96, 98, 70, 36, 72, 38, 38, 54, 64, 26, 30, 50, 22, 62, 42, 14, 10, 54, 84, 24, 16, 72, 68, 32, 18, 56, 10, 40, 50, 16, 46, 30, 68, 10, 34, 54, 62, 80, 69, 19, 11, 77, 49, 81, 79, 95, 77, 67, 23, 89, 35, 51, 83, 25, 51, 89, 95, 39, 87, 89, 97, 25, 85, 61, 59, 19, 13, 55, 31, 79, 47, 29, 53, 21, 25, 77, 85, 39, 45, 67, 63, 53, 29, 77, 99, 63, 45, 77, 97, 87, 89, 23, 93, 95, 49, 33, 79, 73

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.

Korábban is blogoltunk már a Stream API-ról és a lambda kifejezésekről: Ismerkedjünk lambda kifejezésekkel!

Időjárás Budapesten

2023. augusztus 4.2018. augusztus 15. Szerző: Kaczur Sándor

Talált időjárás Widget

A Widgets constructor – OpenWeatherMap weblapon nézelődve megtetszett ez a Widget:

Főleg az volt nagyon szimpatikus, hogy milyen egyszerűen beépíthető mindez egy webes/mobil felületre az alábbi JavaScript forráskóddal:

window.myWidgetParam ? window.myWidgetParam : window.myWidgetParam = [];

window.myWidgetParam.push({

id: 15,

cityid: '3054643',

appid: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',

units: 'metric',

containerid: 'openweathermap-widget-15',

});

(function() {

var script = document.createElement('script');

script.async = true;

script.charset = "utf-8";

script.src = "//openweathermap.org/themes/openweathermap/assets/vendor/owm/js/weather-widget-generator.js";

var s = document.getElementsByTagName('script')[0];

s.parentNode.insertBefore(script, s);

})();

Mindössze egy regisztráció szükséges hozzá a Members OpenWeatherMap weboldalon a fenti forráskódba behelyettesítendő API kódért. Az egy sorba ömlesztve kapott forráskódot a Javascript Viewer, Beautifier and Formatter, Editor weblapon formáztam könnyen olvashatóvá.

Saját fejlesztés

Kedvet kaptam ezt a funkcionalitást összerakni úgy, hogy a hálózati kommunikációra helyeztem a hangsúlyt.
A nézet réteg ezért igen egyszerű, Java swing felületen, JFrame form-ként varázsolt az alábbiak szerint, mindössze JPanel és JLabel vizuális komponensekből áll. Egy JLabel osztályú komponens képes szöveg és/vagy kép megjelenítésére is.

1. feladat

A modell rétegben tárolt település nevét és a szolgáltatás igénybevételéhez szükséges API kulcsot összerakva a Current weather data – OpenWeatherMap oldal specifikációját követve, megkapjuk az adatok lekérdezéséhez szükséges URL-t:

2. feladat

A hálózati kapcsolatot felépítve el kell kérni ( GET) az URL-ről kapott JSON formátumú adatot és tárolni kell azt a modellben ( jsonPuffer). A kivételkezelést nem részleteztem, mert most nem ezen van a hangsúly.

private void setJsonPuffer() {

jsonPuffer=new StringBuilder();

try {

HttpURLConnection c=

(HttpURLConnection)(new URL(API_URL_KEY)).openConnection();

c.setRequestMethod("GET");

c.connect();

InputStream is=c.getInputStream();

BufferedReader br=new BufferedReader(new InputStreamReader(is));

String line;

while((line=br.readLine())!=null)

jsonPuffer.append(line+"\r\n");

is.close();

c.disconnect();

}

catch(MalformedURLException e) {

System.out.println("Hiba: JSON URL...");

}

catch(ProtocolException e) {

System.out.println("Hiba: http, https, ftp...");

}

catch(IOException e) {

System.out.println("Hiba: JSON parser...");

}

A jsonPuffer objektum ezt tartalmazza:

A könnyen átlátható formátumot a JSON FORMATTER & VALIDATOR weblapon állítottam elő.

3. feladat

A JSON-t fel kell dolgozni és a különböző adatokat formázni/konvertálni kell, alkalmazkodva a megjelenítés igényeihez (például hőmérséklet Celsius fokban egész számra kerekítve, szélsebesség egytizedes pontossággal, hónap neve angolul, szükségesek a megfelelő mértékegységek). Külön gondoskodni kell arról, hogy az aktuális időjárást szimbolizáló ikonhoz (képként külön letöltve) is hozzájussunk, mert az API csupán az útvonalát jelentő URL-ből csak a fájl nevét (azonosítóját) adja meg. A kivételkezelést itt sem fejtettem ki.

private void jsonProcessing() {

try {

JSONObject json=new JSONObject(jsonPuffer.toString());

name=json.getString("name"); //település

country=json.getJSONObject("sys").getString("country"); //ország

weatherDescription=json.getJSONArray("weather").

getJSONObject(0).getString("description"); //leírás

JSONObject main=json.getJSONObject("main");

temp=(int)Math.round(main.getDouble("temp")-273.15); //hőmérséklet

wind=Double.parseDouble(new DecimalFormat("#,#").format(

json.getJSONObject("wind").getDouble("speed"))); //szélsebesség

humidity=main.getInt("humidity"); //páratartalom

pressure=main.getInt("pressure"); //légnyomás

dateTime=new SimpleDateFormat("hh:mm MMM dd", Locale.ENGLISH).

format(new Date(json.getLong("dt")*1000)); //dátum és idő

URL weatherIconURL=new URL("http://openweathermap.org/img/w/"+

json.getJSONArray("weather").getJSONObject(0).

getString("icon")+".png"); //ikon

weatherIcon = ImageIO.read(weatherIconURL);

}

catch(JSONException e) {

System.out.println("Hiba: JSON elemzése");

}

catch(MalformedURLException e) {

System.out.println("Hiba: icon URL...");

}

catch(IOException e) {

System.out.println("Hiba: icon...");

}

4. feladat

Végül a modelltől elkért adatokkal frissíteni kell a nézetet.

private void revalidateData() {

lbNameCountry.setText(modell.getOWMNameCountry());

lbWeatherDescription.setText(modell.getWeatherDescription());

lbWeatherIdIcon.setText("");

lbWeatherIdIcon.setIcon(new ImageIcon(modell.getWeatherIcon()));

lbTemp.setText(modell.getOWMTemp());

lbWind.setText(modell.getOWMWind());

lbHumidity.setText(modell.getOWMHumidity());

lbPressure.setText(modell.getOWMPressure());

lbDateTime.setText(modell.getOWMDateTime());

}

Az eredmény

IdojarasHouston

IdojarasTokyo

Aki kedvet kapott, annak többféle API is rendelkezésére áll, dokumentációval és példákkal együtt a https://openweathermap.org/api weboldalon. Kísérletezni bátran szabad, illetve érdemes megnézni és értelmezni azokat az adatokat, amiket JSON formátumban visszakapunk, de ehhez a feladathoz nem volt rájuk szükség.

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 EE szoftverfejlesztő tanfolyam 9-12. óra: XML feldolgozás és 13-16. óra: JSON feldolgozás alkalmaihoz kapcsolódik.