Java forráskód - címke - Oldal 9 a 13-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!

Időjárás Budapesten

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

Talált időjárás Widget

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

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

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

window.myWidgetParam.push({

id: 15,

cityid: '3054643',

appid: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',

units: 'metric',

containerid: 'openweathermap-widget-15',

});

(function() {

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

script.async = true;

script.charset = "utf-8";

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

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

s.parentNode.insertBefore(script, s);

})();

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

Saját fejlesztés

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

1. feladat

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

2. feladat

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

private void setJsonPuffer() {

jsonPuffer=new StringBuilder();

try {

HttpURLConnection c=

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

c.setRequestMethod("GET");

c.connect();

InputStream is=c.getInputStream();

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

String line;

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

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

is.close();

c.disconnect();

}

catch(MalformedURLException e) {

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

}

catch(ProtocolException e) {

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

}

catch(IOException e) {

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

}

A jsonPuffer objektum ezt tartalmazza:

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

3. feladat

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

private void jsonProcessing() {

try {

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

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

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

weatherDescription=json.getJSONArray("weather").

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

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

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

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

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

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

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

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

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

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

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

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

weatherIcon = ImageIO.read(weatherIconURL);

}

catch(JSONException e) {

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

}

catch(MalformedURLException e) {

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

}

catch(IOException e) {

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

}

4. feladat

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

private void revalidateData() {

lbNameCountry.setText(modell.getOWMNameCountry());

lbWeatherDescription.setText(modell.getWeatherDescription());

lbWeatherIdIcon.setText("");

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

lbTemp.setText(modell.getOWMTemp());

lbWind.setText(modell.getOWMWind());

lbHumidity.setText(modell.getOWMHumidity());

lbPressure.setText(modell.getOWMPressure());

lbDateTime.setText(modell.getOWMDateTime());

}

Az eredmény

IdojarasHouston

IdojarasTokyo

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

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

A feladat a Java EE szoftverfejlesztő tanfolyam 9-12. óra: XML feldolgozás és 13-16. óra: JSON feldolgozás alkalmaihoz kapcsolódik.

Barátságos számok

2023. augusztus 15.2018. július 19. Szerző: Balogh Péter

Azokat a számpárokat, amelyekre igaz, hogy az egyik szám önmagánál kisebb osztóinak összege megegyezik a másik számmal és fordítva, külön-külön barátságos számoknak, együtt barátságos számpárnak hívjuk.

Másképpen: legyen d(n) az n természetes szám önmagánál kisebb osztóinak összege. Ha d(a)=b és d(b)=a, ahol a≠b, akkor a és b barátságos számpár.

Például: (220; 284), hiszen a 220 önmagánál kisebb osztói: 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110 és ezek összege 284, illetve 284 önmagánál kisebb osztói: 1, 2, 4, 71, 142 és ezek összege 220.

Írjunk Java programot, amely kiírja az 1-10000 zárt intervallumban található barátságos számpárokat!

1. megoldás

A baratsagosSzamparok1() eljárás ciklusai a brute force módszer szerint behelyesítik az összes lehetséges számot. Minimális lépésszám csökkentésre adódik lehetőség, hiszen a belső ciklus j változója i+1-ről indítható (így a megtalált számpárok nem íródnak ki fordítva is, mert teljesül, hogy i<j).

Az osztokOsszege1(n) függvény is minden lehetséges osztót figyelembe vesz 1-től n-1-ig.

private static int osztokOsszege1(int n) {

int s=0;

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

if(n%i==0)

s+=i;

return s;

}

private static void baratsagosSzamparok1() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

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

for(int j=i+1; j<=10000; j++)

if(i==osztokOsszege1(j) && j==osztokOsszege1(i))

System.out.println("("+i+"; "+j+")");

}

2. megoldás

Kisebb módosításokkal a lépésszám csökkenthető. A baratsagosSzamparok2() eljárás külső ciklusánál figyelembe vettem, hogy a legkisebb barátságos számpár kisebb tagja nagyobb 200-nál. Mivel a barátságos számpárok tagjainak paritása mindig megegyezik (azaz mindkettő páros vagy mindkettő páratlan), így a belső ciklus j változója indítható i+2-ről és léptethető kettesével ( j+=2), és továbbra is teljesül, hogy i<j.

Az osztokOsszege2(n) függvényt is módosítottam. Mivel az 1 minden számnak osztója, illetve a 2 minden páros számnak osztója, így s lehet 3 vagy 1 és a ciklus indítható 3-ról. A páros számok esetén a számnál kisebb legnagyobb osztó maximum n/2 lehet, illetve ugyanez páratlan számok esetén n/3 lehet. Ezekre figyelve a max változó adja a ciklus léptetésének felső határát. Az i változó léptetésénél figyelembe vettem, hogy páratlan számnak csak páratlan osztói lehetnek ( i=3-mal szinkronban).

private static int osztokOsszege2(int n) {

int s=(n%2==0?3:1);

int max=(n%2==0?n/2:n/3);

int lepes=(n%2==0?1:2);

for(int i=3; i<=max; i+=lepes)

if(n%i==0)

s+=i;

return s;

}

private static void baratsagosSzamparok2() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

for(int i=200; i<=10000; i++)

for(int j=i+2; j<=10000; j+=2)

if(i==osztokOsszege2(j) && j==osztokOsszege2(i))

System.out.println("("+i+"; "+j+")");

}

