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

Keresztrejtvény készítése

2023. január 1.2021. április 23. Szerző: Kaczur Sándor

Támogatjuk a keresztrejtvények készítését Java programmal. A program grafikus felülete eszköztárból és a keresztrejtvényből áll. Az elkészült programban 10×10-től 15×15-ig beállítható négyzetrács készíthető elő. A tiltott négyzetek száma 15-től 30-ig beállítható. Mivel a tiltott négyzetek helyzete véletlenszerű, így nem biztos, hogy az elsőre jó/szerencsés lesz, ezért újragenerálható a négyzetrács. A program a tipikus követelményeknek megfelelően sorfolytonosan sorszámozza a négyzetrács elemeit, ami alapján megadhatók hozzá a vízszintes és függőleges feladványok. A program az elfogadott négyzetrácsot többféle képformátumban is el tudja menteni.

Az elkészült Java program grafikus felülete

Objektumorientált tervezés

A keresztrejtvény ábrája egy négyzetrácsból áll, amelyben rejtvénymezők helyezkednek el. A rejtvénymezőnek megfelel egy örökítéssel felüldefiniált címkekomponens. A rejtvénymezőt körülveszi egy szegély/keret, tiltott vagy sem állapotától függően fekete vagy fehér a háttérszíne, valamint van a bal felső sarkához igazított kis méretű betűvel nem kötelezően megjeleníthető sorszáma. A tiltott és sorszám tulajdonságait kell tudni beállítani és megkérdezni. Ez a feladatban a RejtvenyMezo POJO. A négyzetrács sorai és oszlopai azonos méretűek (pixelre és darabszámra egyaránt).

Algoritmus a keresztrejtvény sorszámozására

A rejtvénymezők kétdimenziós négyzetes mátrixban/tömbben helyezkednek el. A sorszámozáshoz hasznos, ha a négyzetrácsot körbeveszi egy tiltott rejtvénymezőkből álló keret. Először a rács sorain és oszlopain végighaladó egymásba ágyazott ciklusok létrehozzák a POJO-kat úgy, hogy a négyzetrács keretén lévő rejtvénymezők tiltottak, a többi nem tiltott. Ezután véletlenszerűen ki kell választani – a még nem tiltottak közül – a szükséges mennyiségű tiltott rejtvénymezőt. Ezután sorfolytonosan sorszámozni kell azokat a rejtvénymezőket, ahol vízszintes vagy függőleges feladvány kezdődik. Ehhez is két egymásba ágyazott ciklus kell, amelyben minden még nem tiltott rejtvénymező egyre növekvő sorszámot kap, ha tőle balra tiltott és tőle jobbra nem tiltott rejtvénymező helyezkedik el, de akkor is, ha felette tiltott és alatta nem tiltott rejtvénymező található.

A keresztrejtvényt sorszámozó algoritmus Java megvalósítása

