dátumkezelés - címke - Oldal 2 a 2-ből

Dátumtartományok kezelése

2023. január 1.2020. február 8. Szerző: Kaczur Sándor

Aki webáruházat üzemeltet és raktároz, befektet áruk raktározásába, biztosan folyamatosan követi a raktárkészlet (és egyúttal pénzügyei) alakulását különböző lekérdezésekkel. Aki online marketinggel foglalkozik, szintén mérheti/követheti/összevetheti egy-egy reklámkampány eszközeinek (Facebook hirdetés, Google Ads hirdetés, e-mail marketing, Instagram hirdetés, blog) eredményességét, hatékonyságát. Az adatok elemzése mindenképpen része a tervezésnek és folyamatosnak/periodikusnak kell lennie.

Tipikus felmerülő kérdések/problémák

Hány offline és/vagy online vásárlás/tranzakció volt eddig az aktuális hónapban?
Hogyan változott a raktárkészlet az előző hónapban? Miből kell utánrendelni? Mik a kifutó termékek?
A bevétel milyen arányban érkezett offline vagy online vásárlásból az aktuális hónapban?
Kik vásároltak az előző negyedévben nyomtatót? Küldjünk nekik e-mailt arról, most 10%-kal olcsóbban rendelhetnek tonert, ha kettőt vesznek!
Milyen értékben adtak le rendelést a webáruházban két adott dátum által megadott napon? Például hogyan alakult az utóbbi két Black Friday? Esetleg GLAMOUR-napok, húsvét, hosszú hétvége…
Kik azok a rendszeres visszatérő vásárlóink, akik nem vásároltak az előző hónapban?
Hogyan alakultak „a számok” az előző két év 3. negyedévében!

Egy webáruház raktárkészletének és számláinak nyilvántartása biztosan adatbázisban tárolódik, így könnyen megfogalmazható SQL lekérdező parancsok segíthetik a fenti kérdésekre/problémákra való válaszadást. Természetesen ezeket a műveleteket okosan ki kell vezetni a felhasználói felületre, hogy könnyen paraméterezhetők legyenek.

Lássunk néhány megoldást! A Java forráskódokból azokat a részeket mutatjuk be, amelyek egy lekérdező parancsba beágyazható dátumokra vonatkozó feltételeket kiírják. A dátumok megjelenítésére rövid formátumot használunk konstansként: SimpleDateFormat SHORT_DATE=new SimpleDateFormat("yyyy-MM-dd");.

Aktuális hónap

Érdemes készíteni két túlterhelt metódust. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti maximálisnak és ehhez adja meg az adott hónap első/minimális napját. A két dátumnál az év és hónap megegyezik, a nap többnyire különbözik (ritkán megegyezik). A maxDate nem lehet jövőbeli és teljesül a minDate<=maxDate feltétel.

private void previousMonth() {

previousMonth(new GregorianCalendar());

}

private void currentMonth(GregorianCalendar date) {

String maxDate=SHORT_DATE.format(date.getTime());

System.out.print(maxDate+" -> ");

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH);

int day=1;

GregorianCalendar currentMonthStartDay=

new GregorianCalendar(year, month, day);