3. megoldás

Az eddigi két egymásba ágyazott ciklus helyett átszervezhető a baratsagosSzamparok3() eljárás. A j>i && osztokOsszege2(j)==i feltétel kiértékelése így sokkal hatékonyabb.

private static void baratsagosSzamparok3() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

for(int i=200; i<=10000; i++) {

int j=osztokOsszege2(i);

if(j>i && osztokOsszege2(j)==i)

System.out.println("("+i+"; "+j+")");

}

Vajon milyen nagyságrendű különbségek adódnak, ha összehasonlítjuk a három megoldás futási idejét?

Az 1. megoldás futási ideje 1104156 ms, a 2. megoldásé 257055 ms, a 3. megoldásé 121 ms. A konkrét értékek helyett a nagyságrendet megfigyelve a különbség nagyon látványos.

Mindhárom megoldás helyes és megkapjuk az intervallumban található öt barátságos számpárt: (220; 284), (1184; 1210), (2620; 2924), (5020; 5564), (6232; 6368).

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

Források:

Wikipédia – Barátságos számok
Wikipedia – Amicable numbers
www.mathe.tu-freiberg.de – Vollkommene, befreundete und gesellige Zahlen
gorbem.hu – Barátságok számok
Hasonló feladat: https://projecteuler.net/problem=21 és megoldás: http://code.jasonbhill.com/c/project-euler-problem-21/

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: Metódusok, rekurzió alkalomhoz kötődik.

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

2023. január 3.2018. május 10. Szerző: Kaczur Sándor

A 2018-as középszintű matematika érettségi feladatsor 10. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá néhány programozási tétel: sorozatszámítás, eldöntés, kiválasztás. É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.

10. feladat

Adja meg az alábbi adathalmaz móduszát, mediánját és terjedelmét!
2; 6; 6; 6; 6; 6; 3; 3; 4; 4; 4; 5; 5; 5; 5

Tervezés

A Java 8 által biztosított újdonságok közül használunk néhányat. Célszerű konstans tömbben tárolni a megadott számsorozatot, ami könnyen konvertálható generikus listába. Alkalmazkodni kell ahhoz, hogy a lista indexelése 0-tól lista.size()-1 -ig értelmezhető. Hasznos, ha a konkrét feladatok helyett általános megoldásokban gondolkodunk és a feladatot 3 metódusra bontjuk, amelyek ellenőrzéseket is végeznek. Például extrém esetek:

ha a lista üres, akkor nincs módusz, medián, terjedelem,
ha a lista egyetlen elemből áll, akkor a módusz és a medián megegyezik az elemmel, a terjedelem pedig nulla,
ha leggyakrabban több különböző szám is előfordul, akkor a módusz ezek közül a (leg)kisebb számot adja vissza.