private RejtvenyMezo[][] keresztrejtveny(

final int RACS_MERET, int TILTOTT_DB) {

RejtvenyMezo[][] t=new RejtvenyMezo[RACS_MERET+2][RACS_MERET+2];

for(int i=0; i<=RACS_MERET+1; i++)

for(int j=0; j<=RACS_MERET+1; j++)

t[i][j]=new RejtvenyMezo();

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

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

t[i][j].setTiltott(false);

int tiltottDb=0;

while(tiltottDb<TILTOTT_DB) {

int i=(int)(Math.random()*RACS_MERET)+1;

int j=(int)(Math.random()*RACS_MERET)+1;

if(!t[i][j].isTiltott()) {

t[i][j].setTiltott(true);

tiltottDb++;

}

int sorszam=1;

for(int i=0; i<=RACS_MERET+1; i++)

for(int j=0; j<=RACS_MERET+1; j++)

if(!t[i][j].isTiltott())

if((t[i-1][j].isTiltott() && !t[i+1][j].isTiltott()) ||

(t[i][j-1].isTiltott() && !t[i][j+1].isTiltott())) {

t[i][j].setSorszam(sorszam);

sorszam++;

}

return t;

}

Továbbfejlesztési lehetőségek

A feladványok listázhatók és kideríthető a hosszuk.
A tiltott rejtvénymezők véletlenszerű elhelyezése helyett lehetne valamilyen szabály, stratégia az egymáshoz való helyzetükre, távolságukra, közvetlen szomszédságukra vonatkozóan. Figyelembe vehetnénk valamilyen szimmetriát is, mintákat, alakzatokat is. Véletlenszerű elhelyezésük nem biztos, hogy mindig jó/szerencsés: például a tiltott rejtvénymezők körbezárhatnak egy nem tiltottat, hosszabb feladványokat nehezebb találni…
A Java SE szoftverfejlesztő tanfolyam tematikájához kötődően többféle szótárból, fájlformátumból betölthetünk a feladványokhoz használható, például 7 betűs országnevek, 2 betűs kémiai elemek, női/férfi keresztnevek, autójelek, pénznemek, szinonimák…
A Java EE szoftverfejlesztő tanfolyam tematikához kötődően többféle webes adatforrásból, Wikipédiából, szótárból, API hívásokkal letölthetünk a feladványokhoz használható listákat, meghatározásokat, kulcs-érték párokat. A swing-es felületet lecserélhetjük böngészőben futó webes GUI-ra is.
A Java adatbázis-kezelő tanfolyam tematikájához kötődően a fentiek kiegészítéseként tervezhetünk és építhetünk helyben tárolt tudástárat, adatbázist, amiből hatékonyan lekérdezve adhatunk feladványokat a keresztrejtvényhez.
Miután a fentiek szerint valahogyan – tipikusan visszalépéses algoritmussal – meghatároztuk a feladványokat, a keresztrejtvényből menthetünk kitöltött változatot is.

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

Rómeó és Júlia

2023. augusztus 4.2021. február 14. Szerző: Kaczur Sándor

Vajon hogyan kerül elő a Rómeó és Júlia az it-tanfolyam.hu szakmai blogban témaként? Hiszen mégiscsak egy Shakespeare színműről/tragédiáról van szó. Vajon mit programozhatunk Java nyelven ehhez kötődően épp Valentin-napon? Mindjárt kiderül.

Tegyünk fel egy kérdést és próbáljunk rá válaszolni! Vajon ki szereti jobban a másikat? Rómeó vagy Júlia?

Induljunk el az adatforrásból, amihez alkalmazkodnunk kell. A színmű angol nyelven publikusan elérhető XML formátumban: The Tragedy of Romeo and Juliet. Az XML fájlok könnyen feldolgozhatók Java nyelven. Részletek a fájlból (görgethető):

<?xml version="1.0"?>

<LINE>Two households, both alike in dignity,</LINE>

<LINE>In fair Verona, where we lay our scene,</LINE>

<LINE>From ancient grudge break to new mutiny,</LINE>

<LINE>Where civil blood makes civil hands unclean.</LINE>

...

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE>Is the day so young?</LINE>

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE>Stay, fellow; I can read.</LINE>

<STAGEDIR>Reads</STAGEDIR>

<LINE>'Signior Martino and his wife and daughters;</LINE>

<LINE>County Anselme and his beauteous sisters; the lady</LINE>

...

<LINE>assembly: whither should they come?</LINE>

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE><STAGEDIR>To JULIET</STAGEDIR> If I profane with my unworthiest hand</LINE>

<LINE>This holy shrine, the gentle fine is this:</LINE>

<LINE>My lips, two blushing pilgrims, ready stand</LINE>

<LINE>To smooth that rough touch with a tender kiss.</LINE>

</SPEECH>

<STAGEDIR>Enter JULIET</STAGEDIR>

</ACT>

Az XML fájl felépítését tanulmányozva (1-5 alapján) megállapíthatóak az alábbiak:

A színmű öt felvonásból áll, ezeket <ACT></ACT> csomópontok jelölik.
Egy „adagnyi” beszédet a <SPEECH></SPEECH> csomópont fog össze.
A csomópontban található, hogy ki beszél: ez a <SPEAKER></SPEAKER> elem. A mesélő, kar esetén ez az elem üres, és a null-t nem szabad feldolgozni.
A csomópontban találhatók a szabadvers kimondott sorai: ezek a <LINE></LINE> elemek. Legalább egy sor minden beszédben van, és nem tudjuk előre a számukat.
Nem következetes helyen a DOM-ban, többféleképpen beágyazva és önállóan is előfordulhatnak <STAGEDIR></STAGEDIR> elemek. Ezek a színmű Kosztolányi-féle magyar fordításában dőlt betűvel megjelenő – cselekvésre utaló – színpadi utasítások. Van köztük csók is, amit az XML-ből nem szabad feldolgozni, bár erősen ráutaló magatartás. 🙂
Nem tudjuk előre, hogy hány csomópont található a fájlban.

A Java program készítése, tesztelése közben – mintegy mellékesen – megtudhatjuk, hogy Rómeó 612 sorban 24075 betűnyi, Júlia 544 sorban 21855 betűnyi szöveget mond. Persze nem mindet egymásnak mondják. Eközben vajon hányszor mondják ki a szeret, szeretem, szeretlek szavakat? A ragoktól, toldalékoktól, kis- és nagybetűket nem megkülönböztetve és attól is eltekintve, hogy éppen kinek/kiknek mondják amit éppen mondanak, egy becsléshez elegendő, ha a love szóra fókuszálunk (számíthatna a loving alak is).

Az alábbi Java forráskód betölti az XML fájlt a memóriába. Ezután kiválogatja a beszédeket. Ha a beszélő élő ember (szereplő), akkor érdekes, hogy mit/miket mond. Ha ROMEO vagy JULIET mondja az adott sort, akkor azt a program kiválogatja két generikus listába ( romeoLineList és julietLineList) beszédnyi adagokban. Ez nem szétválogatás programozási tétel, mert nem minden beszéd minden sora kerül valahová. A kivételkezelés nem kidolgozott.

private static ArrayList<String> getLineList(final Node SPEECH) {

ArrayList<String> lineList=new ArrayList<>();

NodeList nodeList=((Element)SPEECH).getElementsByTagName("LINE");

for(int i=0; i<nodeList.getLength(); i++) {

String line=

((Element)nodeList.item(i)).getFirstChild().getNodeValue();

lineList.add(line);

}

return lineList;

}

public static void main(String[] args) {

ArrayList<String> romeoLineList=new ArrayList<>();

ArrayList<String> julietLineList=new ArrayList<>();

try {

NodeList speechList=DocumentBuilderFactory.newInstance().

newDocumentBuilder().parse(new File("./files/r_and_j.xml")).

getDocumentElement().getElementsByTagName("SPEECH");

for(int i=0; i<speechList.getLength(); i++) {

Node speech=speechList.item(i);

Node speaker=((Element)speech).getElementsByTagName("SPEAKER").

item(0).getFirstChild();

if(speaker!=null)

switch(speaker.getNodeValue()) {

case "ROMEO":

romeoLineList.addAll(getLineList(speech));

break;

case "JULIET":

julietLineList.addAll(getLineList(speech));

}

catch(ParserConfigurationException | SAXException | IOException e) {

e.printStackTrace();

}

//...

}

Könnyen megkaphatjuk, hogy Rómeó hány darab olyan sort mond, amely tartalmazza a love szót. Például ennek a lambda kifejezésnek kiíratva az eredményét a konzolra:

romeoLineList.stream().

filter(f->f!=null).filter(f->f.toLowerCase().contains("love")).

count();

Könnyen megkaphatjuk Rómeótól a 53 sornyi szöveget is így:

romeoLineList.stream().

filter(f->f!=null).filter(f->f.toLowerCase().contains("love")).

forEach(line->System.out.println(line));

Íme Rómeó kiválogatott sorai (az 5. sorban kétszer is előfordul a love, de ez most nem számít):

Out of her favour, where I am in love.

Alas, that love, whose view is muffled still,

Here's much to do with hate, but more with love.

Why, then, O brawling love! O loving hate!

This love feel I, that feel no love in this.

Why, such is love's transgression.

With more of thine: this love that thou hast shown

Love is a smoke raised with the fume of sighs;

Being purged, a fire sparkling in lovers' eyes;

Being vex'd a sea nourish'd with lovers' tears:

In sadness, cousin, I do love a woman.

A right good mark-man! And she's fair I love.

From love's weak childish bow she lives unharm'd.

She hath forsworn to love, and in that vow

widow of Vitravio; Signior Placentio and his lovely

One fairer than my love! the all-seeing sun

Under love's heavy burden do I sink.

Is love a tender thing? it is too rough,

Did my heart love till now? forswear it, sight!

It is my lady, O, it is my love!

O, that I were a glove upon that hand,

Call me but love, and I'll be new baptized;

With love's light wings did I o'er-perch these walls;

For stony limits cannot hold love out,

And what love can do that dares love attempt;

And but thou love me, let them find me here:

Than death prorogued, wanting of thy love.

By love, who first did prompt me to inquire;

If my heart's dear love--

The exchange of thy love's faithful vow for mine.

Wouldst thou withdraw it? for what purpose, love?

Love goes toward love, as schoolboys from

But love from love, toward school with heavy looks.

How silver-sweet sound lovers' tongues by night,

Then plainly know my heart's dear love is set

And bad'st me bury love.

I pray thee, chide not; she whom I love now

Doth grace for grace and love for love allow;

A gentleman, nurse, that loves to hear himself talk,

Then love-devouring death do what he dare;

Tybalt, the reason that I have to love thee

But love thee better than thou canst devise,

Till thou shalt know the reason of my love:

Wert thou as young as I, Juliet thy love,

My conceal'd lady to our cancell'd love?

No nightingale: look, love, what envious streaks

That may convey my greetings, love, to thee.

And trust me, love, in my eye so do you:

Ah me! how sweet is love itself possess'd,

When but love's shadows are so rich in joy!

By heaven, I love thee better than myself;

Call this a lightning? O my love! my wife!

Here's to my love!

Hasonlóan megkaphatjuk Júlia 38 kiválogatott sorát is:

My only love sprung from my only hate!

Prodigious birth of love it is to me,

That I must love a loathed enemy.

Or, if thou wilt not, be but sworn my love,

Dost thou love me? I know thou wilt say 'Ay,'

Thou mayst prove false; at lovers' perjuries

If thou dost love, pronounce it faithfully:

My true love's passion: therefore pardon me,

And not impute this yielding to light love,

Lest that thy love prove likewise variable.

This bud of love, by summer's ripening breath,

My love as deep; the more I give to thee,

I hear some noise within; dear love, adieu!

If that thy bent of love be honourable,

Remembering how I love thy company.

O, she is lame! love's heralds should be thoughts,

Therefore do nimble-pinion'd doves draw love,

My words would bandy her to my sweet love,

Sweet, sweet, sweet nurse, tell me, what says my love?

'Your love says, like an honest gentleman,

But my true love is grown to such excess

Spread thy close curtain, love-performing night,

Lovers can see to do their amorous rites

By their own beauties; or, if love be blind,

With thy black mantle; till strange love, grown bold,

Think true love acted simple modesty.

That all the world will be in love with night

O, I have bought the mansion of a love,

My dear-loved cousin, and my dearer lord?

Believe me, love, it was the nightingale.

Art thou gone so? love, lord, ay, husband, friend!

To wreak the love I bore my cousin

But thankful even for hate, that is meant love.

I will confess to you that I love him.

To live an unstain'd wife to my sweet love.

Love give me strength! and strength shall help afford.

And gave him what becomed love I might,

What's here? a cup, closed in my true love's hand?

Próbáljunk válaszolni a fentiek alapján a feltett kérdésre! Következtethetünk arra, hogy Rómeó jobban szereti Júliát. Legalábbis többször említi. 53>38. Persze tudjuk, hogy mindez nem ilyen egyszerű. 🙂

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 21-24. óra: Objektumorientált programozás 2. rész, 25-28. óra: Objektumorientált programozás 3. rész, valamint a Java EE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: XML feldolgozás alkalmaihoz kötődik.

Nagyon különböző megoldásokat készíthetünk és szerteágazóan gyakorolhatunk, ha:

az XML fájlt kézzel mentjük a webről és utána a helyi fájlrendszerből dolgozzuk fel,
az XML fájlt közvetlenül a webről, dinamikusan olvassuk,
csak beépített XML-feldolgozást használunk,
külső XML API-t használunk,
DOM, SAX, XSL, van-e DTD,
XPath kifejezésekkel adunk választ a kérdésre,
a fenti didaktikusan egyszerű megoldás helyett haladóbb eszközöket (például: Stream API-t) használunk.

Céline Dion – Courage World Tour

2023. január 1.2020. június 1. Szerző: Kaczur Sándor

A Céline Dion – Courage World Tour esettanulmányunkban a turné első részének koncerthelyszíneit jelenítjük meg Google Charts segítségével. Ebben a blog bejegyzésben a tervezés, megvalósítás lépéseit tekintjük át és megmutatjuk az eredményeket. A Java és JavaScript forráskódokat most nem részletezzük.

Háromféle grafikont használunk

idővonal (Timeline) időpontok és helyszínek Gantt diagram-szerűen,
térkép (Geo Chart) városok megjelölésével és időpontok jelmagyarázatban,
tematikus térkép az USA államaival (szintén Geo Chart), az állam területén adott koncertek száma alapján és db jelmagyarázatban.

A tervezés és megvalósítás lépései

Adatokat kell szerezni egy weboldal (https://www.celinedion.com/in-concert/) feldolgozásával ( saveHTML()). Ehhez a művelet a GET. Figyelni kell a megfelelő User-Agent paraméterezésére és a karakterkódolásra ( ISO-8859-1). A kapott bemeneti folyam feldolgozását pufferelt módon érdemes elvégezni. Célszerű az adatforgalom minimalizásása érdekében a weboldal tartalmát helyi fájlba menteni ( tour.html). Ügyelni kell a kötelező és az ajánlott kivételkezelésre.
Értelmezni kell a tour.html fájlt. A HTML tartalom végén JSON formátumban beágyazva elérhetők a koncert turné állomásainak adatai: nekünk kell a város ( city), helyszín ( venue), dátum/idő ( startDate). Érdemes külön fájlba menteni a tour.html-ből a JSON tartalmat ( tour.json), mert abból egyszerűen betölthető ( saveJSON()).
Tanulmányozni kell a Google Charts diagramok közül azt a kettőt, amiket testre kell szabni: Timeline és Geo Chart. Tudni kell: mi a diagramot tartalmazó weboldal állandónak tekinthető eleje és vége (ezeket hasznos külön interfészben konstansként tárolni: HTMLFileContent), valamint mi az adatoktól függő része (közepe). Ismerni kell a szükséges metaadatok és adatok formátumát. Érdemes átnézni a különböző testre szabási és formázási lehetőségeket a fenti diagramtípusoknál (esetleg a többi típusból is meríthetünk ötleteket).
A koncert turné állomásainak összetartozó 3 adatát le kell képezni POJO-vá ( Event). Ezt érdemes privát változókkal ( city, venue, startDate) és factory metódussal megvalósítani. Célszerű, ha az adatok visszakérésére alkalmas getter metódusok is készülnek ( getTimelineChartDataTableRow(), getGeoChartDataTableRow()), amelyek kiszolgálják a megfelelő diagramtípus igényeit.
A tour.json fájl feldolgozásával (parszolásával) Event típusú generikus listába vagy JSON tömbbe könnyen leképezhetők az adatok.
Hasznos egy vezérlőosztály létrehozása, amely a 3 diagramtípust előállító (HTML fájlt generáló) metódust ( createTimelineChart(), createGeoChartCity(), createGeoChartCountry()) valamint a belépési pontot ( main()) tartalmazza.
Generálható az idővonalat tartalmazó timelineChart.html fájl a createTimelineChart()metódussal. Ehhez 5 oszlop megadása szükséges (ebben a sorrendben): label, city, tooltip, start, end. Az első 3 adat string, az utolsó 2 adat date típusú. Egy példa Event: ['2019.09.18.', 'Québec, QC', 'Videotron Centre', new Date(2019, 09, 18, 19, 0, 0), new Date(2019, 09, 18, 21, 0, 0)].
Regisztrálni kell egy Google Cloud Platform felhasználói fiókot és tanulmányozni kell a geokódolás folyamatát és lehetőségeit, hiszen a városok nevéből (formátum pl.: 'Minneapolis, MN') szükség lesz azok térképi koordinátáira. Aktiválni kell a szolgáltatás használatához szükséges mapsApiKey-t.
Generálható a városokat tartalmazó geoChartCity.html fájl a createGeoChartCity() metódussal. Ehhez 3 oszlop megadása szükséges (ebben a sorrendben): city, dateCity, no . Egy példa Event: ['Minneapolis, MN', '2019.11.01. Minneapolis, MN', 1].
Generálható a régiókat/államokat tartalmazó geoChartCountry.html fájl a createGeoChartCountry() metódussal. Ez egy tematikus térkép: a különböző színek jelölik az egy régió/állam városaiban tartott koncertek számát. Ehhez az adatok megfelelő rendezését követően végrehajtott csoportváltás algoritmus szükséges. 2 oszlop megadása szükséges: country, concertNo. Egy példa adatsor: ['US-TX', 3].

Az eredmények

TimelineChart grafikon:

GeoChartCity grafikon:

GeoChartCountry grafikon:

Érdemes megismerni további – térképekhez kapcsolódó – grafikontípusokat is: Geomap, Intensity Map.

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 példák a Java SE szoftverfejlesztő tanfolyam 37-44. óra: Fájlkezelés és a Java EE szoftverfejlesztő tanfolyam 1-4. óra: Elosztott alkalmazások, webszolgáltatások és 13-16. óra: JSON feldolgozás alkalmaihoz kötődnek.

Egy matematika érettségi feladat megoldása programozással 2020

2023. január 3.2020. május 6. Szerző: Kaczur Sándor

A 2020-as emelt szintű matematika érettségi feladatsor 9. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá kollekció adatszerkezet és néhány programozási tétel. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor a megoldásokkal együtt letölthető az oktatas.hu-ról.

2018-ban és 2019-ben is kiválasztottam egy-egy matematika érettségi feladatot a középszintű feladatlapról és megoldottam Java nyelven. 2020-ban az emelt szintű feladatsornál lelkesedtem eléggé, hogy blogoljak róla.

9. feladat

Egy városban a közösségi közlekedést kizárólag vonaljeggyel lehet igénybe venni, minden utazáshoz egy vonaljegyet kell váltani. A vonaljegy ára jelenleg 300 tallér. Az utazások száma naponta átlagosan 100 ezer. Ismert az is, hogy ennek kb. 10%-ában nem váltanak jegyet (bliccelnek).
A városi közlekedési társaság vezetői hatástanulmányt készíttettek a vonaljegy árának esetleges megváltoztatásáról. A vonaljegy árát 5 talléronként lehet emelni vagy csökkenteni. A hatástanulmány szerint a vonaljegy árának 5 talléros emelése várhatóan 1000-rel csökkenti a napi utazások számát, és 1 százalékponttal növeli a jegy nélküli utazások (bliccelések) arányát. (Tehát például 310 talléros jegyár esetén naponta 98000 utazás lenne, és ennek 12%-a lenne bliccelés.) Ugyanez fordítva is igaz: a vonaljegy árának minden 5 talléros csökkentése 1000-rel növelné a napi utazások számát, és 1 százalékponttal csökkentené a bliccelések arányát. A tanulmány az alkalmazott modellben csak a 245 tallérnál drágább, de 455 tallérnál olcsóbb lehetséges jegyárakat vizsgálta.

a) Mekkora lenne a közlekedési társaság vonaljegyekből származó napi bevétele a hatástanulmány becslései alapján, ha 350 tallérra emelnék a vonaljegyek árát?
b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Tervezés

Értelmezve a feladatot és a feltett kérdéseket: adódik, hogy a megoldáshoz szükséges egy POJO, ami az összetartozó adatokat fogja egybe objektumként. Mivel több kell belőle, célszerű egy indexelhető adatszerkezet, például tömb vagy lista. Ékezettelen magyar elnevezéseket fogok használni. A POJO osztály neve legyen Kozlekedes és a beszédes nevű tulajdonságai legyenek a következők: vonaljegyAr, napiUtasszam, bliccelesSzazalek, napiBevetel. Mindegyik nemnegatív egész szám és belefér az int primitív típus számábrázolási tartományába.

Ha a konstruktor paraméterként átveszi az input vonaljegyAr-at, akkor abból a többi adatot egyszerű képletekkel előállíthatja. Hasznos, ha a konstruktor ellenőrzést is végez. A tanulmány az alkalmazott modellben limitálja a vonaljegy árát (250 és 450 közötti öttel osztható számként). Az öttel oszthatóság az emelés/árváltozás mértékéből adódik. Ha a vonaljegy ára nem megfelelő, akkor a konstruktor kivételt dob, amivel megakadályozza, hogy az alkalmazott modellhez nem illeszkedő tulajdonságokkal rendelkező objektum létrejöjjön.

Az output meghatározásához az a) és b) feladatban megfogalmazott kérdésekből kell kiindulni. Ezekből adódik, hogy szükséges két getter metódus a POJO-ba: getVonaljegyAr() és getNapiBevetel(). Persze könnyen generáltatható az összes getter is, de setter nem kell. Ezeken kívül a tesztelés megkönnyítésére hasznos egy toString() metódus is, amellyel a 4 összetartozó adat hozzáférhető és megjeleníthető a konzolon.

A belépési pont és egyben a vezérlés egy másik osztályban valósul meg. Itt feltöltjük a tanulmány alkalmazott modelljének megfelelően előállított objektumokkal (memóriacímeikkel) a generikus listát, amit programozási tételekkel (kiválasztás, szélsőérték-kiválasztás) dolgozunk fel.

A POJO osztály forráskódja

public class Kozlekedes {

private int vonaljegyAr; //pl.: 300 tallér

private int napiUtasszam; //pl.: 100000 fő

private int bliccelesSzazalek; //pl.: 10%

private int napiBevetel; //pl.: 27000000 tallér

public Kozlekedes(int vonaljegyAr) {

if(vonaljegyAr<=245 || vonaljegyAr>=455 || vonaljegyAr%5!=0)

throw new IllegalArgumentException(

"A vonaljegy ára nem megfelelő. (Hibakód: 32596)");

this.vonaljegyAr=vonaljegyAr;

napiUtasszam=100000-(vonaljegyAr-300)/5*1000;

bliccelesSzazalek=10+(vonaljegyAr-300)/5;

napiBevetel=(vonaljegyAr*

(int)(napiUtasszam*(100-bliccelesSzazalek)/100.0));

}

public int getVonaljegyAr() {

return vonaljegyAr;

}

public int getNapiBevetel() {

return napiBevetel;

}

@Override

public String toString() {

return

"Közlekedés {\n"+

" vonaljegy ár: "+vonaljegyAr+" tallér\n"+

" napi utasszám: "+napiUtasszam+" fő\n"+

" bliccelés: "+bliccelesSzazalek+"%\n"+

" napi bevétel: "+napiBevetel+" tallér\n"+

"}";

}

A vezérlő osztály forráskódja

public class MatErettsegi2020EmeltFeladat9 {

private static void feladat9(List<Kozlekedes> lista) {

//a) feladat

int i=0;

while(lista.get(i).getVonaljegyAr()!=350)

i++;

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

lista.get(i).getNapiBevetel()+" tallér lenne a napi bevétel.\n");

//b) feladat

int maxIndex=0;

for(i=1; i<lista.size(); i++)

if(lista.get(i).getNapiBevetel()>

lista.get(maxIndex).getNapiBevetel())

maxIndex=i;

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

lista.get(maxIndex).getVonaljegyAr()+" tallér lenne.\n");

}

public static void main(String[] args) {

List<Kozlekedes> lista=new ArrayList<>();

for(int vonaljegyAr=250; vonaljegyAr<=450; vonaljegyAr+=5)

lista.add(new Kozlekedes(vonaljegyAr));

// for (Kozlekedes kozlekedes : lista)

// System.out.println(kozlekedes);

// System.out.println();

feladat9Megoldas1(lista);

// feladat9Megoldas2();

}

A main() metódus feltölti a generikus lista adatszerkezetet az alkalmazott modellben lehetséges/előforduló vonaljegyAr alapján létrehozott objektumokkal (a memóriacímükkel). A feladat9Megoldas1() metódus paraméterként átveszi a feldolgozandó listát.

Az a) feladatra a választ kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a vonaljegyAr egyenlő 350-nel? A ciklust követően megkapjuk, hogy az i-edik az, amelyikre igaz a feltétel. (Az nem merül fel, hogy van-e ilyen objektum, hiszen tudjuk, hogy van. Csak az a kérdés, hogy melyik az. Több sem lehet.) A lista.get(i).getNapiBevetel() művelettel elkérjük az i-edik objektumtól a válaszadáshoz szükséges napi bevételt.