String minDate=SHORT_DATE.format(currentMonthStartDay.getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Előző hónap

Itt is érdemes készíteni két túlterhelt metódust. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti kiinduló napnak, és ehhez adja meg az előző hónap első és utolsó napját. A két dátumnál az év és hónap megegyezik, a nap mindig különbözik. Mindkét dátum múltbeli és teljesül a minDate<maxDate feltétel. A megvalósítás kezeli az eltérő hosszúságú hónapokat és a szökőévet is. Ha a kiinduló dátum az adott év első hónapjába esik, akkor az előző hónap az előző év utolsó hónapja (ez most automatikusan teljesül, külön nem kell rá figyelni). Hasznos a dátumobjektum add() metódusa, ami az első paraméterében megadott dátummező alapján a második paraméterében megadott értékkel tudja változtatni a dátumot.

private void previousMonth() {

previousMonth(new GregorianCalendar());

}

private void previousMonth(GregorianCalendar date) {

System.out.print(SHORT_DATE.format(date.getTime())+" -> ");

date.add(Calendar.MONTH, -1); //előző hónap

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH);

int minDay=1;

int maxDay=date.getActualMaximum(Calendar.DAY_OF_MONTH);

String minDate=SHORT_DATE.format(

new GregorianCalendar(year, month, minDay).getTime());

String maxDate=SHORT_DATE.format(

new GregorianCalendar(year, month, maxDay).getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Előző negyedév

Itt is hasznos lehet a két túlterhelt metódus. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti kiinduló napnak, és ehhez adja meg az előző negyedév első hónapjának első napját és az előző negyedév utolsó hónapjának utolsó napját. A két dátumnál az év megegyezik, a hónap és a nap mindig különbözik. Mindkét dátum múltbeli és teljesül a minDate<maxDate feltétel. A megvalósítás kezeli az eltérő hosszúságú hónapokat. A szökőév most nem számít. Ha a kiinduló dátum az adott év első negyedévébe esik, akkor az előző negyedév az előző év utolsó negyedéve (erre most külön figyelni kell). A negyedév ( quarter) képletén látszik, hogy épít arra, hogy a dátumobjektumtól elkért hónap ( month) 0 bázisú.

private void previousQuarter() {

previousQuarter(new GregorianCalendar());

}

private void previousQuarter(GregorianCalendar date) {

System.out.print(SHORT_DATE.format(date.getTime())+" -> ");

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH); //0-11

int quarter=month/3+1

if(quarter==1) {

year--;

quarter=4;

}

else

quarter--;

//negyedév első hónapjának 1. napja

int minMonth=(quarter-1)*3;

int minDay=1;

GregorianCalendar min=new GregorianCalendar(year, minMonth, minDay);

String minDate=SHORT_DATE.format(min.getTime());

//negyedév utolsó hónapjának utolsó napja

int maxMonth=minMonth+2;

min.add(Calendar.MONTH, 2);

int maxDay=min.getActualMaximum(Calendar.DAY_OF_MONTH);

GregorianCalendar max=new GregorianCalendar(year, maxMonth, maxDay);

String maxDate=SHORT_DATE.format(max.getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Eredmény

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 21-24. óra: Objektumorientált programozás, 2. rész kapcsolódik alapvetően, de a két visszakapott dátum használható több programozási tétellel (kiválogatás, szétválogatás) tömbbel, lambda kifejezésekkel kollekciókkal, SQL lekérdező parancsban adatbázis-kezeléshez kötődően.

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.

Péntek 13

2023. augusztus 4.2017. október 13. Szerző: Kaczur Sándor

Sokan szerencsés vagy balszerencsés napnak tartják a péntek tizenharmadikát. Évente 1-2-3 alkalommal megtörténik, hogy a hónap 13. napja péntekre esik (minden vasárnap kezdődő hónapban). A hónap 13. napja valamivel valószínűbben péntekre esik, mint a hét bármely más napja. Átlagosan 212,35 naponként fordul elő péntek 13. Előfordulhat két egymást követő hónapban is, de akár 14 hónap is eltelhet két péntek 13 között.

A nap említése sok helyen előfordult: regényekben, filmekben, híres emberek születése vagy halála is esett péntek 13-ra. Átlag alatti közlekedési baleset szokott előfordulni ezeken a napokon – talán mert az emberek óvatosabbak. Kimutatható összefüggést/korrelációt, „péntek 13 hatást” figyeltek meg a tőzsdén is.

Hasznos lehet, ha írunk egy Java programot, amely néhány egymást követő év esetén listázza a konzolra azokat a hónapokat, amikor 13-a péntekre esik.

Tervezés

Legyen egy listFriday13(year) eljárás, amely a paraméterként átvett évben kiírja azokat a hónapokat a konzolra, amelyekben 13-a péntekre esett/esik. Például: 2017: január, október. A hónapok nevei magyar nyelven jelenjenek meg. Az adott év hónapjain végighaladó ciklus legyen hatékony. Optimalizáljunk a ciklus lépésszámára! A ciklus álljon le, ha már talált 3 hónapot (mivel nem lehet több).

1. megoldás

A megoldást a tematika Tömbök témakörében az alábbiak szerint készíthetjük el. Előismeretek: változók, operátorok, ciklusok, programozási tételek, metódusok, tömbök, String összehasonlítás. Az ismert öröknaptár algoritmusokból implementáljuk az egyiket, például:

static boolean isLeapYear(int year) {

return (year>=1582) &&

((year%4==0 && year%100!=0) || (year%400==0));

}

public static String dayOfWeek(int year, int month, int day) {

int centuryCode=2*(3-year/100%4);

int yearOfCentury=year%100;

int monthCode=new int[] {-1,

isLeapYear(year)?6:0, isLeapYear(year)?2:3, 3, 6,

1, 4, 6, 2,

5, 0, 3, 5

}[month];

int dayCode=(centuryCode+yearOfCentury+

yearOfCentury/4+monthCode+day)%7;

return new String[] {

"Sunday", "Monday", "Tuesday", "Wednesday",

"Thursday", "Friday", "Saturday"

}[dayCode];

}

public static void listFriday13v1(int year) {

String[] months={"",

"január", "február", "március", "április",

"május", "június", "július", "augusztus",

"szeptember", "október", "november", "december"};

System.out.print(year+": ");

for(int month=1, count=1; month<=12 && count<=3; month++)

if(dayOfWeek(year, month, 13).equals("Friday")) {

System.out.print(months[month]+", ");

count++;

}

System.out.println();

}

A listFriday13v1(year) eljárásban az elemi döntés egyszerű: dayOfWeek(year, month, 13).equals("Friday"). Épít az öröknaptárt megvalósító – saját – szöveget visszaadó függvényre. A függvény az algoritmus szerinti kódok előállításához ( centuryCode, monthCode, dayCode) felhasználja a szökőév ( isLeapYear(year)) függvényt, valamint két – konstansnak is tekinthető – névtelen tömböt ( new int[], new String[]).

2. megoldás

A megoldást a tematika Objektumorientált programozás témakörében az alábbiak szerint készíthetjük el. Felhasználjuk eddigi ismereteinket és a JDK beépített dátumkezelő (tároló, formázó) funkcióit (osztályok, interfészek, konstansok, felsorolások).

public static void listFriday13v2(int year) {

SimpleDateFormat dfMonth=

new SimpleDateFormat("MMMM", new Locale("hu"));

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

for(int month=1, count=1; month<=12 && count<=3; month++) {

GregorianCalendar date=new GregorianCalendar(year, month-1, 13);

if(date.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY) {

listMonths.add(dfMonth.format(date.getTime()));

count++;

}

System.out.println(year+": "+String.join(", ", listMonths));

}

A listFriday13v2(year) eljárás a Calendar absztrakt osztály konstansait használja fel az elemi döntéshez: date.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY. A dátumot a GregorianCalendar konstruktora példányosítja és figyelni kell a 0-bázisú hónapkezelésre. A dátum formázása során ( dfMonth) beállítjuk a megfelelően paraméterezett ( "hu") Locale típusú objektumot és a hónap hosszú nevét kérjük ( "MMMM"). A metódus generikus listába gyűjti a kiválasztott hónapok nevét, amiket végül a String.join() függvény fűz össze a megjelenítéshez.

Eredmény

A vezérlésben egy ciklus 2017-től 2036-ig szervezve az alábbi eredményt adja:

Péntek 13 előfordulások

2017: január, október

2018: április, július

2019: szeptember, december

2020: március, november

2021: augusztus

2022: május

2023: január, október

2024: szeptember, december

2025: június

2026: február, március, november

2027: augusztus

2028: október

2029: április, július

2030: szeptember, december

2031: június

2032: február, augusztus

2033: május

2034: január, október

2035: április, július

2036: június

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 tematikájához kötődik a fentiek szerint: 13-16. óra: Tömbök alkalom, illetve 17-28. óra: Objektumorientált programozás alkalom.

Aki gyakorolna a témához kötődően: írjon olyan Java programot, ami listázza a konzolra a 21. század éveit olyan hónapokba csoportosítva, amikor 13-a péntekre esik. Egy év többször is előfordulhat. Például: január – 2006, 2012, 2017, 2023, 2034, 2040, 2045, 2051, 2062, 2068, 2073, 2079, 2090, 2096. A megoldásokat hallgatóinktól az ILIAS-ra, érdeklődőinktől hozzászólásban várjuk.

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.

Húsvétvasárnap

2023. augusztus 4.2017. április 16. Szerző: Kaczur Sándor

A nyugati kereszténység húsvétvasárnapja legkorábban március 22-ére, legkésőbb április 25-re esik. Másképpen: a húsvét mozgó ünnep, azaz nem esik az év ugyanazon napjára minden évben. Az első niceai zsinat 325-ben úgy határozott, hogy legyen a keresztény húsvét időpontja a tavaszi napéjegyenlőség utáni első holdtöltét követő vasárnap.

A húsvét kiszámítására a legismertebb algoritmus Gauss módszere. A Java implementációban az easterGauss() függvény által elfogadható év paramétert életszerűen lekorlátoztam 1900-2099-ig terjedő évekre, valamint a vezérlés az aktuális és a rákövetkező 19 évben ír ki eredményt:

private static final int MIN_YEAR=1900, MAX_YEAR=2099;

public static String easterGauss(int y) {

if(y<MIN_YEAR || y>MAX_YEAR)

throw new IllegalArgumentException(

y+" not in ["+MIN_YEAR+", "+MAX_YEAR+"]");

int a=y%19, b=y%4, c=y%7, d=(19*a+24)%30, e=(2*b+4*c+6*d+5)%7,

h=22+d+e;

if(e==6 && d==29) //1. kivétel

h=50;

if(e==6 && d==28 && a>10) //2. kivétel

h=49;

String message="Húsvétvasárnap "+y+" évben: ";

if(h<=31) //március

message+="március "+h+".";

else //április

message+="április "+(h-31)+".";

return message;

}

public static void main(String[] args) {

System.out.println("Mikor van húsvétvasárnap az alábbi években?");

int startYear=

Math.max(MIN_YEAR, Calendar.getInstance().get(Calendar.YEAR));

int endYear=Math.min(startYear+19, MAX_YEAR);

for (int y=startYear; y<=endYear; y++)

System.out.println(easterGauss(y));

}

Az algoritmus részletes magyarázata alapján könnyen kiegészíthető úgy, hogy tetszőleges évre, illetve különböző naptárakra is működjön.

A kapott eredmények megtekinthetők:

Mikor van húsvétvasárnap az alábbi években?

Húsvétvasárnap 2017 évben: április 16.

Húsvétvasárnap 2018 évben: április 1.

Húsvétvasárnap 2019 évben: április 21.

Húsvétvasárnap 2020 évben: április 12.

Húsvétvasárnap 2021 évben: április 4.

Húsvétvasárnap 2022 évben: április 17.

Húsvétvasárnap 2023 évben: április 9.

Húsvétvasárnap 2024 évben: március 31.

Húsvétvasárnap 2025 évben: április 20.

Húsvétvasárnap 2026 évben: április 5.

Húsvétvasárnap 2027 évben: március 28.

Húsvétvasárnap 2028 évben: április 16.

Húsvétvasárnap 2029 évben: április 1.

Húsvétvasárnap 2030 évben: április 21.

Húsvétvasárnap 2031 évben: április 13.

Húsvétvasárnap 2032 évben: március 28.

Húsvétvasárnap 2033 évben: április 17.

Húsvétvasárnap 2034 évben: április 9.

Húsvétvasárnap 2035 évben: március 25.

Húsvétvasárnap 2036 évben: április 13.

A feladat – a kivételkezeléstől eltekintve – a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek alkalmához kötődik.