Elvárjuk, hogy probléma esetén a metódusok dobjanak kivételt. Lényeges, hogy a referencia szerinti paraméterátadás során megváltozna a listában az elemek sorrendje, mert a megoldás igényli az elemek rendezettségét, akkor készüljön másolat az adatszerkezetről, hogy egy-egy részfeladat megoldása nem járjon azzal a mellékhatással, hogy az eredeti adatszerkezetben megváltozik az elemek sorrendje. Felhasználjuk a primitív típusú változók és a csomagolóosztályok közötti konverziós lehetőségeket: autoboxing és unboxing.

Megoldás: módusz

A módusz a lista leggyakoribb értékét adja meg. Másképpen az az érték, amelyik az adatsorban a legtöbbször előfordul.

public static int modusz(List<Integer> szamLista) {

if(szamLista.isEmpty())

throw new IllegalArgumentException("Hiba! Üres lista.");

List<Integer> lista=

szamLista.stream().collect(Collectors.toList());

Collections.sort(lista);

int i=0, maxAktSzam=0, maxAktSzamDb=0;

while(i<lista.size()) {

int aktSzam=lista.get(i), aktSzamDb=0;

while(i<lista.size() && lista.get(i)==aktSzam) {

aktSzamDb++;

i++;

}

if(aktSzamDb>maxAktSzamDb) {

maxAktSzam=aktSzam;

maxAktSzamDb=aktSzamDb;

}

return maxAktSzam;

}

A modusz() metódus átveszi a szamLista-t és készít róla lista néven egy másolatot, majd utóbbit növekvő sorrendbe rendezi. A másolat a Stream API-val készül el. Ezután csoportváltás algoritmussal feldolgozza a listát. Egy csoportba az azonos számok kerülnek és léptetés közben a belső ciklus megszámolja, hogy hány azonos szám alkotja az aktuális csoportot. Végül összehasonlítás következik a szélsőérték-kiválasztás ( aktSzamDb>maxAktSzamDb) beépítésével.

Megoldás: medián

A medián a lista középső értéke, amelynél az ennél kisebb és nagyobb elemek száma azonos. Rendezett adatsornál páratlan elemszám esetén a középső elem, illetve páros elemszám esetén a két középső elem átlaga.

public static double median(List<Integer> szamLista) {

if(szamLista.isEmpty())

throw new IllegalArgumentException("Hiba! Üres lista.");

List<Integer> lista=

szamLista.stream().collect(Collectors.toList());

Collections.sort(lista);

int n=lista.size();

return n%2==0?

(lista.get((n-1)/2)+lista.get((n-1)/2+1))/2.0 :

lista.get((n-1)/2);

}

A median() metódus átveszi a szamLista-t és készít róla lista néven egy másolatot, majd utóbbit növekvő sorrendbe rendezi. Ezután páros elemszám esetén visszaadja a két középső elem átlagát, illetve páratlan elemszám esetén a középső elemet. A metódusnak valós értéket ( double) kell visszaadnia, mert a két középső elem átlaga nem feltétlenül egész szám.

Megoldás: terjedelem

A terjedelem azt mutatja meg, hogy mekkora értékközben ingadoznak a lista elemei. A terjedelem az adatok változékonyságának „legdurvább” jellemzője, ami a szélsőértékek (minimum és maximum) közötti különbséget jelenti.

public static int terjedelem(List<Integer> szamLista) {

if(szamLista.isEmpty())

throw new IllegalArgumentException("Hiba! Üres lista.");

int min=Collections.min(szamLista), max=Collections.max(szamLista);

return max-min;

}

A terjedelem() metódus átveszi a szamLista-t paraméterként és visszaadja a két szélsőérték különbségét, amelyek a Collections osztály metódusaival könnyen előállítható. Persze egyetlen ciklussal is megkaphatnánk a két szélsőértéket.

Eredmény

A vezérlést az alábbi main() metódus végzi el:

public static void main(String[] args) {

int[] szamTomb={2, 6, 6, 6, 6, 6, 3, 3, 4, 4, 4, 5, 5, 5, 5};

List<Integer> szamLista=

Arrays.stream(szamTomb).boxed().collect(Collectors.toList());

System.out.println(

"A sorozat elemei: "+szamLista+"\n"+

"Módusz: "+modusz(szamLista)+"\n"+

"Medián: "+median(szamLista)+"\n"+

"Terjedelem: "+terjedelem(szamLista));

}

A konzolon az alábbi eredményt kapjuk:

A sorozat elemei: [2, 6, 6, 6, 6, 6, 3, 3, 4, 4, 4, 5, 5, 5, 5]

Módusz: 6

Medián: 5.0

Terjedelem: 4

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

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

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra: Objektumorientált programozás alkalmaihoz kötődik.

Koch-görbe rajzolása

2023. július 8.2018. április 23. Szerző: Kaczur Sándor

A Koch-görbe egyike a legrégebben ismert egyszerű fraktáloknak. Mint ilyen, önhasonlóan rekurzív. Az önhasonlóság azt jelenti, hogy az ábra tetszőleges részét felnagyítva mindig hasonló/ugyanolyan részek jelennek meg (a méretaránytól függetlenül). Az n=1 szinten a Koch-görbe kiindulópontja egy szabályos háromszög. A n+1-edik szinten az n-edik szinten található szakaszokat harmadoljuk, és a középső szakasz helyére egy harmad akkora háromszög két szárát illesztjük (az alapját kihagyjuk). Ezt rekurzívan folytatva kapjuk meg a Koch-görbét, másképpen Koch-féle hópelyhet.

Írtam egy egyszerű Java programot, amely n=1-től 9-ig paraméterezhetően kirajzolja a Koch-görbét egy grafikus felületre. Így működik:

A program elkészítéséhez néhány alapvető dolgot kell csupán tudni:

Vászontechnikával tudunk swing GUI felületre ( Graphics osztályú g objektum) rajzolni, ahol a koordináta-rendszer origója egy téglalap alakú terület bal felső csúcsa, X jobbra növekszik, Y pedig lefelé növekszik.
Kétféle szín áll rendelkezésre: háttérszín (most Color.WHITE), illetve rajzolószín (most Color.BLUE).
A rajzoláshoz grafikai primitíveket használhatunk, például pont, szakasz, téglalap, ellipszis. Szakaszt két végpontjának koordinátáival tudunk rajzolni a drawLine() metódussal.
Be kell állítani a vászon méreteit, azaz annak a komponensnek ( JPanel-ből öröklött KochPanel osztályú pnKoch objektum) a méreteit, amelyre ráfeszül a vászon.
Egy Slider osztályú sSzint nevű vezérlőobjektum ChangeListener figyelőinterfész stateChanged() eseménykezelő metódust implementáló objektumával paraméterezzük a rajzolást 1-től 9-ig.
A pnKoch objektumnak küldött repaint() üzenet/metódushívás meghívja a felüldefiniált paintComponent() metódust.

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

g.setColor(Color.BLUE);

koch(n, 200, 51, 60, 300, g);

koch(n, 60, 300, 340, 300, g);

koch(n, 340, 300, 200, 51, g);

}