A b) feladatra a választ szélsőérték-kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a napiBevetel a maximális? (Mivel a lista nem üres, így létezik a legnagyobb napi bevétel. Mivel nem biztos, hogy a legnagyobb napi bevétel egyedi, ezért merül fel az első a kérdésben.) Tegyük fel, hogy a nulladik objektumra igaz a feltétel: azaz maxIndex=0. Később a ciklusban változtassuk meg a maxIndex-et, ha a feldolgozás során találunk nagyobb értéket. Szélsőérték-kiválasztásnál a kezdeti elemet nem hasonlítjuk össze saját magával (hiszen úgysem különbözne), ezért indul a for ciklus 1-ről. A ciklust követően a lista.get(maxIndex).getVonaljegyAr() művelettel elkérhetjük a maxIndex-edik objektumtól a válaszadáshoz szükséges vonaljegy árát.

A program által felépített adatszerkezet

Ha a vezérlőben aktiváljuk a megjegyzésben szereplő kiíratást, akkor a konzolon megjelennek a main() metódusban létrehozott listában lévő objektumok adatai (amilyen viselkedést a POJO toString()-jébe programoztunk. A 246 soros szöveg görgetéssel megtekinthető.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

Közlekedés {

vonaljegy ár: 250 tallér

napi utasszám: 110000 fő

bliccelés: 0%

napi bevétel: 27500000 tallér

}

Közlekedés {

vonaljegy ár: 255 tallér

napi utasszám: 109000 fő

bliccelés: 1%

napi bevétel: 27517050 tallér

}

Közlekedés {

vonaljegy ár: 260 tallér

napi utasszám: 108000 fő

bliccelés: 2%

napi bevétel: 27518400 tallér

}

Közlekedés {

vonaljegy ár: 265 tallér

napi utasszám: 107000 fő

bliccelés: 3%

napi bevétel: 27504350 tallér

}

Közlekedés {

vonaljegy ár: 270 tallér

napi utasszám: 106000 fő

bliccelés: 4%

napi bevétel: 27475200 tallér

}

Közlekedés {

vonaljegy ár: 275 tallér

napi utasszám: 105000 fő

bliccelés: 5%

napi bevétel: 27431250 tallér

}

Közlekedés {

vonaljegy ár: 280 tallér

napi utasszám: 104000 fő

bliccelés: 6%

napi bevétel: 27372800 tallér

}

Közlekedés {

vonaljegy ár: 285 tallér

napi utasszám: 103000 fő

bliccelés: 7%

napi bevétel: 27300150 tallér

}

Közlekedés {

vonaljegy ár: 290 tallér

napi utasszám: 102000 fő

bliccelés: 8%

napi bevétel: 27213600 tallér

}

Közlekedés {

vonaljegy ár: 295 tallér

napi utasszám: 101000 fő

bliccelés: 9%

napi bevétel: 27113450 tallér

}

Közlekedés {

vonaljegy ár: 300 tallér

napi utasszám: 100000 fő

bliccelés: 10%

napi bevétel: 27000000 tallér

}

Közlekedés {

vonaljegy ár: 305 tallér

napi utasszám: 99000 fő

bliccelés: 11%

napi bevétel: 26873550 tallér

}

Közlekedés {

vonaljegy ár: 310 tallér

napi utasszám: 98000 fő

bliccelés: 12%

napi bevétel: 26734400 tallér

}

Közlekedés {

vonaljegy ár: 315 tallér

napi utasszám: 97000 fő

bliccelés: 13%

napi bevétel: 26582850 tallér

}

Közlekedés {

vonaljegy ár: 320 tallér

napi utasszám: 96000 fő

bliccelés: 14%

napi bevétel: 26419200 tallér

}

Közlekedés {

vonaljegy ár: 325 tallér

napi utasszám: 95000 fő

bliccelés: 15%

napi bevétel: 26243750 tallér

}

Közlekedés {

vonaljegy ár: 330 tallér

napi utasszám: 94000 fő

bliccelés: 16%

napi bevétel: 26056800 tallér

}

Közlekedés {

vonaljegy ár: 335 tallér

napi utasszám: 93000 fő

bliccelés: 17%

napi bevétel: 25858650 tallér

}

Közlekedés {

vonaljegy ár: 340 tallér

napi utasszám: 92000 fő

bliccelés: 18%

napi bevétel: 25649600 tallér

}

Közlekedés {

vonaljegy ár: 345 tallér

napi utasszám: 91000 fő

bliccelés: 19%

napi bevétel: 25429950 tallér

}

Közlekedés {

vonaljegy ár: 350 tallér

napi utasszám: 90000 fő

bliccelés: 20%

napi bevétel: 25200000 tallér

}

Közlekedés {

vonaljegy ár: 355 tallér

napi utasszám: 89000 fő

bliccelés: 21%

napi bevétel: 24960050 tallér

}

Közlekedés {

vonaljegy ár: 360 tallér

napi utasszám: 88000 fő

bliccelés: 22%

napi bevétel: 24710400 tallér

}

Közlekedés {

vonaljegy ár: 365 tallér

napi utasszám: 87000 fő

bliccelés: 23%

napi bevétel: 24451350 tallér

}

Közlekedés {

vonaljegy ár: 370 tallér

napi utasszám: 86000 fő

bliccelés: 24%

napi bevétel: 24183200 tallér

}

Közlekedés {

vonaljegy ár: 375 tallér

napi utasszám: 85000 fő

bliccelés: 25%

napi bevétel: 23906250 tallér

}

Közlekedés {

vonaljegy ár: 380 tallér

napi utasszám: 84000 fő

bliccelés: 26%

napi bevétel: 23620800 tallér

}

Közlekedés {

vonaljegy ár: 385 tallér

napi utasszám: 83000 fő

bliccelés: 27%

napi bevétel: 23327150 tallér

}

Közlekedés {

vonaljegy ár: 390 tallér

napi utasszám: 82000 fő

bliccelés: 28%

napi bevétel: 23025600 tallér

}

Közlekedés {

vonaljegy ár: 395 tallér

napi utasszám: 81000 fő

bliccelés: 29%

napi bevétel: 22716450 tallér

}

Közlekedés {

vonaljegy ár: 400 tallér

napi utasszám: 80000 fő

bliccelés: 30%

napi bevétel: 22400000 tallér

}

Közlekedés {

vonaljegy ár: 405 tallér

napi utasszám: 79000 fő

bliccelés: 31%

napi bevétel: 22076550 tallér

}

Közlekedés {

vonaljegy ár: 410 tallér

napi utasszám: 78000 fő

bliccelés: 32%

napi bevétel: 21746400 tallér

}

Közlekedés {

vonaljegy ár: 415 tallér

napi utasszám: 77000 fő

bliccelés: 33%

napi bevétel: 21409850 tallér

}

Közlekedés {

vonaljegy ár: 420 tallér

napi utasszám: 76000 fő

bliccelés: 34%

napi bevétel: 21067200 tallér

}

Közlekedés {

vonaljegy ár: 425 tallér

napi utasszám: 75000 fő

bliccelés: 35%

napi bevétel: 20718750 tallér

}

Közlekedés {

vonaljegy ár: 430 tallér

napi utasszám: 74000 fő

bliccelés: 36%

napi bevétel: 20364800 tallér

}

Közlekedés {

vonaljegy ár: 435 tallér

napi utasszám: 73000 fő

bliccelés: 37%

napi bevétel: 20005650 tallér

}

Közlekedés {

vonaljegy ár: 440 tallér

napi utasszám: 72000 fő

bliccelés: 38%

napi bevétel: 19641600 tallér

}

Közlekedés {

vonaljegy ár: 445 tallér

napi utasszám: 71000 fő

bliccelés: 39%

napi bevétel: 19272950 tallér

}

Közlekedés {

vonaljegy ár: 450 tallér

napi utasszám: 70000 fő

bliccelés: 40%

napi bevétel: 18900000 tallér

}

Az eredmény

A program konzolon/szövegesen jeleníti meg a válaszokat a feltett két kérdésre:

a) Mekkora lenne a közlekedési társaság vonaljegyekből

