lambda kifejezés - címke - Oldal 3 a 3-ből

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!

Ismerkedjünk lambda kifejezésekkel!

2023. augusztus 4.2017. július 22. Szerző: Kaczur Sándor

A Java 8-tól használhatunk lambda kifejezéseket, amivel hatékonyabban, rövidebben és könnyebben valósíthatunk meg tipikus műveleteket.

Korábban általában az eseménykezelést globálisan (interfészek implementálásával), vagy lokálisan (névtelen interfész implementálásával) oldottuk meg, illetve besegítettek adapterek is. Sok- és többféle eseménynél ez a forráskódunk elaprózódásához vezetett, ami nehézkes olvashatóságot és karbantarthatóságot eredményezett.

A lambda kifejezés egy olyan kódrészlet, amelyben valamihez hozzárendelünk valamit, például egy metódus paraméteréhez a végrehajtandó forráskódot ( x -> y). Ehhez építünk a funkcionális interfészekre és a metódus referenciákra (szintén Java 8-tól), illetve a típus kikövetkeztetés képességére is (Java 7-től).

A kiválogatás programozási tételt valósítjuk meg többféle implementációval, felhasználva a Java nyelv újdonságait, és a fentieken kívül még a Stream API-t is.

Adatforrás

Először is kellenek adatok, hiszen azokat dolgozzuk fel. Egy Termek osztályú egyszerű POJO-val dolgozunk, nev és ar tulajdonságokkal, generált konstruktorral, getter metódusokkal és toString()-gel. Az adatforrást biztosító absztrakt Lista ősosztályban a POJO-kból felépítünk egy termekLista nevű generikus listát (például CSV vagy XML fájlból beolvasva az összetartozó adatokat) – listaFeltolt() eljárás – és implementálunk egy univerzálisan használható listaKiir(String uzenet, List termekLista) eljárást is.

abstract class Lista {

private File xmlFajl=new File("./files/prod.xml");

private File csvFajl=new File("./files/prod.csv");

protected ArrayList termekLista=null;

public Lista() {

listaFeltolt();

listaKiir("Összes termék listája", termekLista);

}

private void listaFeltolt() {

…

}

public void listaKiir(String uzenet, List termekLista) {

System.out.print(uzenet+" - ");

if(termekLista.isEmpty()) {

System.out.println("Nincs ilyen termék.\n");

return;

}

System.out.println(termekLista.size()+" db:");

termekLista.forEach(termek -> System.out.println(termek));

System.out.println();

}

Örökítünk három utódosztályt a Lista osztályból, amelyek különbözőképpen dolgozzák fel a termekLista-t, bemutatva a fejlődés útját, illetve a rendelkezésre álló lehetőségeket.

Válogassunk a termékek közül négyféleképpen és adjuk vissza azon termékeket, amelyek:

limit alatti áron kaphatók,
ára limit1 és limit2 közé esik (zárt intervallumban),
neve adott szöveggel kezdődik (kis- és nagybetű különbözik),
neve adott szöveget tartalmaz (kis- és nagybetű nem különbözik)!

1. változat

Hagyományos megközelítéssel a fentiek megvalósításához külön egy-egy függvény tartozik, ahogyan az alábbiakban látható:

class Kivalogatas1 extends Lista {

private List termekListaLimitAr1(int limit) {

//limit ár alatti termékek listája

List lista=new ArrayList<>();

// for (int i = 0; i < termekLista.size(); i++) //1

// if(termekLista.get(i).getAr()<limit)

// lista.add(lista.get(i));

//// Iterator i=termekLista.iterator(); //2

//// while(i.hasNext()) {

//// Termek termek=i.next();

//// if(termek.getAr()<limit)

//// lista.add(termek);

//// }

////// for (Termek termek : termekLista) //3

////// if(termek.getAr()<limit) ////// lista.add(termek); //////// termekLista.stream(). //4 //////// filter(termek -> termek.getAr()<limit). //////// forEach(termek -> lista.add(termek));

lista=termekLista.stream(). //5

filter(termek -> termek.getAr()<limit).

collect(Collectors.toList());

return lista;

}

private List termekListaLimitAr2(int limit1, int limit2) {

//limit1<=ár<=limit2 termékek listája

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> limit1<=termek.getAr() &&

termek.getAr()<=limit2). forEach(termek -> lista.add(termek));

return lista;

}

private List termekListaSzoveg1(String szoveg) {

//szoveg-gel kezdődő terméknevek listája (kis- és nagybetű különbözik)

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> termek.getNev().startsWith(szoveg)).

forEach(termek -> lista.add(termek));

return lista;

}