A szakasz négy darab harmad akkora szakaszra osztását a megfelelően paraméterezett rekurzív metódushívások oldják meg az alábbi lépéseket követve:

A rekurzív rajzolást a koch() metódus végzi el, ahol a fraktál szabályának megfelelően szakaszharmadolás és a szükséges pontok koordinátáinak (szakaszok végpontjai) kiszámítása történik:

private void koch(int n, int x1, int y1, int x5, int y5, Graphics g) {

if(n==1)

g.drawLine(x1, y1, x5, y5);

else {

double gy=Math.sqrt(3)/6;

int dx=x5-x1, dy=y5-y1,

x2=x1+dx/3, y2=y1+dy/3,

x3=(int)((x1+x5)/2+gy*(y1-y5)), y3=(int)((y1+y5)/2+gy*(x5-x1)),

x4=x1+dx*2/3, y4=y1+dy*2/3;

koch(n-1, x1, y1, x2, y2, g);

koch(n-1, x2, y2, x3, y3, g);

koch(n-1, x3, y3, x4, y4, g);

koch(n-1, x4, y4, x5, y5, g);

}

A Koch-görbének van néhány érdekes tulajdonsága:

kerülete minden rekurzív lépésben minden határon túl növekszik, azaz a végtelenhez tart,
területe véges, hiszen minden rekurzív lépésben belefér a háromszög köré írható körbe,
dimenziója tört, ~ 1,261859.

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

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: Metódusok, rekurzió alkalomra építő 29-36. Grafikus felhasználói felület alkalomhoz kötődik.