származó napi bevétele a hatástanulmány becslései alapján,

ha 350 tallérra emelnék a vonaljegyek árát?

25200000 tallér lenne a napi bevétel.

b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Ha a vonaljegy ára 260 tallér lenne.

Gondoljuk újra

Az első megoldás 41 elemű listát épít. Persze ez a lista több mindenre is jó lehet, ha több(féle) kérdést kell(ene) megválaszolni. Ezért tekinthetjük strukturális tartaléknak.

A két konkrét kérdésre azonban úgy is adhatunk választ, hogy nem építünk lista adatszerkezetet. Ez a második megoldás. A feladat9Megoldas2() metódusnak nincs paramétere és azonos eredmény ad.

Az a) feladat: egy névtelen objektumként létrehozott POJO-tól azonnal elkérhetjük a választ, ami mehet rögtön a konzolra. Ez a kiválasztás programozási tétel extrém/legjobb esete, hiszen az első objektum jó is lesz, ciklust sem kell szervezni.

A b) feladat: kiindulunk a legolcsóbb vonaljegyből és tegyük fel, hogy ekkor a legnagyobb a napi bevétel. Ciklussal léptessük a vonaljegy árát ötösével legfeljebb a legdrágábbig. Léptetés közben mindig csak azt a dinamikusan létrehozott objektumot „jegyezzük meg”, amelyiktől a röptében elkért napi bevétel a korábbihoz – az addig legnagyobbnak vélthez – képest nagyobb. Végül a megmaradó POJO-tól elkérhető a maximális napi bevételhez tartozó vonaljegy ára. Ez a szélsőérték-kiválasztás programozási tétel megvalósítása dinamikusan: kezdetben nem áll rendelkezésre az összes adat, ami alapján döntést kell hozni, ehelyett az adatokat menet/feldolgozás közben állítjuk elő és „eldobjuk” azt, ami már nem kell.

private static void feladat9Megoldas2() {

//a) feladat

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

new Kozlekedes(350).getNapiBevetel()+

" tallér lenne a napi bevétel.\n");

//b) feladat

Kozlekedes kMax=new Kozlekedes(250);

for(int vonaljegyAr=255; vonaljegyAr<=450; vonaljegyAr+=5) {

Kozlekedes k=new Kozlekedes(vonaljegyAr);

if(k.getNapiBevetel()>kMax.getNapiBevetel())

kMax=k;

}

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

kMax.getVonaljegyAr()+" tallér lenne.\n");

}

Nekem ezek a programozással való megoldások sokkal jobban tetszenek, mint az oktatas.hu-n elérhető hivatalos, matematikai megoldás, amihez differenciálszámítás is kell. Persze aki emelt szinten érettségizik matematikából, annak az sem jelenthet gondot és biztosan izgalmasnak találja.

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

Ajánljuk matematika érettségi feladat címkénket, mert a témában évről-évre blogolunk.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek, 9-12. óra: Metódusok, rekurzió, valamint 17-24. óra: Objektumorientált programozás alkalmaihoz kötődik.

Címkefelhő generálása

2023. augusztus 4.2020. április 21. Szerző: Kaczur Sándor

A címkefelhők/szófelhők népszerűek, sok weboldalon megtalálhatóak. A CMS rendszerekben beépített szolgáltatás is lehet, vagy külön bővítmény/plugin is megvalósíthatja. Egy szövegben előforduló szavakból a gyakrabban előfordulókat nagyobb betűmérettel emeli ki. Eredménye lehet listás, táblázatos, esetleg képpé generált is. Kétféleképpen is megközelíthető, erre utal a Word Cloud és a Tag Cloud elnevezés. Utóbbi inkább egy blog taxonomiájához kapcsolódik és kategóriákra/címkékre érvényesül. A szakmai blogunkhoz is tartozik egy táblázatos címkefelhő. A szófelhő a szöveg betűméretén túl megjelenítheti a szavak előfordulását, például Java forráskód (63), címkefelhő (2).

