Skikkings van Skikkings in Java
https://stackoverflow.com/questions/12870
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianVra
Dit is'n nare een vir my...Ek is'n PHP-man werk in Java op'n JSP projek.Ek weet hoe om te doen wat ek probeer deur te veel kode en'n totale gebrek aan finesse.
Ek sou verkies om dit reg te doen.Hier is die situasie:
Ek is die skryf van'n klein vertoon om te wys kliënte wat dae kan hulle water hul grasperke wat gebaseer is op hul water-groep (ABCDE) en watter tyd van die jaar dit is.Ons seisoene lyk soos hierdie:Somer (5-1 te 8-31) Lente (3-1 te 4-30) Val (9-1 te 10-31) Winter (11-1 te 2-28)
'n voorbeeld kan wees:
As ek in groep A, hier sou my toegelaat tye:Winter:Slegs op maandae Lente:Dinsdag, Donderdag, Sat Somer:Enige Dag Val:Dinsdag, Donderdag, Sat
As ek skryf hierdie in PHP ek sou gebruik die skikkings soos hierdie:
//M=Monday,t=Tuesday,T=Thursday.... etc
$schedule["A"]["Winter"]='M';
$schedule["A"]["Spring"]='tTS';
$schedule["A"]["Summer"]='Any';
$schedule["A"]["Fall"]='tTS';
$schedule["B"]["Winter"]='t';
Ek KON die dae skikkings (array("dinsdag","donderdag","saterdag")), ens, maar dit is nie nodig vir wat ek werklik probeer om te bereik.
Ek sal ook nodig het om te installeer skikkings om te bepaal watter seisoen ek is in:
$seasons["Summer"]["start"]=0501;
$seasons["Summer"]["end"]=0801;
Is daar iemand wat kan dui op'n baie cool manier om dit te doen?Ek sal vandag se datum en die groep brief.Ek sal nodig het om te kry uit my funksie'n dag (M) of'n reeks van dae (tTS), (Enige).
Oplossing
Jy kan basies dieselfde kode met Hashtables (of 'n ander kaart) doen:
Hashtable<String, Hashtable<String, String>> schedule
= new Hashtable<String, Hashtable<String, String>>();
schedule.put("A", new Hashtable<String, String>());
schedule.put("B", new Hashtable<String, String>());
schedule.put("C", new Hashtable<String, String>());
schedule.put("D", new Hashtable<String, String>());
schedule.put("E", new Hashtable<String, String>());
schedule.get("A").put("Winter", "M");
schedule.get("A").put("Spring", "tTS");
// Etc...
Nie so elegant, maar dan weer, Java is nie 'n dinamiese taal, en dit nie hashes op die taalvlak het.
Let wel:. Jy mag dalk in staat wees om 'n beter oplossing te doen, dit net inloer in my kop as ek jou vraag te lees
Ander wenke
Moenie probeer so dinamies soos PHP is om te wees. Jy kan probeer om eerste definieer wat jy nodig het.
interface Season
{
public string getDays();
}
interface User
{
public Season getWinter();
public Season getSpring();
public Season getSummer();
public Season getFall();
}
interface UserMap
{
public User getUser(string name);
}
En asseblief, lees die dokumentasie van Hashtable voordat dit gebruik word. Hierdie klas is gesinchroniseer wat beteken dat elke oproep is beskerm teen multi-threading wat regtig vertraag die toegang wanneer jy nie die ekstra beskerming nodig het. Gebruik asseblief enige Map implementering plaas soos HashMap of TreeMap .
Dit lyk asof almal is probeer om uit te vind die Java manier om dit te doen soos jy dit doen in PHP, in plaas van die manier waarop dit gedoen behoort te word in Java.Net oorweeg elke stuk van jou skikking van'n voorwerp, of, op die heel minste, die eerste vlak van die skikking as'n voorwerp en elke sub vlak as veranderlikes binne die voorwerp.Die bou van'n data struktuur wat jy vul met genoemde voorwerpe en toegang tot die voorwerpe deur middel van die data struktuur gegee accessors.
Iets soos:
class Schedule
{
private String group;
private String season;
private String rundays;
public Schedule() { this.group = null; this.season = null; this.rundays= null; }
public void setGroup(String g) { this.group = g; }
public String getGroup() { return this.group; }
...
}
public ArrayList<Schedule> schedules = new ArrayList<Schedule>();
Schedule s = new Schedule();
s.setGroup(...);
...
schedules.add(s);
...
Van die kursus wat waarskynlik nie reg is nie óf.Ek wil elke seisoen'n voorwerp, en miskien is elke weekdag lys as'n voorwerp te.In elk geval, sy meer maklik weer gebruik, verstaan, en extensible as'n gekniehalter-saam Hashtable wat probeer om na te boots jou PHP-kode.Van die kursus, PHP het voorwerpe te, en jy moet gebruik om hulle in'n soortgelyke wyse in plaas van jou uber-skikkings, waar moontlik.Ek verstaan die versoeking om te kul, al is.PHP maak dit so maklik nie, en so pret!
Hier is een manier waarop dit kan lyk, kan jy die res uit te vind:
A = new Group();
A.getSeason(Seasons.WINTER).addDay(Days.MONDAY);
A.getSeason(Seasons.SPRING).addDay(Days.TUESDAY).addDay(Days.THURSDAY);
A.getSeason(Seasons.SPRING).addDays(Days.MONDAY, Days.TUESDAY, ...);
schedule = new Schedule();
schedule.addWateringGroup( A );
Ek is nie 'n Java-programmeerder, maar om weg van Java en net te dink in terme wat meer taal agnostikus is - 'n skoner manier om dit te doen sou wees om óf konstantes of vervat tipes gebruik. Dit behoort te werk in enige langauge dat multi-dimensionele skikkings ondersteun.
As die gebruik van die naam van konstantes, waar, byvoorbeeld:
int A = 0;
int B = 1;
int C = 2;
int D = 3;
int Spring = 0;
int Summer = 1;
int Winter = 2;
int Fall = 3;
...
Toe die konstantes dien as meer leesbare verskeidenheid onderskrifte:
schedule[A][Winter]="M";
schedule[A][Spring]="tTS";
schedule[A][Summer]="Any";
schedule[A][Fall]="tTS";
schedule[B][Winter]="t";
Die gebruik van versyferde tipes:
enum groups
{
A = 0,
B = 1,
C = 2,
D = 3
}
enum seasons
{
Spring = 0,
Summer = 1,
Fall = 2,
Winter = 3
}
...
schedule[groups.A][seasons.Winter]="M";
schedule[groups.A][seasons.Spring]="tTS";
schedule[groups.A][seasons.Summer]="Any";
schedule[groups.A][seasons.Fall]="tTS";
schedule[groups.B][seasons.Winter]="t";
Ek is heeltemal teen 'n verlies aan te voer waarom sommige van julle dink dat gooi gobs van voorwerpe op die kode is die pad om te gaan. Byvoorbeeld, daar is presies vier seisoene, en hulle doen nie doen of winkel enigiets. Hoe werk dit alles te vereenvoudig om hulle oogmerke te maak? Vleuel is heeltemal reg dat hierdie waarskynlik moet wees konstantes (of miskien enums).
Wat Bruce nodig, by dit se hart, is bloot 'n lookup tafel. Hy het nie 'n hiërargie van voorwerpe en koppelvlakke nodig; Hy het 'n manier om te kyk 'n skedule gebaseer op 'n seisoen en 'n groep identifiseerder. Draai dinge in voorwerpe maak net sin as hulle verantwoordelikhede of staat. As hulle nie het nie, dan is hulle net identifiseerders, en die bou van 'n spesiale voorwerpe vir hulle maak net die kodebasis groter.
Jy kan te bou, bv, Group voorwerpe wat elk 'n stel van snare skedule (een vir elke seisoen), maar as al die Group voorwerp doen is voorsien lookup funksie, dan is jy weer uit te vind die lookup tafel in 'n baie minder intuïtief mode. As hy moet opkyk die groep, en dan lookup die skedule, alles wat hy het, is 'n twee-stap lookup tafel wat langer neem om kode, is meer geneig om te karretjie wees, en sal moeiliker om in stand te hou.
Ek is met diegene wat raai vat funksie in voorwerpe.
import java.util.Date;
import java.util.Map;
import java.util.Set;
public class Group {
private String groupName;
private Map<Season, Set<Day>> schedule;
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public Map<Season, Set<Day>> getSchedule() {
return schedule;
}
public void setSchedule(Map<Season, Set<Day>> schedule) {
this.schedule = schedule;
}
public String getScheduleFor(Date date) {
Season now = Season.getSeason(date);
Set<Day> days = schedule.get(now);
return Day.getDaysForDisplay(days);
}
}
EDIT: Moet ook jou datum bereik nie spring jaar in ag neem:
Ons seisoene lyk: Somer (5-1 tot 8-31) Lente (3-1 tot 4-30) Val (9-1 tot 10-31) Winter (1/11 tot 2-28)
Ek stem saam dat jy beslis hierdie logika moet sit agter die skoon koppelvlak van:
public String lookupDays(String group, String date);
maar miskien moet jy die data te hou in 'n eiendom lêer. Ek is nie teen hardcoding hierdie data in jou bronkodelêers maar, as jy al agtergekom, kan Java mooi langdradig wees wanneer dit kom by die sub-versamelings. Jou lêer mag lyk:
A.Summer = M
A.Spring = TTS
B.Summer = T
Gewoonlik Ek hou nie daarvan om statiese data soos hierdie na 'n eksterne lêer beweeg omdat dit die "afstand" tussen die data en die kode wat dit gebruik verhoog. Maar wanneer jy met geneste versamelings, veral kaarte, dinge kan kry real lelike, ware vinnig.
As jy nie hou van hierdie idee, miskien kan jy iets soos dit te doen:
public class WaterScheduler
{
private static final Map<String, String> GROUP2SEASON = new HashMap<String, String>();
static
{
addEntry("A", "Summer", "M");
addEntry("A", "Spring", "tTS");
addEntry("B", "Summer", "T");
}
private static void addEntry(String group, String season, String value)
{
GROUP2SEASON.put(group + "." + season, value);
}
}
Jy verloor 'n paar leesbaarheid maar ten minste die data is nader aan waar dit gaan om gebruik te word.
Maak die "datum" het 'n parameter wees? As jy net wys die huidige water skedule die WateringSchedule klas self kan uitvind watter dag dit is, en dus watter seisoen dit is. Dan het net 'n metode wat 'n kaart waar die sleutel is die groep brief terug. Iets soos:
public Map<String,List<String>> getGroupToScheduledDaysMap() {
// instantiate a date or whatever to decide what Map to return
}
Toe ek in die JSP bladsy
<c:forEach var="day" items="${scheduler.groupToScheduledDaysMap["A"]}">
${day}
</c:forEach>
As jy nodig het om die skedules te wys vir meer as een seisoen, jy moet 'n metode in die WateringSchedule klas wat 'n kaart waar Seisoene is die sleutels terug te hê, en dan Kaarte groupToScheduledDays is die waardes.
'n beter oplossing sou dalk wees om alles wat data in 'n databasis geplaas, in plaas van harde kodering dit in jou bronne of die gebruik van eiendomme lêers.
Die gebruik van 'n databasis sal baie makliker om in stand te hou, en daar is 'n verskeidenheid van gratis databasis enjins om uit te kies.
Twee van hierdie databasis enjins is heeltemal geïmplementeer in Java en kan in 'n aansoek ingesluit word net deur die insluiting van 'n pot lêer. Dit is 'n bietjie swaargewig, seker nie, maar dit is 'n baie meer skaalbare en makliker om te onderhou. Net omdat daar 20 rekords vandag beteken nie daar sal nie meer later wees as gevolg van die verandering van vereistes of funksie kruip.
As jy in 'n paar weke of maande, jy besluit wat jy wil byvoeg, sê, tyd van die dag nat beperkings, dit sal baie makliker wees om dit funksies by te voeg as jy reeds met behulp van 'n databasis. Selfs al is dit nooit gebeur, dan moet jy spandeer 'n paar uur om te leer hoe om 'n databasis te sluit in 'n aansoek.
Daar is geen mooi oplossing. Java net nie dinge soos hierdie goed te doen. Mike se oplossing is pretty much die manier om dit te doen as jy snare as die indekse (sleutels) wil. Nog 'n opsie as die hash-van-hashes opstel is te lelik is om die snare saam (skaamteloos gesteel Mike en verander) voeg:
Hashtable<String, String> schedule = new Hashtable<String, String>();
schedule.put("A-Winter", "M");
schedule.put("A-Spring", "tTS");
en dan lookup:
String val = schedule.get(group + "-" + season);
As jy ontevrede is met die algemene lelike is (en ek blameer jou nie), sit dit alles agter 'n metode oproep:
String whenCanIWater(String group, Date date) { /* ugliness here */ }
tl;dr
Met behulp van moderne Java taal funksies en klasse, definieer jou eie enums te verteenwoordig die seisoene en groepe.
Schedule.daysForGroupOnDate(
Group.D ,
LocalDate.now()
)
Die metode lewer'n Set van DayOfWeek enum voorwerpe (nie blote teks!), soos DayOfWeek.TUESDAY & DayOfWeek.THURSDAY.
Moderne Java
Is daar iemand wat kan dui op'n baie cool manier om dit te doen?
Ja.
Moderne Java het'n ingeboude-in klasse, versamelings, en enums om jou te help met hierdie probleem.
Die java.tyd raamwerk gebou in Java bied die Month enum en DayOfWeek enum.
Die EnumSet en EnumMap verskaf die implementering van Set en Map dit is geskik vir gebruik met enums vir'n vinnige uitvoering in baie min geheue.
Jy kan definieer jou eie enums te verteenwoordig jou seisoen en jou groepe (A, B, en so aan).Die enum fasiliteit in Java is baie meer nuttig en kragtig as gesien in ander tale.Indien nie vertroud is, sien die Oracle Handleiding.
Die eenvoudige sintaksis te definieer jou eie enums eintlik bied baie van die funksies wat nodig is om op te los hierdie Vraag, die uitskakeling van'n paar ingewikkelde kodering.Nuwe vasgekodeerde sintaksis vir stelle en kaarte in die versamelings fabriek metodes in Java 9 (JEP 269) maak die kode selfs makliker nou.
Hier is'n volledige werk app. Let op hoe min kode daar is vir algoritmes.Definieer jou eie persoonlike enums nie die meeste van die swaar-opheffing.
Een caveat met hierdie inligting kode:Dit neem niks verander in jou besigheid definisies, of ten minste as daar is'n verandering wat jy net omgee oor die huidige reëls, "jongste is die grootste".As jou reëls verander met verloop van tyd en wat jy nodig het om te verteenwoordig al die verlede, hede, en toekoms weergawes, ek sou die bou van'n baie verskillende artikels, waarskynlik met'n databasis op te slaan die reëls.Maar hierdie inligting hier los die Vraag gevra.
Season
Stel jou seisoen as'n enum Season.Elke seisoen voorwerp in besit is van'n List van Month enum voorwerpe wat definieer die lengte van daardie spesifieke seisoen.Die nuwe List.of sintaksis bygevoeg om te Java 9 definieer'n onveranderlike lys in'n vasgekodeerde sintaksis via statiese fabriek metodes.
package com.basilbourque.watering;
import java.time.LocalDate;
import java.time.Month;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
public enum Season
{
SPRING( List.of( Month.MARCH , Month.APRIL ) ),
SUMMER( List.of( Month.MAY , Month.JUNE, Month.JULY , Month.AUGUST ) ),
FALL( List.of( Month.SEPTEMBER , Month.OCTOBER ) ),
WINTER( List.of( Month.NOVEMBER , Month.DECEMBER , Month.JANUARY , Month.FEBRUARY ) );
private List< Month > months;
// Constructor
Season ( List < Month > monthsArg )
{
this.months = monthsArg;
}
public List < Month > getMonths ( )
{
return this.months;
}
// For any given month, determine the season.
static public Season ofLocalMonth ( Month monthArg )
{
Season s = null;
for ( Season season : EnumSet.allOf( Season.class ) )
{
if ( season.getMonths().contains( monthArg ) )
{
s = season;
break; // Bail out of this FOR loop.
}
}
return s;
}
// For any given date, determine the season.
static public Season ofLocalDate ( LocalDate localDateArg )
{
Month month = localDateArg.getMonth();
Season s = Season.ofLocalMonth( month );
return s;
}
// Run `main` for demo/testing.
public static void main ( String[] args )
{
// Dump all these enum objects to console.
for ( Season season : EnumSet.allOf( Season.class ) )
{
System.out.println( "Season: " + season.toString() + " = " + season.getMonths() );
}
}
}
Group
Verteenwoordig elke groepering van kliënte se grasperke/meter, (A, B, C, D, E) as'n enum naam Group.Elkeen van hierdie enum voorwerpe in besit is van'n Map, kartering van'n Season enum voorwerp na'n Set van DayOfWeek enum voorwerpe.Byvoorbeeld, Group.A in Season.SPRING laat die water oor twee dae, DayOfWeek.TUESDAY & DayOfWeek.THURSDAY.
package com.basilbourque.watering;
import java.time.DayOfWeek;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;
public enum Group
{
A(
Map.of(
Season.SPRING , EnumSet.of( DayOfWeek.TUESDAY , DayOfWeek.THURSDAY ) ,
Season.SUMMER , EnumSet.allOf( DayOfWeek.class ) ,
Season.FALL , EnumSet.of( DayOfWeek.TUESDAY , DayOfWeek.THURSDAY ) ,
Season.WINTER , EnumSet.of( DayOfWeek.TUESDAY )
)
),
B(
Map.of(
Season.SPRING , EnumSet.of( DayOfWeek.FRIDAY ) ,
Season.SUMMER , EnumSet.allOf( DayOfWeek.class ) ,
Season.FALL , EnumSet.of( DayOfWeek.TUESDAY , DayOfWeek.FRIDAY ) ,
Season.WINTER , EnumSet.of( DayOfWeek.FRIDAY )
)
),
C(
Map.of(
Season.SPRING , EnumSet.of( DayOfWeek.MONDAY ) ,
Season.SUMMER , EnumSet.allOf( DayOfWeek.class ) ,
Season.FALL , EnumSet.of( DayOfWeek.MONDAY , DayOfWeek.TUESDAY ) ,
Season.WINTER , EnumSet.of( DayOfWeek.MONDAY )
)
),
D(
Map.of(
Season.SPRING , EnumSet.of( DayOfWeek.WEDNESDAY , DayOfWeek.FRIDAY ) ,
Season.SUMMER , EnumSet.allOf( DayOfWeek.class ) ,
Season.FALL , EnumSet.of( DayOfWeek.FRIDAY ) ,
Season.WINTER , EnumSet.of( DayOfWeek.WEDNESDAY )
)
),
E(
Map.of(
Season.SPRING , EnumSet.of( DayOfWeek.TUESDAY ) ,
Season.SUMMER , EnumSet.allOf( DayOfWeek.class ) ,
Season.FALL , EnumSet.of( DayOfWeek.TUESDAY , DayOfWeek.WEDNESDAY ) ,
Season.WINTER , EnumSet.of( DayOfWeek.WEDNESDAY )
)
);
private Map < Season, Set < DayOfWeek > > map;
// Constructor
Group ( Map < Season, Set < DayOfWeek > > mapArg )
{
this.map = mapArg;
}
// Getter
private Map < Season, Set < DayOfWeek > > getMapOfSeasonToDaysOfWeek() {
return this.map ;
}
// Retrieve the DayOfWeek set for this particular Group.
public Set<DayOfWeek> daysForSeason (Season season ) {
Set<DayOfWeek> days = this.map.get( season ) ; // Retrieve the value (set of days) for this key (a season) for this particular grouping of lawns/yards.
return days;
}
// Run `main` for demo/testing.
public static void main ( String[] args )
{
// Dump all these enum objects to console.
for ( Group group : EnumSet.allOf( Group.class ) )
{
System.out.println( "Group: " + group.toString() + " = " + group.getMapOfSeasonToDaysOfWeek() );
}
}
}
Schedule
Trek dit alles saam in hierdie Schedule die klas.
Hierdie klas maak gebruik van die twee enums gedefinieer bo te kry nuttige werk gedoen.Die enigste metode geïmplementeer so ver vir jou vertel watter dae van die week toegelaat word om vir'n bepaalde groep op'n spesifieke datum.Die metode bepaal wat Season van toepassing is vir daardie datum.
Hardloop die main metode hier om te stort die inhoud van ons twee enums, en verslag oor die dae van die week toelaat vir water in elke groep vir'n spesifieke hard-gekodeerde datum.
package com.basilbourque.watering;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.IsoFields;
import java.util.EnumSet;
import java.util.Set;
public class Schedule
{
static private DateTimeFormatter isoWeekFormatter = DateTimeFormatter.ofPattern( "uuuu-'W'ww" ) ;
static public Set < DayOfWeek > daysForGroupOnDate ( Group group , LocalDate localDate )
{
Season season = Season.ofLocalDate( localDate );
Set < DayOfWeek > days = group.daysForSeason( season );
return days;
}
// Run `main` for demo/testing.
public static void main ( String[] args )
{
Season.main( null );
Group.main( null );
// Dump all these enum objects to console.
for ( Group group : EnumSet.allOf( Group.class ) )
{
LocalDate localDate = LocalDate.now( ZoneId.of( "Africa/Tunis" ) );
Set < DayOfWeek > days = Schedule.daysForGroupOnDate( group , localDate );
String week = localDate.format( Schedule.isoWeekFormatter ) ; // Standard ISO 8601 week, where week number one has the first Thursday of the calendar year, and week starts on Monday, so year is either 52 or 53 weeks long.
String message = "Group " + group + " – Watering days on " + localDate + " week # " + week + " is: " + days;
System.out.println( message );
}
}
}
Console
Toe hardloop Schedule.main, ons sien dit gestort word aan die konsole.
Seisoen:LENTE = [MAART, APRIL]
Seisoen:SOMER = [MEI, JUNIE, JULIE, AUGUSTUS]
Seisoen:VAL = [SEPTEMBER, OKTOBER]
Seisoen:WINTER = [NOVEMBER, DESEMBER, JANUARIE, FEBRUARIE]
Groep:A = {LENTE=[DINSDAG, DONDERDAG], VAL=[DINSDAG, DONDERDAG], DIE SOMER=[MAANDAG, DINSDAG, WOENSDAG, DONDERDAG, VRYDAG, SATERDAG, SONDAG], DIE WINTER=[DINSDAG]}
Groep:B = {LENTE=[VRYDAG], VAL=[DINSDAG, VRYDAG], DIE SOMER=[MAANDAG, DINSDAG, WOENSDAG, DONDERDAG, VRYDAG, SATERDAG, SONDAG], DIE WINTER=[VRYDAG]}
Groep:C = {LENTE=[MAANDAG], VAL=[MAANDAG, DINSDAG], DIE SOMER=[MAANDAG, DINSDAG, WOENSDAG, DONDERDAG, VRYDAG, SATERDAG, SONDAG], DIE WINTER=[MAANDAG]}
Groep:D = {LENTE=[WOENSDAG, VRYDAG], VAL=[VRYDAG], DIE SOMER=[MAANDAG, DINSDAG, WOENSDAG, DONDERDAG, VRYDAG, SATERDAG, SONDAG], DIE WINTER=[WOENSDAG]}
Groep:E = {LENTE=[DINSDAG], VAL=[DINSDAG, WOENSDAG], DIE SOMER=[MAANDAG, DINSDAG, WOENSDAG, DONDERDAG, VRYDAG, SATERDAG, SONDAG], DIE WINTER=[WOENSDAG]}
Groep A – Lekker dae op die 2018-01-30 week # 2018-W05 is:[DINSDAG]
Groep B – Lekker dae op die 2018-01-30 week # 2018-W05 is:[VRYDAG]
Groep C – Nat dae op 2018-01-30 week # 2018-W05 is:[MAANDAG]
Groep D – Lekker dae op die 2018-01-30 week # 2018-W05 is:[WOENSDAG]
Groep E – Lekker dae op die 2018-01-30 week # 2018-W05 is:[WOENSDAG]
ISO 8601 week
Jy mag dit nuttig vind om te leer oor die ISO 8601 standaard vir'n definisie van die week.Die standaard gee'n bepaalde betekenis aan die "week" en definieer'n tekstuele formaat vir die voorstelling van'n spesifieke week of'n spesifieke dag in die week.
Vir die werk met sulke weke binne Java, oorweeg die toevoeging van die ThreeTen-Ekstra biblioteek om jou projek om gebruik te maak van die YearWeek die klas.
LocalDate
Die LocalDate klas verteenwoordig'n datum-net waarde sonder tyd-van-dag en sonder tyd sone.
'n tyd sone is van kardinale belang in die bepaling van'n datum.Vir enige gegewe oomblik, die datum wissel oor die hele wêreld deur die gebied.Byvoorbeeld, 'n paar minute na middernag in Parys, Frankryk is'n nuwe dag, terwyl nog steeds "gister" in Montreal Québec.
Indien geen tyd sone is gespesifiseer, is die JVM implisiet toepassing sy huidige standaard tyd sone.Dat die standaard kan verander op enige oomblik, sodat jou resultate kan wissel.Beter om te gee jou die gewenste/verwagte tyd sone uitdruklik as'n argument.
Spesifiseer'n regte tyd zone naam in die formaat van die continent/region, soos America/Montreal, Africa/Casablanca, of Pacific/Auckland.Nooit gebruik van die 3-4 brief afkorting soos EST of IST as hulle is nie waar tyd sones, nie gestandaardiseerde, en selfs nie uniek(!).
ZoneId z = ZoneId.of( "America/Montreal" ) ;
LocalDate today = LocalDate.now( z ) ;
As jy wil om te gebruik die JVM se huidige standaard tyd sone, vra vir dit en slaag as'n argument.As weggelaat, die JVM se huidige standaard toegepas word implisiet.Beter om te wees eksplisiete.
ZoneId z = ZoneId.systemDefault() ; // Get JVM’s current default time zone.
Of spesifiseer'n datum.Jy kan stel die maand deur'n aantal, met gesonde verstand nommeringstelsel 1-12 vir januarie-desember.
LocalDate ld = LocalDate.of( 1986 , 2 , 23 ) ; // Years use sane direct numbering (1986 means year 1986). Months use sane numbering, 1-12 for January-December.
Of, beter, gebruik die Month enum voorwerpe pre-gedefinieerde, een vir elke maand van die jaar.Wenk:Die gebruik van hierdie Month voorwerpe in jou kodebasis eerder as'n blote heelgetal te maak om jou kode meer self-dokumentasie, verseker dat geldige waardes, en verskaf tipe-veiligheid.
LocalDate ld = LocalDate.of( 1986 , Month.FEBRUARY , 23 ) ;
Onveranderlike versamelings
Die lyste, stelle, en kaarte hierbo gesien moet ideaal wees onveranderlik versamelings, soos die verandering van die lidmaatskap van daardie versamelings is geneig om te wees confounding en verkeerd.
Die nuwe Java 9 sintaksis List.of en Map.of reeds belowe om te wees onveranderlik.Egter, in ons geval die Map moet verkieslik'n EnumMap vir doeltreffendheid van prestasie en geheue.Die huidige implementering van Map.of en Set.of blykbaar op te spoor nie die gebruik van enums as lede en outomaties optimaliseer met'n interne gebruik van EnumMap en EnumSet.Daar is'n OpenJDK kwessie oopgemaak sulke sake te oorweeg: oorweeg verbeterings aan EnumMap en EnumSet.
Een manier om te kry'n onveranderlike EnumSet en onveranderlike EnumMap is deur die Google Koejawel biblioteek:
Die resultate van elke gebruik van'n onderliggende EnumSet/EnumMap.Bedrywighede, soos get en put gooi'n uitsondering.So kry jy die enum-verwante optimalisaties saam met onveranderlikheid.
Hier is die Season en Group klasse hierbo gesien verander om te gebruik die Google Koejawel 23.6 biblioteek.
Season met onveranderlikheid
package com.basilbourque.watering;
import java.time.LocalDate;
import java.time.Month;
import java.util.EnumSet;
import java.util.List;
public enum Season
{
SPRING( List.of( Month.MARCH , Month.APRIL ) ), // `List.of` provides literals-style syntax, and returns an immutable `List`. New in Java 9.
SUMMER( List.of( Month.MAY , Month.JUNE, Month.JULY , Month.AUGUST ) ),
FALL( List.of( Month.SEPTEMBER , Month.OCTOBER ) ),
WINTER( List.of( Month.NOVEMBER , Month.DECEMBER , Month.JANUARY , Month.FEBRUARY ) );
private List< Month > months;
// Constructor
Season ( List < Month > monthsArg )
{
this.months = monthsArg;
}
public List < Month > getMonths ( )
{
return this.months;
}
// For any given month, determine the season.
static public Season ofLocalMonth ( Month monthArg )
{
Season s = null;
for ( Season season : EnumSet.allOf( Season.class ) )
{
if ( season.getMonths().contains( monthArg ) )
{
s = season;
break; // Bail out of this FOR loop.
}
}
return s;
}
// For any given date, determine the season.
static public Season ofLocalDate ( LocalDate localDateArg )
{
Month month = localDateArg.getMonth();
Season s = Season.ofLocalMonth( month );
return s;
}
// Run `main` for demo/testing.
public static void main ( String[] args )
{
// Dump all these enum objects to console.
for ( Season season : EnumSet.allOf( Season.class ) )
{
System.out.println( "Season: " + season.toString() + " = " + season.getMonths() );
}
}
}
Group met onveranderlikheid
package com.basilbourque.watering;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.time.DayOfWeek;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;
public enum Group
{
A(
Maps.immutableEnumMap(
Map.of( // `Map.of` provides literals-style syntax, and returns an immutable `Map`. New in Java 9.
Season.SPRING , Sets.immutableEnumSet( DayOfWeek.TUESDAY , DayOfWeek.THURSDAY ) ,
Season.SUMMER , Sets.immutableEnumSet( EnumSet.allOf( DayOfWeek.class ) ) ,
Season.FALL , Sets.immutableEnumSet( DayOfWeek.TUESDAY , DayOfWeek.THURSDAY ) ,
Season.WINTER , Sets.immutableEnumSet( DayOfWeek.TUESDAY )
)
)
),
B(
Maps.immutableEnumMap(
Map.of(
Season.SPRING , Sets.immutableEnumSet( DayOfWeek.FRIDAY ) ,
Season.SUMMER , Sets.immutableEnumSet( EnumSet.allOf( DayOfWeek.class ) ) ,
Season.FALL , Sets.immutableEnumSet( DayOfWeek.TUESDAY , DayOfWeek.FRIDAY ) ,
Season.WINTER , Sets.immutableEnumSet( DayOfWeek.FRIDAY )
)
)
),
C(
Maps.immutableEnumMap(
Map.of(
Season.SPRING , Sets.immutableEnumSet( DayOfWeek.MONDAY ) ,
Season.SUMMER , Sets.immutableEnumSet( EnumSet.allOf( DayOfWeek.class ) ) ,
Season.FALL , Sets.immutableEnumSet( DayOfWeek.MONDAY , DayOfWeek.TUESDAY ) ,
Season.WINTER , Sets.immutableEnumSet( DayOfWeek.MONDAY )
)
)
),
D(
Maps.immutableEnumMap(
Map.of(
Season.SPRING , Sets.immutableEnumSet( DayOfWeek.WEDNESDAY , DayOfWeek.FRIDAY ) ,
Season.SUMMER , Sets.immutableEnumSet( EnumSet.allOf( DayOfWeek.class ) ) ,
Season.FALL , Sets.immutableEnumSet( DayOfWeek.FRIDAY ) ,
Season.WINTER , Sets.immutableEnumSet( DayOfWeek.WEDNESDAY )
)
)
),
E(
Maps.immutableEnumMap(
Map.of(
Season.SPRING , Sets.immutableEnumSet( DayOfWeek.TUESDAY ) ,
Season.SUMMER , Sets.immutableEnumSet( EnumSet.allOf( DayOfWeek.class ) ) ,
Season.FALL , Sets.immutableEnumSet( EnumSet.of( DayOfWeek.TUESDAY , DayOfWeek.WEDNESDAY ) ) ,
Season.WINTER , Sets.immutableEnumSet( DayOfWeek.WEDNESDAY )
)
)
);
private Map < Season, Set < DayOfWeek > > map;
// Constructor
Group ( Map < Season, Set < DayOfWeek > > mapArg )
{
this.map = mapArg;
}
// Getter
private Map < Season, Set < DayOfWeek > > getMapOfSeasonToDaysOfWeek ( )
{
return this.map;
}
// Retrieve the DayOfWeek set for this particular Group.
public Set < DayOfWeek > daysForSeason ( Season season )
{
Set < DayOfWeek > days = this.map.get( season ); // Retrieve the value (set of days) for this key (a season) for this particular grouping of lawns/yards.
return days;
}
// Run `main` for demo/testing.
public static void main ( String[] args )
{
// Dump all these enum objects to console.
for ( Group group : EnumSet.allOf( Group.class ) )
{
System.out.println( "Group: " + group.toString() + " = " + group.getMapOfSeasonToDaysOfWeek() );
}
}
}
Oor java.tyd
Die java.tyd raamwerk is gebou in Java 8 en later.Hierdie klasse verdring die lastige ou nalatenskap datum-en tyd klasse soos java.util.Date, Calendar, & SimpleDateFormat.
Die Joda-Tyd die projek, nou in die onderhoud af, beveel migrasie na die java.tyd klasse.
Om meer te leer, sien die Oracle Handleiding.En soek Stapel Oorloop vir baie voorbeelde en verduidelikings.Spesifikasie is JSR 310.
Waar om te kry die java.tyd klasse?
- Java SE 8, Java SE 9, en later
- Gebou-in.
- Deel van die standaard-Java API met'n bundel implementering.
- Java 9 voeg'n paar klein funksies en fixes.
- Java SE 6 en Java SE 7
- Baie van die java.tyd funksionaliteit is terug-oorgedra na Java 6 & 7 in ThreeTen-Backport.
- Android
- Later weergawes van Android bundel implementering van die java.tyd klasse.
- Vir vroeër Android, die ThreeTenABP projek pas ThreeTen-Backport (hierbo genoem).Sien Hoe om te gebruik ThreeTenABP....
Die ThreeTen-Ekstra die projek strek java.tyd met addisionele klasse.Hierdie projek is'n bewys dat die grond vir moontlike toekomstige toevoegings tot java.tyd.Jy kan vind'n paar nuttige klasse hier soos Interval, YearWeek, YearQuarter, en meer.