private List termekListaSzoveg2(String szoveg) {

//szoveg-et tartalmazó terméknevek listája (kis- és nagybetű nem különbözik)

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> termek.getNev().toLowerCase().

contains(szoveg.toLowerCase())).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10", termekListaLimitAr1(10));

listaKiir("Terméklista - 10<=ár<=20", termekListaLimitAr2(10, 20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaSzoveg1("Sir"));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaSzoveg2("hot"));

}

A termekListaLimitAr1() függvényben látható ötféle lehetőség a kiválogatásra a termekLista-ból:

//1: hagyományos, index alapú változat,
//2: iterátorra közvetlenül építő változat,
//3: bejáró ciklus, iterátorra közvetve építő változat,
//4: Stream API-ra építő változat, kiválogatás lambda-kifejezéssel ( filter), a megmaradó termékekre végrehajtandó forEach művelet lambda kifejezéssel,
//5: Stream API-ra építő változat, kiválogatás lambda-kifejezéssel ( filter), a megmaradó termékeket összegyűjtő/leképező collect művelettel.

Jól megfigyelhető, hogy négy függvény vázszerkezete megegyezik, és csupán a filter-ben található lambda-kifejezések különböznek. Ez a megoldás meglehetősen redundáns, nem általánosítható, valamint további műveletek megvalósítása további függvények implementálását igényli.

2. változat

Őrizzük meg a négyféle funkciót, sőt tegyük lehetővé, hogy ez tetszőlegesen bővíthető legyen. Használjunk saját generikus, funkcionális Feltetel interfészt saját döntés megvalósítását biztosítani tudó implementálandó teszt() függvénnyel, az alábbiak szerint:

class Kivalogatas2 extends Lista {

private List termekListaFeltetel(Feltetel feltetel) {

//feltetel-t teljesítő termékek listája

List lista=new ArrayList<>();

// for (Termek termek : termekLista)

// if(feltetel.teszt(termek))

// lista.add(termek);

termekLista.stream().

filter(termek -> feltetel.teszt(termek)).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10",

termekListaFeltetel(new Feltetel() {

@Override

public boolean teszt(Termek t) {

return t.getAr()<10;

}

}));

// listaKiir("Terméklista - ár<10", termekListaFeltetel((Termek termek) -> termek.getAr()<10));

listaKiir("Terméklista - 10<=ár<=20",

termekListaFeltetel((Termek termek) ->

10<=termek.getAr() && termek.getAr()<=20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().startsWith("Sir")));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().toLowerCase().contains("hot".toLowerCase())));

}

A termekListaFeltetel() függvény paramétere a saját Feltetel interfészünket implementáló névtelen osztály példánya, amely felhasználható:

//6: ciklusban egyszerű feltételként,
//7: Stream API filter műveletében megadott lambda-kifejezésben,
//8: a listaKiir() metódusban paraméterként átadva névtelen osztály példányaként,
//9-től: a listaKiir() metódusban paraméterként átadva lambda-kifejezésként.

Látszik, hogy többféle kiválogató művelethez egyetlen implementált függvény szükséges. Ez a megoldás már jóval általánosabb.

3. változat

A saját interfész helyett használjuk fel a beépített Predicate generikus, funkcionális interfészt, építve annak test() függvényére az alábbiak szerint:

class Kivalogatas3 extends Lista {

private List termekListaFeltetel(Predicate feltetel) {

//feltetel-t teljesítő termékek listája

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> feltetel.test(termek)).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10",

termekListaFeltetel(new Predicate() {

@Override

public boolean test(Termek t) {

return t.getAr()<10;

}

}));

listaKiir("Terméklista - ár<10",

termekListaFeltetel( (Termek termek) -> termek.getAr()<10));

listaKiir("Terméklista - 10<=ár<=20",

termekListaFeltetel((Termek termek) ->

10<=termek.getAr() && termek.getAr()<=20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaFeltetel( (Termek termek) ->

termek.getNev().startsWith("Sir")));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().toLowerCase().contains("hot".toLowerCase())));

}

Belépési pont

Végül következzen a közös belépési pont, amelyben tetszőlegesen aktiválható és tesztelhető mindhárom változat működése:

public class Kivalogatas {

public static void main(String[] args) {

//new Kivalogatas1().run();

//new Kivalogatas2().run();

new Kivalogatas3().run();

}

Mit ír ki a program a konzolra?

Összes termék listája - 77 db:

Chai, 18.0

Chang, 19.0

Aniseed Syrup, 10.0

---

Rhönbräu Klosterbier, 7.75

Lakkalikööri, 18.0

Original Frankfurter grüne Soße, 13.0

Terméklista - ár<10 - 11 db:

Konbu, 6.0

Teatime Chocolate Biscuits, 9.2

Tunnbröd, 9.0

Guaraná Fantástica, 4.5

Geitost, 2.5

Jack's New England Clam Chowder, 9.65

Rogede sild, 9.5

Zaanse koeken, 9.5

Filo Mix, 7.0

Tourtiere, 7.45

Rhönbräu Klosterbier, 7.75

Terméklista - ár<10 - 11 db:

Konbu, 6.0

Teatime Chocolate Biscuits, 9.2

Tunnbröd, 9.0

Guaraná Fantástica, 4.5

Geitost, 2.5

Jack's New England Clam Chowder, 9.65

Rogede sild, 9.5

Zaanse koeken, 9.5

Filo Mix, 7.0

Tourtiere, 7.45

Rhönbräu Klosterbier, 7.75

Terméklista - 10<=ár<=20 - 29 db:

Chai, 18.0

Chang, 19.0

Aniseed Syrup, 10.0

Genen Shouyu, 15.5

Pavlova, 17.45

Sir Rodney's Scones, 10.0

NuNuCa Nuß-Nougat-Creme, 14.0

Gorgonzola Telino, 12.5

Sasquatch Ale, 14.0

Steeleye Stout, 18.0

Inlagd Sill, 19.0

Chartreuse verte, 18.0

Boston Crab Meat, 18.4

Singaporean Hokkien Fried Mee, 14.0

Gula Malacca, 19.45

Spegesild, 12.0

Chocolade, 12.75

Maxilaku, 20.0

Valkoinen suklaa, 16.25

Ravioli Angelo, 19.5

Escargots de Bourgogne, 13.25

Louisiana Hot Spiced Okra, 17.0

Laughing Lumberjack Lager, 14.0

Scottish Longbreads, 12.5

Outback Lager, 15.0

Röd Kaviar, 15.0

Longlife Tofu, 10.0

Lakkalikööri, 18.0

Original Frankfurter grüne Soße, 13.0

Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik) - 3 db:

Sir Rodney's Marmalade, 81.0

Sir Rodney's Scones, 10.0

Sirop d'érable, 28.5

Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik) - 2 db:

Louisiana Fiery Hot Pepper Sauce, 21.05

Louisiana Hot Spiced Okra, 17.0

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.

Máskor is blogolunk a témakörben: Stream API lambda kifejezésekkel.

Java fejtörők – haladó

2023. augusztus 4.2017. június 5. Szerző: Balogh Péter