Példánkban tetszőleges szöveget dolgozunk fel. Ebből felépítünk egy előfordulást is mutató listás szófelhőt, amely rendezett, és a szavak betűmérete 32-16-ig változik. Azok a szavak kerülnek a szófelhőbe, amelyek legalább 5-ször előfordulnak. Kezelünk kivételeket is, például olyan szavakat, amiket nem érdemes szófelhőbe tenni. Lépésenként haladva ismertetjük a megvalósító forráskódot, és külön megjeleníthetők az egyes lépések részeredményei.

A Java programozási nyelv csomagjait, osztályait, interfészeit, metódusait, műveleteit használjuk. Különböző adatszerkezetek kerülnek elő: tömb, generikus lista, generikus map, generikus folyam. Építünk a Stream API szolgáltatásaira és a lambda kifejezésekre. A megvalósítás könnyen testre szabható, kezeli a tipikusan előforduló igényeket.

1. Szövegforrás előkészítése

Generálunk egy 10 bekezdésből álló szöveget a Lorem Ipsum – All the facts – Lipsum generator weboldalon és a későbbi feldolgozáshoz mentjük a Java projekt files mappájába lorem.txt néven. A fájl mérete: 5781 bájt. Szövegfájl:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur quis mauris laoreet, lobortis orci eget, egestas dui. Vivamus pretium nunc sit amet ex dictum rutrum. Duis sodales augue dui, vitae porta eros auctor non. Pellentesque vehicula sollicitudin scelerisque. Sed urna massa, auctor nec tellus at, iaculis dictum ligula. Nunc vitae metus quis velit hendrerit finibus. Aenean et nunc et sem facilisis sagittis. Phasellus vestibulum accumsan eleifend. Etiam finibus est fringilla augue imperdiet lacinia. Suspendisse eleifend, magna quis sollicitudin euismod, turpis enim pretium nulla, at vulputate justo sem vel ipsum. Donec vestibulum risus viverra purus sodales, nec laoreet tortor volutpat. Pellentesque vitae sodales odio. Morbi tristique vitae justo ac dictum. Nam eleifend dolor sapien, ullamcorper pellentesque quam semper quis.

Suspendisse eu aliquet lectus. Maecenas placerat nunc nec ipsum tempor suscipit. Donec fringilla lacinia aliquam. Fusce maximus nunc eget nibh dignissim, id aliquam ex fringilla. Donec eget blandit tortor. Nunc at ornare lectus, non varius augue. Donec cursus velit ligula, non volutpat tellus euismod eu. Mauris dictum nisl consequat nisl dapibus placerat. Maecenas in purus leo. Praesent imperdiet aliquet porttitor. Nunc tempus maximus enim. Integer imperdiet luctus lorem eget luctus. Nullam et sapien fringilla, vestibulum lectus at, porttitor odio. Sed cursus mollis ante, ac volutpat est facilisis non.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum id posuere tellus. Quisque ornare, sem ac maximus porttitor, eros dui porta sem, ornare vulputate mi leo vel nunc. Donec leo ex, fringilla cursus dui at, congue euismod velit. Nunc viverra lectus vel nunc tempus viverra. Suspendisse potenti. Integer vel purus commodo, rutrum lectus nec, pharetra sem. Proin blandit tincidunt turpis in pulvinar. Aliquam malesuada tellus id dui ullamcorper pellentesque. Donec vel urna felis.

Morbi blandit ipsum eget tellus efficitur, ac pulvinar nunc porttitor. Quisque nec posuere elit, ac sollicitudin sem. Vestibulum faucibus ante lectus, vel congue erat molestie sed. Maecenas ac leo porttitor, congue felis sit amet, dignissim nibh. Quisque porttitor neque maximus est scelerisque, nec gravida orci eleifend. Aenean ac magna ut dolor aliquet fermentum vel nec risus. Phasellus in ullamcorper mauris. Phasellus semper blandit bibendum. Cras vitae purus fermentum diam dapibus dictum. Curabitur sapien neque, rutrum in dapibus eu, ornare at ante.

Integer facilisis, libero convallis pellentesque gravida, velit odio interdum nisi, vel ultricies nisl sapien et eros. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Morbi nec ante at ante blandit fringilla eu sed nisi. Suspendisse potenti. Maecenas neque lacus, laoreet nec lacinia efficitur, suscipit at est. Mauris lacinia fringilla ligula, sit amet blandit nisl ullamcorper sed. Nulla et velit laoreet, egestas sapien vitae, elementum leo. Suspendisse laoreet nibh neque, et convallis dolor vulputate id.

Fusce at elit a libero ullamcorper interdum vitae bibendum urna. Proin porta est lorem, eget accumsan nibh placerat ut. Aenean scelerisque, lectus rutrum efficitur mollis, elit eros dapibus velit, eu lobortis ipsum felis quis dui. Cras quis faucibus eros, eget scelerisque ligula. Proin tempor felis quis tellus ornare sodales. Curabitur quam sapien, venenatis nec diam in, molestie euismod arcu. Morbi malesuada sodales metus, vitae ornare nisl eleifend nec. Nulla nec metus sed diam vestibulum commodo vel vitae lectus. Suspendisse quis quam eu nibh suscipit faucibus quis ut orci.

Cras quis mi sit amet ante fermentum consectetur. Aliquam euismod libero vitae euismod dapibus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi auctor in mi vitae egestas. Aenean justo nisl, consectetur quis dui cursus, consectetur commodo lacus. In scelerisque erat ac ligula aliquet ultrices. Aliquam rutrum ut tortor sed pellentesque. Aliquam semper, felis sed finibus scelerisque, neque odio consectetur odio, eget imperdiet quam quam ut arcu. Maecenas non arcu tempus, ornare quam vel, fringilla turpis. Vivamus rhoncus velit sed mauris pretium pharetra. Mauris tempor, leo quis tristique ullamcorper, mauris mi aliquet dui, sed ullamcorper risus nunc quis metus.

Donec in laoreet lectus. Ut sit amet mattis diam. Maecenas et mauris eget lacus mollis sodales. Pellentesque porttitor venenatis accumsan. In a aliquet tortor. Donec condimentum lectus sem, quis ornare magna dapibus ac. Mauris maximus dolor in porttitor pulvinar. Cras ut magna eros. Nullam eu dolor eget purus aliquam bibendum vel nec erat. Duis augue justo, ornare non urna id, elementum pulvinar arcu. Donec placerat quam lorem, pulvinar laoreet justo hendrerit vitae. Suspendisse porta accumsan leo. Mauris suscipit urna ac erat convallis auctor.

Quisque sollicitudin elit odio. Mauris tempor eu lorem nec rhoncus. Aliquam in feugiat tellus. Maecenas elementum euismod ex. In maximus scelerisque viverra. Nam vel placerat quam, sit amet eleifend nisi. Cras porta tincidunt malesuada. Ut congue porta pellentesque. Donec porttitor elit ac tempor malesuada. Etiam ultricies laoreet ante, vitae interdum felis rhoncus eu. Morbi dignissim consequat semper.

Nam luctus molestie turpis, vel bibendum ante lobortis eget. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed cursus urna nisl, molestie faucibus libero pulvinar nec. Nulla facilisi. Integer lorem odio, suscipit vel risus eget, tempor vulputate nulla. Morbi a posuere arcu. Praesent et arcu dolor. Sed placerat eros vel lacus interdum viverra. Ut pulvinar dui ac enim rhoncus hendrerit.

2. Szöveges tartalom előkészítése

String s=new String(Files.readAllBytes(Paths.get("./files/lorem.txt")));

s=s.replace("\n", "").replace("\r", "").replace(",", "").

replace(".", "").toLowerCase();

A megadott útvonalról a java.nio csomag metódusaival betöltjük a szövegfájl tartalmát byte[]-be, majd az s szövegbe. A replace() metódus hívásaival eltávolítjuk a szövegből a sor és bekezdés végét jelző soremelés ( LF="\n") és kocsi vissza ( CR="\r") vezérlőkaraktereket, a vessző és a pont írásjeleket (mindet külön-külön cseréljük a semmire), végül kisbetűssé alakítjuk ( toLowerCase()) a szöveget. A szöveg 5563 db karakterből áll. Előkészített szöveg:

lorem ipsum dolor sit amet consectetur adipiscing elit curabitur quis mauris laoreet lobortis orci eget egestas dui vivamus pretium nunc sit amet ex dictum rutrum duis sodales augue dui vitae porta eros auctor non pellentesque vehicula sollicitudin scelerisque sed urna massa auctor nec tellus at iaculis dictum ligula nunc vitae metus quis velit hendrerit finibus aenean et nunc et sem facilisis sagittis phasellus vestibulum accumsan eleifend etiam finibus est fringilla augue imperdiet lacinia suspendisse eleifend magna quis sollicitudin euismod turpis enim pretium nulla at vulputate justo sem vel ipsum donec vestibulum risus viverra purus sodales nec laoreet tortor volutpat pellentesque vitae sodales odio morbi tristique vitae justo ac dictum nam eleifend dolor sapien ullamcorper pellentesque quam semper quissuspendisse eu aliquet lectus maecenas placerat nunc nec ipsum tempor suscipit donec fringilla lacinia aliquam fusce maximus nunc eget nibh dignissim id aliquam ex fringilla donec eget blandit tortor nunc at ornare lectus non varius augue donec cursus velit ligula non volutpat tellus euismod eu mauris dictum nisl consequat nisl dapibus placerat maecenas in purus leo praesent imperdiet aliquet porttitor nunc tempus maximus enim integer imperdiet luctus lorem eget luctus nullam et sapien fringilla vestibulum lectus at porttitor odio sed cursus mollis ante ac volutpat est facilisis nonlorem ipsum dolor sit amet consectetur adipiscing elit vestibulum id posuere tellus quisque ornare sem ac maximus porttitor eros dui porta sem ornare vulputate mi leo vel nunc donec leo ex fringilla cursus dui at congue euismod velit nunc viverra lectus vel nunc tempus viverra suspendisse potenti integer vel purus commodo rutrum lectus nec pharetra sem proin blandit tincidunt turpis in pulvinar aliquam malesuada tellus id dui ullamcorper pellentesque donec vel urna felismorbi blandit ipsum eget tellus efficitur ac pulvinar nunc porttitor quisque nec posuere elit ac sollicitudin sem vestibulum faucibus ante lectus vel congue erat molestie sed maecenas ac leo porttitor congue felis sit amet dignissim nibh quisque porttitor neque maximus est scelerisque nec gravida orci eleifend aenean ac magna ut dolor aliquet fermentum vel nec risus phasellus in ullamcorper mauris phasellus semper blandit bibendum cras vitae purus fermentum diam dapibus dictum curabitur sapien neque rutrum in dapibus eu ornare at anteinteger facilisis libero convallis pellentesque gravida velit odio interdum nisi vel ultricies nisl sapien et eros pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas morbi nec ante at ante blandit fringilla eu sed nisi suspendisse potenti maecenas neque lacus laoreet nec lacinia efficitur suscipit at est mauris lacinia fringilla ligula sit amet blandit nisl ullamcorper sed nulla et velit laoreet egestas sapien vitae elementum leo suspendisse laoreet nibh neque et convallis dolor vulputate idfusce at elit a libero ullamcorper interdum vitae bibendum urna proin porta est lorem eget accumsan nibh placerat ut aenean scelerisque lectus rutrum efficitur mollis elit eros dapibus velit eu lobortis ipsum felis quis dui cras quis faucibus eros eget scelerisque ligula proin tempor felis quis tellus ornare sodales curabitur quam sapien venenatis nec diam in molestie euismod arcu morbi malesuada sodales metus vitae ornare nisl eleifend nec nulla nec metus sed diam vestibulum commodo vel vitae lectus suspendisse quis quam eu nibh suscipit faucibus quis ut orcicras quis mi sit amet ante fermentum consectetur aliquam euismod libero vitae euismod dapibus class aptent taciti sociosqu ad litora torquent per conubia nostra per inceptos himenaeos morbi auctor in mi vitae egestas aenean justo nisl consectetur quis dui cursus consectetur commodo lacus in scelerisque erat ac ligula aliquet ultrices aliquam rutrum ut tortor sed pellentesque aliquam semper felis sed finibus scelerisque neque odio consectetur odio eget imperdiet quam quam ut arcu maecenas non arcu tempus ornare quam vel fringilla turpis vivamus rhoncus velit sed mauris pretium pharetra mauris tempor leo quis tristique ullamcorper mauris mi aliquet dui sed ullamcorper risus nunc quis metusdonec in laoreet lectus ut sit amet mattis diam maecenas et mauris eget lacus mollis sodales pellentesque porttitor venenatis accumsan in a aliquet tortor donec condimentum lectus sem quis ornare magna dapibus ac mauris maximus dolor in porttitor pulvinar cras ut magna eros nullam eu dolor eget purus aliquam bibendum vel nec erat duis augue justo ornare non urna id elementum pulvinar arcu donec placerat quam lorem pulvinar laoreet justo hendrerit vitae suspendisse porta accumsan leo mauris suscipit urna ac erat convallis auctorquisque sollicitudin elit odio mauris tempor eu lorem nec rhoncus aliquam in feugiat tellus maecenas elementum euismod ex in maximus scelerisque viverra nam vel placerat quam sit amet eleifend nisi cras porta tincidunt malesuada ut congue porta pellentesque donec porttitor elit ac tempor malesuada etiam ultricies laoreet ante vitae interdum felis rhoncus eu morbi dignissim consequat sempernam luctus molestie turpis vel bibendum ante lobortis eget orci varius natoque penatibus et magnis dis parturient montes nascetur ridiculus mus sed cursus urna nisl molestie faucibus libero pulvinar nec nulla facilisi integer lorem odio suscipit vel risus eget tempor vulputate nulla morbi a posuere arcu praesent et arcu dolor sed placerat eros vel lacus interdum viverra ut pulvinar dui ac enim rhoncus hendrerit

3. Szólista elkészítése

1	List<String> wordList=Arrays.asList(s.split(" "));

A szóközök mentén darabolva ( split()) a szöveget elkészül belőle egy névtelen szövegtömb ( String[]), amit rögtön átalakítunk ( Arrays.asList()) szöveg típusú generikus listává ( List<String>). A lista 826 db elemből áll. Generikus lista:

[lorem, ipsum, dolor, sit, amet, consectetur, adipiscing, elit, curabitur, quis, mauris, laoreet, lobortis, orci, eget, egestas, dui, vivamus, pretium, nunc, sit, amet, ex, dictum, rutrum, duis, sodales, augue, dui, vitae, porta, eros, auctor, non, pellentesque, vehicula, sollicitudin, scelerisque, sed, urna, massa, auctor, nec, tellus, at, iaculis, dictum, ligula, nunc, vitae, metus, quis, velit, hendrerit, finibus, aenean, et, nunc, et, sem, facilisis, sagittis, phasellus, vestibulum, accumsan, eleifend, etiam, finibus, est, fringilla, augue, imperdiet, lacinia, suspendisse, eleifend, magna, quis, sollicitudin, euismod, turpis, enim, pretium, nulla, at, vulputate, justo, sem, vel, ipsum, donec, vestibulum, risus, viverra, purus, sodales, nec, laoreet, tortor, volutpat, pellentesque, vitae, sodales, odio, morbi, tristique, vitae, justo, ac, dictum, nam, eleifend, dolor, sapien, ullamcorper, pellentesque, quam, semper, quissuspendisse, eu, aliquet, lectus, maecenas, placerat, nunc, nec, ipsum, tempor, suscipit, donec, fringilla, lacinia, aliquam, fusce, maximus, nunc, eget, nibh, dignissim, id, aliquam, ex, fringilla, donec, eget, blandit, tortor, nunc, at, ornare, lectus, non, varius, augue, donec, cursus, velit, ligula, non, volutpat, tellus, euismod, eu, mauris, dictum, nisl, consequat, nisl, dapibus, placerat, maecenas, in, purus, leo, praesent, imperdiet, aliquet, porttitor, nunc, tempus, maximus, enim, integer, imperdiet, luctus, lorem, eget, luctus, nullam, et, sapien, fringilla, vestibulum, lectus, at, porttitor, odio, sed, cursus, mollis, ante, ac, volutpat, est, facilisis, nonlorem, ipsum, dolor, sit, amet, consectetur, adipiscing, elit, vestibulum, id, posuere, tellus, quisque, ornare, sem, ac, maximus, porttitor, eros, dui, porta, sem, ornare, vulputate, mi, leo, vel, nunc, donec, leo, ex, fringilla, cursus, dui, at, congue, euismod, velit, nunc, viverra, lectus, vel, nunc, tempus, viverra, suspendisse, potenti, integer, vel, purus, commodo, rutrum, lectus, nec, pharetra, sem, proin, blandit, tincidunt, turpis, in, pulvinar, aliquam, malesuada, tellus, id, dui, ullamcorper, pellentesque, donec, vel, urna, felismorbi, blandit, ipsum, eget, tellus, efficitur, ac, pulvinar, nunc, porttitor, quisque, nec, posuere, elit, ac, sollicitudin, sem, vestibulum, faucibus, ante, lectus, vel, congue, erat, molestie, sed, maecenas, ac, leo, porttitor, congue, felis, sit, amet, dignissim, nibh, quisque, porttitor, neque, maximus, est, scelerisque, nec, gravida, orci, eleifend, aenean, ac, magna, ut, dolor, aliquet, fermentum, vel, nec, risus, phasellus, in, ullamcorper, mauris, phasellus, semper, blandit, bibendum, cras, vitae, purus, fermentum, diam, dapibus, dictum, curabitur, sapien, neque, rutrum, in, dapibus, eu, ornare, at, anteinteger, facilisis, libero, convallis, pellentesque, gravida, velit, odio, interdum, nisi, vel, ultricies, nisl, sapien, et, eros, pellentesque, habitant, morbi, tristique, senectus, et, netus, et, malesuada, fames, ac, turpis, egestas, morbi, nec, ante, at, ante, blandit, fringilla, eu, sed, nisi, suspendisse, potenti, maecenas, neque, lacus, laoreet, nec, lacinia, efficitur, suscipit, at, est, mauris, lacinia, fringilla, ligula, sit, amet, blandit, nisl, ullamcorper, sed, nulla, et, velit, laoreet, egestas, sapien, vitae, elementum, leo, suspendisse, laoreet, nibh, neque, et, convallis, dolor, vulputate, idfusce, at, elit, a, libero, ullamcorper, interdum, vitae, bibendum, urna, proin, porta, est, lorem, eget, accumsan, nibh, placerat, ut, aenean, scelerisque, lectus, rutrum, efficitur, mollis, elit, eros, dapibus, velit, eu, lobortis, ipsum, felis, quis, dui, cras, quis, faucibus, eros, eget, scelerisque, ligula, proin, tempor, felis, quis, tellus, ornare, sodales, curabitur, quam, sapien, venenatis, nec, diam, in, molestie, euismod, arcu, morbi, malesuada, sodales, metus, vitae, ornare, nisl, eleifend, nec, nulla, nec, metus, sed, diam, vestibulum, commodo, vel, vitae, lectus, suspendisse, quis, quam, eu, nibh, suscipit, faucibus, quis, ut, orcicras, quis, mi, sit, amet, ante, fermentum, consectetur, aliquam, euismod, libero, vitae, euismod, dapibus, class, aptent, taciti, sociosqu, ad, litora, torquent, per, conubia, nostra, per, inceptos, himenaeos, morbi, auctor, in, mi, vitae, egestas, aenean, justo, nisl, consectetur, quis, dui, cursus, consectetur, commodo, lacus, in, scelerisque, erat, ac, ligula, aliquet, ultrices, aliquam, rutrum, ut, tortor, sed, pellentesque, aliquam, semper, felis, sed, finibus, scelerisque, neque, odio, consectetur, odio, eget, imperdiet, quam, quam, ut, arcu, maecenas, non, arcu, tempus, ornare, quam, vel, fringilla, turpis, vivamus, rhoncus, velit, sed, mauris, pretium, pharetra, mauris, tempor, leo, quis, tristique, ullamcorper, mauris, mi, aliquet, dui, sed, ullamcorper, risus, nunc, quis, metusdonec, in, laoreet, lectus, ut, sit, amet, mattis, diam, maecenas, et, mauris, eget, lacus, mollis, sodales, pellentesque, porttitor, venenatis, accumsan, in, a, aliquet, tortor, donec, condimentum, lectus, sem, quis, ornare, magna, dapibus, ac, mauris, maximus, dolor, in, porttitor, pulvinar, cras, ut, magna, eros, nullam, eu, dolor, eget, purus, aliquam, bibendum, vel, nec, erat, duis, augue, justo, ornare, non, urna, id, elementum, pulvinar, arcu, donec, placerat, quam, lorem, pulvinar, laoreet, justo, hendrerit, vitae, suspendisse, porta, accumsan, leo, mauris, suscipit, urna, ac, erat, convallis, auctorquisque, sollicitudin, elit, odio, mauris, tempor, eu, lorem, nec, rhoncus, aliquam, in, feugiat, tellus, maecenas, elementum, euismod, ex, in, maximus, scelerisque, viverra, nam, vel, placerat, quam, sit, amet, eleifend, nisi, cras, porta, tincidunt, malesuada, ut, congue, porta, pellentesque, donec, porttitor, elit, ac, tempor, malesuada, etiam, ultricies, laoreet, ante, vitae, interdum, felis, rhoncus, eu, morbi, dignissim, consequat, sempernam, luctus, molestie, turpis, vel, bibendum, ante, lobortis, eget, orci, varius, natoque, penatibus, et, magnis, dis, parturient, montes, nascetur, ridiculus, mus, sed, cursus, urna, nisl, molestie, faucibus, libero, pulvinar, nec, nulla, facilisi, integer, lorem, odio, suscipit, vel, risus, eget, tempor, vulputate, nulla, morbi, a, posuere, arcu, praesent, et, arcu, dolor, sed, placerat, eros, vel, lacus, interdum, viverra, ut, pulvinar, dui, ac, enim, rhoncus, hendrerit]