Java fejtörők – csapdák, buktató, és szélsőséges esetek. Ez egy könyv címe, amelynek szerzői J. Bloch és N. Gafter. Magyar nyelven a Kiskapu Kft. jelentette meg. A 2010-es magyar kiadás a 2005-ös angol nyelvű kiadás fordítása. A könyv weboldaláról (http://www.javapuzzlers.com), letölthető a 95 fejtörőhöz tartozó mintapéldák gyűjteménye, és elérhető a 270 oldalból minta fejezetként 28 oldalnyi tartalom 9 fejtörővel és azok részletes magyarázataival.

A két részre bontott blog bejegyzés a könyv anyagából válogatva készült el. Az első rész a bevezetés. Ez a második rész, haladó szintű példákkal. Néhány példát továbbfejlesztettem.

7. fejtörő: Mit ír ki program a konzolra?

public class Test {

static void workHard() {

try {

workHard();

}

finally {

workHard();

}

public static void main(String[] args) {

workHard();

System.out.println("Hello World!");

}

Kivételkezelés nélkül arra számítanánk, hogy a Hello World! nem jelenik meg a konzolon, mert a wordHard() metódus feltétel nélkül rekurzív módon folyamatosan újrahívja önmagát és az emiatt keletkező StackOverflowError hibával elszáll a program. A kivételkezelés természetesen módosítja a program működését.

Ha azt feltételezzük, hogy minden Throwable utódosztályból futás közben létrehozott objektum kivételkezeléssel elkapható, akkor végtelen ciklusnak tűnik a vezérlés, hiszen a try blokkban hibát okozó metódushívásra a finally blokkban újra ugyanannak a metódusnak a meghívásával reagálunk, amelyik korábban a hibát kiváltotta. Ez a gondolatmenet tévút. A kulcsszó a rekurzív vezérlést megvalósító verem adatszerkezet mérete. Részletes indoklás a blog bejegyzés végén található.

8. fejtörő: Mit ír ki program a konzolra?

public class Null {

static void greet() {

System.out.println("Hello World!");

}

public static void main(String[] args) {

((Null)null).greet();

}

Természetesen NullPointerException-re gyanakszunk, pedig a program hibátlanul működik. A kulcsszó a statikus metódusok minősítése, vagyis annak jelölése, hogy melyik osztálytól vagy objektumtól kérjük annak végrehajtását. Részletes indoklás a blog bejegyzés végén található.

9. fejtörő: Mit ír ki a program a konzolra?

import java.util.Calendar;

import java.util.Date;

public class Test {

public static void main(String[] args) {

Calendar c=Calendar.getInstance();

c.set(1999, 12, 31);

Date d=c.getTime();

System.out.println(c.get(Calendar.YEAR)+"-"+d.getDay());

}

Arra számítunk, hogy a kiírás 1999-12, de ehelyett 2000 1-et látunk a konzolon. Tudjuk, hogy a Date osztály jó része már deprecated és ezen próbáltak javítani a Calendar osztállyal. Bár ne tették volna. A kulcsszó az ős dátumkezelést megvalósító API rejtelmeiben van. Részletes indoklás a blog bejegyzés végén található.

10. fejtörő: Mit ír ki a program a konzolra?

class X {

static class Y {

static String Z="Black";

}

static C Y=new C();

}

class C {

String Z="White";

}

public class Test {

public static void main(String[] args) {

System.out.println(X.Y.Z);

}

Nem tűnik egyértelműen eldönthetőnek a helyzet, ezért szintaktikai hibára gyanakodhatunk. Azonban a forráskód helyes, a program futás közben sem dob kivételt/hibát és a konzolon megjelenik a White. Szokatlan, hogy nagybetűvel konstansokat szokás jelölni, pedig nincs erre utaló final a forráskódban. A kulcsszó a sorrendiségen van, ha ugyanabban a hatókörben/blokkban van azonos nevű változó és típus/osztály. Részletes indoklás a blog bejegyzés végén található.

11. fejtörő: Mit ír ki a program a konzolra?

import java.util.Random;

public class Test {

private static Random r=new Random();

private static void swap(Object[] a, int i, int j) {

Object temp=a[i];

a[i]=a[j];

a[j]=temp;

}

public static Object[] shuffle(Object[] a) {

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

swap(a, i, r.nextInt(a.length));

return a;

}

public static void main(String[] args) {

String[] s1={"alma", "körte", "barack", "dinnye"};

for(Object o: shuffle(s1))

System.out.print(o+", ");

System.out.println();

}

A program helyes és egyértelműnek tűnik. A konzolra az s1 szövegtömb elemei kerülnek ki véletlenszerűen összekeverve. Finomítsunk a kérdésen. Vajon minden lehetséges permutáció azonos eséllyel fordul elő? Ha ez a kérdés egyáltalán felmerül, akkor a válasz nyilván nem. A kulcsszó most egy kis matematika. Részletes indoklás a blog bejegyzés végén található.

12. fejtörő: Mit ír ki a program a konzolra?

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

Integer[] array={3, 1, 4, 1, 5, 9};

Arrays.sort(array,

(Integer i1, Integer i2) -> i1 < i2 ? -1 : (i2 > i1 ? 1 : 0));

System.out.println(Arrays.toString(array));

}

Ez a forráskód nem úgy működik, ahogyan a könyv írja. Meglepő módon nem a [3, 1, 4, 1, 5, 9]-et adja, hanem az [1, 1, 3, 4, 5, 9]-et. Némi indoklás a blog bejegyzés végén található.

Részletes indoklások

7. fejtörő: ha a try blokkban folyamatosan meghívja saját magát a workHard() metódus, akkor előbb-utóbb betelik a verem. Ekkor a finally blokkra kerül a vezérlés, ahonnan újra hívja saját magát a workHard() metódus. Persze követni kell, hogy a rekurzió végrehajtása során a lefelé haladó vagy a felszálló ágon vagyunk és nem mindegy, hogy melyik szinten. A háttérben egy teljes bináris fa bontakozik ki, amelynek mélysége azonos a verem méretével, mélységi korlátjával. Ezt a teljes bináris fát járja be a program, azaz mélységi fabejárás. Egy n mélységű teljes bináris fa elemeinek száma 2ⁿ-1. A verem mérete a virtuális gép beállításaitól függ, több ezer mélységű is lehet. Végtelen ciklusról tehát nincs szó. Ugye milyen izgalmas? További részletek a könyv 100-102. oldalán találhatók.
8. fejtörő: a végrehajtás kiértékeli a statikus greet() metódus hívásának minősítő kifejezését, de figyelmen kívül hagyja a kapott értéket. A metódust végrehajthatnánk Null.greet()-ként vagy közvetlenül (minősítés nélkül) meghívva is. További részletek a könyv 122-124. oldalán találhatók.
9. fejtörő: a Date osztály a hónapokat nulla bázissal kezeli, ezért csak 0-11-ig „van értelme”. Számíthatnánk a tömb vagy szöveg túlindexelésénél tapasztaltakhoz hasonlóan kivételre, de nem ez történik. A 12. hónap a következő év első/nulladik hónapját jelöli. Ezért látjuk a konzolon a 2000-et, amit egy kötőjel követ. A Date.getDay() deprecated metódus pedig a dátumobjektumban tárolt nap adott héten (nem hónapban!) elfoglalt helyét adja meg, ami nullával, azaz vasárnappal indul. Tehát a konzolon megjelenő 1 nem a 2000. januárt jelenti, hanem azt, hogy a 2000. január 31. hétfőre esik. Aki ezek után meri használni a régi dátumkezelő API-t, magára vessen. További részletek a könyv 141-143. oldalán találhatók.
10. fejtörő: ha ugyanabban a hatókörben/blokkban van azonos nevű változó és típus/osztály, akkor a változó neve az elsődleges. Ha betartjuk a névadási konvenciókat ( ClassName, objectName, CONSTANT_NAME), akkor nem adódhatnak ilyen gondok. Még egy csavar van: ha az előző elnevezési módosításokat megtesszük, akkor a program a Black-et írja ki a konzolra. További részletek a könyv 161-163. oldalán találhatók.
11. fejtörő: konkrét esetből általánosítunk. 4 elemre a ciklus 4-szer hajtódik végre és minden lépésben kiválaszt egyet a 0 és az 3 indexű elemek közül, ami 4⁴=256-féle lehetséges eredményt ad. Ha az r objektum jól működik, akkor az egyes futások esélye/valószínűsége megegyezik. 4 elemű tömb elemeinek 4!=24 (faktoriális) féle permutációja (lehetséges sorrendje) van. Mivel a 256 nem osztható 24-gyel, így biztos, hogy a shuffle() metódus bizonyos permutációkat gyakrabban állít elő, mint másokat. Általánosan: nⁿ nem osztható n!-sal, ha n>2 egész szám. Vajon mi történik, ha egy 52 lapos pakli kártyát keverünk össze? Vajon milyen érdekességet vet ez fel? Minden poént nem lövünk le itt a blogban. További részletek a könyv 228-232. oldalán találhatók.
12. fejtörő: ez a tankönyv utolsó példája. A felvetett gondolat nagyon frappáns: az összehasonlító rész „ha fej, én nyerek, ha írás, te veszítesz” tüneteitől szenved. További részletek a könyv 232-233. oldalán találhatók.

Állásinterjúkon időnként visszaköszönnek hasonló fejtörők, de ezekkel óvatosan kell bánni. Egy programozási nyelv „joghézagainak”, buktatóinak, szélsőséges eseteinek ismerete a könyv szintjét elérő ismeretanyaggal nem lehet elvárt még egy meghirdetett senior pozíció esetén sem. Ezen fejtörők ismerete (vagy nem tudása) egy jelöltről nem árulja el a mindennapokban használható szakmai tudás meglétét/hiányát. De nyilván aki szakmailag folyamatosan fejlődik és mindenféle keretrendszert alkotó forráskódokban turkál, elemez, előbb-utóbb találkozik ezekkel/ilyenekkel.

Tanfolyamainkon nem kifejezetten foglalkozunk hasonló problémákkal, de azért időnként feszegetjük a határokat. Természetesen részletesen indokoljuk, ha előkerül valamilyen hasonló eset. Általánosságban nem célunk, hogy extrém eseteken keresztül, a programozási nyelv gyenge pontjaira kihegyezve oktassuk a Java programozási nyelvet.