4. Csoportosítás és megszámolás

1 2	Map<String, Long> wordCountMap=wordList.stream().collect( Collectors.groupingBy(Function.identity(), Collectors.counting()));

A szólistát csoportosítjuk és megszámoljuk, hogy az egyes szavak hányszor fordulnak elő (másképpen: egy-egy csoport hány elemű). Elkészül a wordCountMap generikus map, amely kulcs-érték párok halmaza (leképezés). A kulcs a szó ( String), az érték a darabszáma ( Long). Alkalmazkodunk ahhoz, hogy a csoportosítás során használt counting() megszámoló művelet Long típusú értéket ad vissza. 188 db kulcs-érték párt kapunk. Generikus map:

{aenean=4, elementum=3, efficitur=3, mollis=3, tempor=6, potenti=2, bibendum=4, commodo=3, purus=5, augue=4, justo=5, lorem=6, leo=7, id=4, nam=2, per=2, habitant=1, semper=3, volutpat=3, ac=13, ad=1, sodales=6, in=12, finibus=3, velit=7, urna=6, sociosqu=1, luctus=3, fusce=1, at=9, pellentesque=9, ipsum=6, convallis=3, elit=7, taciti=1, aptent=1, ullamcorper=7, vestibulum=6, laoreet=8, ridiculus=1, congue=4, idfusce=1, penatibus=1, arcu=6, conubia=1, dolor=8, iaculis=1, inceptos=1, sed=12, duis=2, metus=3, dictum=5, vehicula=1, dapibus=6, sem=7, pulvinar=7, diam=4, porta=6, ultricies=2, interdum=4, a=3, felismorbi=1, magnis=1, nisi=3, morbi=7, quam=8, tincidunt=2, nisl=7, ultrices=1, condimentum=1, ornare=9, aliquam=8, praesent=2, magna=4, auctor=3, turpis=5, nibh=5, ante=7, placerat=6, parturient=1, malesuada=5, rutrum=5, sapien=6, himenaeos=1, quis=13, porttitor=9, sagittis=1, eros=7, maximus=6, torquent=1, tristique=3, etiam=2, suscipit=5, sempernam=1, cursus=5, est=5, adipiscing=2, odio=7, eleifend=6, accumsan=4, fames=1, integer=3, egestas=4, nec=15, scelerisque=7, dis=1, erat=4, nunc=12, facilisis=3, euismod=7, nascetur=1, donec=9, vivamus=2, mauris=11, nostra=1, neque=5, imperdiet=4, natoque=1, molestie=4, mi=4, vel=15, feugiat=1, metusdonec=1, ut=9, enim=3, consequat=2, ligula=5, lobortis=3, quissuspendisse=1, varius=2, facilisi=1, dignissim=3, nullam=2, vulputate=4, fermentum=3, auctorquisque=1, litora=1, et=11, eu=9, mattis=1, lacus=4, ex=4, vitae=13, senectus=1, posuere=3, felis=5, tellus=7, orci=3, faucibus=4, phasellus=3, pharetra=2, blandit=6, lacinia=4, massa=1, venenatis=2, lectus=10, rhoncus=4, viverra=5, montes=1, netus=1, tempus=3, mus=1, non=5, proin=3, risus=4, cras=4, maecenas=7, hendrerit=3, class=1, sit=8, tortor=4, orcicras=1, anteinteger=1, fringilla=8, curabitur=3, sollicitudin=4, suspendisse=6, aliquet=6, amet=8, quisque=3, pretium=3, dui=9, nonlorem=1, libero=4, gravida=2, nulla=5, eget=12, consectetur=6}

5. Szűrés és rendezés

List<String> exceptList=

Arrays.asList(new String[] {"at", "et", "in", "ut"});

Stream<Entry<String, Long>> sortedWordCountStream=

wordCountMap.entrySet().stream().

filter(e -> !exceptList.contains(e.getKey())).

filter(e -> e.getValue()>=5).

sorted((e1, e2) ->

(e1.getValue().equals(e2.getValue())) ?

e1.getKey().compareTo(e2.getKey()) :

e2.getValue().compareTo(e1.getValue())

);

A generikus map-et kétszer szűrjük ( filter() művelet) úgy, hogy a kivételeket tartalmazó exceptList-ben ne szerepeljen a szó, valamint csak a legalább 5-ször előforduló szavakat hagyjuk meg. 71 db elemből álló folyam marad. Ebből a maradékból készítünk rendezett generikus folyamot ( sortedWordCountStream). A sorted() művelet két kulcs-érték párt hasonlít össze. A rendezés érték/darabszám szerint ( getValue()) csökkenő, azon belül kulcs/szavak szerint ( getKey()) növekvő sorrendet biztosít. Másképpen: ha az értékek megegyeznek, akkor a növekvő sorrendet a szavak ábécé sorrendje határozza meg, egyébként a darabszámok csökkenő sorrendje dönti el. Most már könnyen látható, hogy a leggyakrabban előforduló kevés szóból 15 van, 14 előfordulás nincs… Rendezett generikus folyam:

[nec=15, vel=15, ac=13, quis=13, vitae=13, eget=12, nunc=12, sed=12, mauris=11, lectus=10, donec=9, dui=9, eu=9, ornare=9, pellentesque=9, porttitor=9, aliquam=8, amet=8, dolor=8, fringilla=8, laoreet=8, quam=8, sit=8, ante=7, elit=7, eros=7, euismod=7, leo=7, maecenas=7, morbi=7, nisl=7, odio=7, pulvinar=7, scelerisque=7, sem=7, tellus=7, ullamcorper=7, velit=7, aliquet=6, arcu=6, blandit=6, consectetur=6, dapibus=6, eleifend=6, ipsum=6, lorem=6, maximus=6, placerat=6, porta=6, sapien=6, sodales=6, suspendisse=6, tempor=6, urna=6, vestibulum=6, cursus=5, dictum=5, est=5, felis=5, justo=5, ligula=5, malesuada=5, neque=5, nibh=5, non=5, nulla=5, purus=5, rutrum=5, suscipit=5, turpis=5, viverra=5]

6. Saját típusú listává konvertálás

Definiálunk egy WordCount POJO-t, String típusú word nevű, Long típusú count nevű, int típusú fontSize nevű tulajdonságokkal, getter/setter metódusokkal, és toString() függvénnyel.

List<WordCount> sortedWordCountList=

sortedWordCountStream.

map(e -> new WordCount(e.getKey(), e.getValue())).

collect(Collectors.toList());

A map() intermediate művelettel a rendezett generikus folyamot bejárva, előállítjuk a POJO/ WordCount típusú kimeneti objektumok rendezett generikus listáját. Továbbra is 71 elemmel dolgozunk. Rendezett generikus lista:

POJO{word: nec, count: 15, fontSize: 0}

POJO{word: vel, count: 15, fontSize: 0}

POJO{word: ac, count: 13, fontSize: 0}

POJO{word: quis, count: 13, fontSize: 0}

POJO{word: vitae, count: 13, fontSize: 0}

POJO{word: eget, count: 12, fontSize: 0}

POJO{word: nunc, count: 12, fontSize: 0}

POJO{word: sed, count: 12, fontSize: 0}

POJO{word: mauris, count: 11, fontSize: 0}

POJO{word: lectus, count: 10, fontSize: 0}

POJO{word: donec, count: 9, fontSize: 0}

POJO{word: dui, count: 9, fontSize: 0}

POJO{word: eu, count: 9, fontSize: 0}

POJO{word: ornare, count: 9, fontSize: 0}

POJO{word: pellentesque, count: 9, fontSize: 0}

POJO{word: porttitor, count: 9, fontSize: 0}

POJO{word: aliquam, count: 8, fontSize: 0}

POJO{word: amet, count: 8, fontSize: 0}

POJO{word: dolor, count: 8, fontSize: 0}

POJO{word: fringilla, count: 8, fontSize: 0}

POJO{word: laoreet, count: 8, fontSize: 0}

POJO{word: quam, count: 8, fontSize: 0}

POJO{word: sit, count: 8, fontSize: 0}

POJO{word: ante, count: 7, fontSize: 0}

POJO{word: elit, count: 7, fontSize: 0}

POJO{word: eros, count: 7, fontSize: 0}

POJO{word: euismod, count: 7, fontSize: 0}

POJO{word: leo, count: 7, fontSize: 0}

POJO{word: maecenas, count: 7, fontSize: 0}

POJO{word: morbi, count: 7, fontSize: 0}

POJO{word: nisl, count: 7, fontSize: 0}

POJO{word: odio, count: 7, fontSize: 0}

POJO{word: pulvinar, count: 7, fontSize: 0}

POJO{word: scelerisque, count: 7, fontSize: 0}

POJO{word: sem, count: 7, fontSize: 0}

POJO{word: tellus, count: 7, fontSize: 0}

POJO{word: ullamcorper, count: 7, fontSize: 0}

POJO{word: velit, count: 7, fontSize: 0}

POJO{word: aliquet, count: 6, fontSize: 0}

POJO{word: arcu, count: 6, fontSize: 0}

POJO{word: blandit, count: 6, fontSize: 0}

POJO{word: consectetur, count: 6, fontSize: 0}

POJO{word: dapibus, count: 6, fontSize: 0}

POJO{word: eleifend, count: 6, fontSize: 0}

POJO{word: ipsum, count: 6, fontSize: 0}

POJO{word: lorem, count: 6, fontSize: 0}

POJO{word: maximus, count: 6, fontSize: 0}

POJO{word: placerat, count: 6, fontSize: 0}

POJO{word: porta, count: 6, fontSize: 0}

POJO{word: sapien, count: 6, fontSize: 0}

POJO{word: sodales, count: 6, fontSize: 0}

POJO{word: suspendisse, count: 6, fontSize: 0}

POJO{word: tempor, count: 6, fontSize: 0}

POJO{word: urna, count: 6, fontSize: 0}

POJO{word: vestibulum, count: 6, fontSize: 0}

POJO{word: cursus, count: 5, fontSize: 0}

POJO{word: dictum, count: 5, fontSize: 0}

POJO{word: est, count: 5, fontSize: 0}

POJO{word: felis, count: 5, fontSize: 0}

POJO{word: justo, count: 5, fontSize: 0}

POJO{word: ligula, count: 5, fontSize: 0}

POJO{word: malesuada, count: 5, fontSize: 0}

POJO{word: neque, count: 5, fontSize: 0}

POJO{word: nibh, count: 5, fontSize: 0}

POJO{word: non, count: 5, fontSize: 0}

POJO{word: nulla, count: 5, fontSize: 0}

POJO{word: purus, count: 5, fontSize: 0}

POJO{word: rutrum, count: 5, fontSize: 0}

POJO{word: suscipit, count: 5, fontSize: 0}

POJO{word: turpis, count: 5, fontSize: 0}

POJO{word: viverra, count: 5, fontSize: 0}

7. Darabszámok összegyűjtése

List<Long> distinctCountList=

sortedWordCountList.stream().map(e -> e.getCount()).distinct().

collect(Collectors.toList());

A POJO típusú rendezett generikus listában lévő objektumoktól elkért darabszámok ( getCount() POJO függvény) közül a különbözőeket ( distinct() művelet) összegyűjtjük egy Long típusú generikus listába ( distinctCountList). Az egyediesítő művelet nincs hatással az adatok sorrendjére. Tízféle előfordulást kapunk. Generikus lista:

1	[15, 13, 12, 11, 10, 9, 8, 7, 6, 5]

8. Betűméret lépésköze

final int MAX_FONT_SIZE=32;

final int MIN_FONT_SIZE=16;

long countCount=distinctCountList.size();

double stepFontSize=(double)(MAX_FONT_SIZE-MIN_FONT_SIZE+1)/countCount;

A szófelhőben a szavak gyakorisága alapján határozzuk meg a betűméretet. A betűméret 32-ről indul és fokozatosan csökken 16-ig. A betűméret léptetéséhez a tízféle gyakoriság/előfordulás meghatározza a stepFontSize lépésközt. Lépésköz:

1.7

9. Betűméret kiszámítása

int i=0, gi=0;

while(i<sortedWordCountList.size()) {

long count=sortedWordCountList.get(i).getCount();

int fontSize=(int)Math.round(MAX_FONT_SIZE-gi*stepFontSize);

while(i<sortedWordCountList.size() &&

count==sortedWordCountList.get(i).getCount()) {

sortedWordCountList.get(i).setFontSize(fontSize);

i++;

}

gi++;

}

Csoportváltást alkalmazunk és a csoportot gi-vel indexeljük. Egy csoportba azok a POJO objektumok tartoznak, amelyeknél a szavak előfordulása megegyezik. Az algoritmus 2. lépésében az aktuális csoportra érvényesen kiszámítjuk a betűméretet ( fontSize), ami az algoritmus 3. lépésében a csoportba tartozó minden POJO objektumnál beállításra kerül a setFontSize() POJO eljárással. Az algoritmus 4. lépésében léptetjük a csoport gi indexét. A POJO-k esetén először csak a word és count tulajdonságok kerültek beállításra, de most már a fontSize tulajdonság is értéket kapott. Generikus lista:

POJO{word: nec, count: 15, fontSize: 32}

POJO{word: vel, count: 15, fontSize: 32}

POJO{word: ac, count: 13, fontSize: 30}

POJO{word: quis, count: 13, fontSize: 30}

POJO{word: vitae, count: 13, fontSize: 30}

POJO{word: eget, count: 12, fontSize: 29}

POJO{word: nunc, count: 12, fontSize: 29}

POJO{word: sed, count: 12, fontSize: 29}

POJO{word: mauris, count: 11, fontSize: 27}

POJO{word: lectus, count: 10, fontSize: 25}

POJO{word: donec, count: 9, fontSize: 24}

POJO{word: dui, count: 9, fontSize: 24}

POJO{word: eu, count: 9, fontSize: 24}

POJO{word: ornare, count: 9, fontSize: 24}

POJO{word: pellentesque, count: 9, fontSize: 24}

POJO{word: porttitor, count: 9, fontSize: 24}

POJO{word: aliquam, count: 8, fontSize: 22}

POJO{word: amet, count: 8, fontSize: 22}

POJO{word: dolor, count: 8, fontSize: 22}

POJO{word: fringilla, count: 8, fontSize: 22}

POJO{word: laoreet, count: 8, fontSize: 22}

POJO{word: quam, count: 8, fontSize: 22}

POJO{word: sit, count: 8, fontSize: 22}

POJO{word: ante, count: 7, fontSize: 20}

POJO{word: elit, count: 7, fontSize: 20}

POJO{word: eros, count: 7, fontSize: 20}

POJO{word: euismod, count: 7, fontSize: 20}

POJO{word: leo, count: 7, fontSize: 20}

POJO{word: maecenas, count: 7, fontSize: 20}

POJO{word: morbi, count: 7, fontSize: 20}

POJO{word: nisl, count: 7, fontSize: 20}

POJO{word: odio, count: 7, fontSize: 20}

POJO{word: pulvinar, count: 7, fontSize: 20}

POJO{word: scelerisque, count: 7, fontSize: 20}

POJO{word: sem, count: 7, fontSize: 20}

POJO{word: tellus, count: 7, fontSize: 20}

POJO{word: ullamcorper, count: 7, fontSize: 20}

POJO{word: velit, count: 7, fontSize: 20}

POJO{word: aliquet, count: 6, fontSize: 18}

POJO{word: arcu, count: 6, fontSize: 18}

POJO{word: blandit, count: 6, fontSize: 18}

POJO{word: consectetur, count: 6, fontSize: 18}

POJO{word: dapibus, count: 6, fontSize: 18}

POJO{word: eleifend, count: 6, fontSize: 18}

POJO{word: ipsum, count: 6, fontSize: 18}

POJO{word: lorem, count: 6, fontSize: 18}

POJO{word: maximus, count: 6, fontSize: 18}

POJO{word: placerat, count: 6, fontSize: 18}

POJO{word: porta, count: 6, fontSize: 18}

POJO{word: sapien, count: 6, fontSize: 18}

POJO{word: sodales, count: 6, fontSize: 18}

POJO{word: suspendisse, count: 6, fontSize: 18}

POJO{word: tempor, count: 6, fontSize: 18}

POJO{word: urna, count: 6, fontSize: 18}

POJO{word: vestibulum, count: 6, fontSize: 18}

POJO{word: cursus, count: 5, fontSize: 17}

POJO{word: dictum, count: 5, fontSize: 17}

POJO{word: est, count: 5, fontSize: 17}

POJO{word: felis, count: 5, fontSize: 17}

POJO{word: justo, count: 5, fontSize: 17}

POJO{word: ligula, count: 5, fontSize: 17}

POJO{word: malesuada, count: 5, fontSize: 17}

POJO{word: neque, count: 5, fontSize: 17}

POJO{word: nibh, count: 5, fontSize: 17}

POJO{word: non, count: 5, fontSize: 17}

POJO{word: nulla, count: 5, fontSize: 17}

POJO{word: purus, count: 5, fontSize: 17}

POJO{word: rutrum, count: 5, fontSize: 17}

POJO{word: suscipit, count: 5, fontSize: 17}

POJO{word: turpis, count: 5, fontSize: 17}

POJO{word: viverra, count: 5, fontSize: 17}

10. HTML tartalom előállítása

StringBuilder sbHTML=new StringBuilder("");

sortedWordCountList.forEach(wordCount ->

sbHTML.append("<span style=\"font-size: ").

append(wordCount.getFontSize()).append("px\">").

append(wordCount.toString()).append(" ")

);

sbHTML.append("");

A generikus lista POJO objektumain végighaladva, a forEach() záró művelettel összeállítható a weboldal szófelhőt tartalmazó része ( sbHTML). A 71 db szóból álló szófelhő HTML forráskódjának mérete 3409 bájt. HTML forráskód:

nec (15) vel (15) ac (13) quis (13) vitae (13) eget (12) nunc (12) sed (12) mauris (11) lectus (10) donec (9) dui (9) eu (9) ornare (9) pellentesque (9) porttitor (9) aliquam (8) amet (8) dolor (8) fringilla (8) laoreet (8) quam (8) sit (8) ante (7) elit (7) eros (7) euismod (7) leo (7) maecenas (7) morbi (7) nisl (7) odio (7) pulvinar (7) scelerisque (7) sem (7) tellus (7) ullamcorper (7) velit (7) aliquet (6) arcu (6) blandit (6) consectetur (6) dapibus (6) eleifend (6) ipsum (6) lorem (6) maximus (6) placerat (6) porta (6) sapien (6) sodales (6) suspendisse (6) tempor (6) urna (6) vestibulum (6) cursus (5) dictum (5) est (5) felis (5) justo (5) ligula (5) malesuada (5) neque (5) nibh (5) non (5) nulla (5) purus (5) rutrum (5) suscipit (5) turpis (5) viverra (5)

Eredmény

Szöveges formában:

Képként (a 3. lépés részeredményéből a WordClouds.com weboldalon generálva):

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 több alkalmához is kötődik. A Stream API-val és a lambda kifejezésekkel sokszor foglalkozunk.