Arrays von Arrays in Java
https://stackoverflow.com/questions/12870
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Das ist für mich eine schlimme Sache...Ich bin ein PHP-Typ, der in Java an einem JSP-Projekt arbeitet.Ich weiß, wie ich das, was ich versuche, durch zu viel Code und einen völligen Mangel an Finesse erreichen kann.
Ich würde es lieber richtig machen.Hier ist die Situation:
Ich schreibe eine kleine Anzeige, um Kunden zu zeigen, an welchen Tagen sie ihren Rasen basierend auf ihrer Bewässerungsgruppe (ABCDE) bewässern können und welche Jahreszeit es ist.Unsere Jahreszeiten sehen so aus:Sommer (5-1 bis 8-31) Spring (3-1 bis 4-30) Herbst (9-1 bis 10-31) Winter (11-1 bis 2-28)
Ein Beispiel könnte sein:
Wenn ich in Gruppe A bin, wären hier meine erlaubten Zeiten:Winter:Montag nur Frühling:Dienstag, Donnerstag, Sa Summer:Jeder Tag fällt:Di, Do, Sa
Wenn ich dies in PHP schreiben würde, würde ich Arrays wie diese verwenden:
//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';
Ich KÖNNTE die Tages-Arrays erstellen (array("Dienstag", "Donnerstag", "Samstag")) usw., aber das ist für das, was ich wirklich erreichen möchte, nicht notwendig.
Ich muss auch Arrays einrichten, um zu bestimmen, in welcher Saison ich bin:
$seasons["Summer"]["start"]=0501;
$seasons["Summer"]["end"]=0801;
Kann jemand einen wirklich coolen Weg vorschlagen, dies zu tun?Ich werde den heutigen Termin und den Gruppenbrief haben.Ich muss meine Funktion einen Tag (M) oder eine Reihe von Tagen (tTS) (beliebig) verlassen.
Lösung
Sie könnten im Wesentlichen den gleichen Code mit Hashtables (oder einer anderen Map) erstellen:
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...
Nicht so elegant, aber andererseits ist Java keine dynamische Sprache und verfügt über keine Hashes auf Sprachebene.
Notiz:Möglicherweise können Sie eine bessere Lösung finden. Das kam mir gerade in den Sinn, als ich Ihre Frage las.
Andere Tipps
Versuchen Sie nicht, so dynamisch zu sein wie PHP.Du könntest es zuerst versuchen definieren was du brauchst.
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);
}
Und bitte lesen Sie die Dokumentation von Hash-tabelle bevor Sie es verwenden.Diese Klasse ist synchronisiert, was bedeutet, dass jeder Aufruf vor Multithreading geschützt ist, was den Zugriff wirklich verlangsamt, wenn Sie keinen zusätzlichen Schutz benötigen.Bitte verwenden Sie eines Karte Umsetzung statt wie HashMap oder TreeMap.
Es scheint, als würde jeder versuchen, die Java-Methode zu finden, um es so zu machen, wie man es in PHP macht, und nicht so, wie es in Java gemacht werden sollte.Betrachten Sie einfach jeden Teil Ihres Arrays als ein Objekt oder zumindest die erste Ebene des Arrays als ein Objekt und jede Unterebene als Variablen innerhalb des Objekts.Anschließend erstellen Sie eine Datenstruktur, die Sie mit den genannten Objekten füllen und über die angegebenen Zugriffsfunktionen der Datenstruktur auf die Objekte zugreifen.
Etwas wie:
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);
...
Natürlich ist das wahrscheinlich auch nicht richtig.Ich würde jede Jahreszeit zu einem Objekt machen und vielleicht auch jede Wochentagsliste zu einem Objekt.Auf jeden Fall lässt es sich leichter wiederverwenden, ist leichter zu verstehen und erweiterbar als eine zusammengewürfelte Hashtabelle, die versucht, Ihren PHP-Code zu imitieren.Natürlich verfügt PHP auch über Objekte, und Sie sollten diese, wo immer möglich, auf ähnliche Weise anstelle Ihrer Über-Arrays verwenden.Allerdings verstehe ich die Versuchung, zu schummeln.PHP macht es so einfach und macht so viel Spaß!
Hier ist eine Möglichkeit könnte aussehen, den Rest können Sie herausfinden:
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 );
Ich bin kein Java-Programmierer, aber wenn ich mich von Java verabschiede und einfach in sprachunabhängigeren Begriffen denke, könnte die Verwendung von Konstanten oder Aufzählungstypen eine sauberere Möglichkeit sein.Dies sollte in jeder Sprache funktionieren, die mehrdimensionale Arrays unterstützt.
Bei Verwendung benannter Konstanten, zum Beispiel:
int A = 0;
int B = 1;
int C = 2;
int D = 3;
int Spring = 0;
int Summer = 1;
int Winter = 2;
int Fall = 3;
...
Dann dienen die Konstanten als besser lesbare Array-Indizes:
schedule[A][Winter]="M";
schedule[A][Spring]="tTS";
schedule[A][Summer]="Any";
schedule[A][Fall]="tTS";
schedule[B][Winter]="t";
Verwendung von Aufzählungstypen:
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";
Ich verstehe überhaupt nicht, warum einige von Ihnen zu glauben scheinen, dass es der richtige Weg ist, große Mengen an Objekten auf den Code zu werfen.Es gibt zum Beispiel genau vier Jahreszeiten, und das gibt es nicht Tun oder speichern irgendetwas.Wie vereinfacht es etwas, sie zu Objekten zu machen?Wing hat völlig Recht, dass dies wahrscheinlich der Fall sein sollte Konstanten (oder vielleicht Aufzählungen).
Was Bruce im Grunde braucht, ist einfach eine Nachschlagetabelle.Er braucht keine Hierarchie von Objekten und Schnittstellen;Er braucht eine Möglichkeit, einen Zeitplan basierend auf einer Saison und einer Gruppenkennung nachzuschlagen.Dinge in Objekte umzuwandeln macht nur dann Sinn, wenn sie Verantwortlichkeiten oder einen Zustand haben.Wenn sie keines von beidem haben, handelt es sich einfach um Bezeichner, und wenn sie spezielle Objekte für sie erstellen, wird die Codebasis nur größer.
Du könnte bauen, z.B. Group Objekte, die jeweils eine Reihe von Zeitplanzeichenfolgen enthalten (eine für jede Saison), aber wenn alle Group Wenn ein Objekt Nachschlagefunktionen bereitstellt, haben Sie die Nachschlagetabelle auf eine viel weniger intuitive Art und Weise neu erfunden.Wenn er die Gruppe und dann den Zeitplan nachschlagen muss, hat er nur eine zweistufige Nachschlagetabelle, deren Codierung länger dauerte, die wahrscheinlicher fehlerhaft ist und schwieriger zu pflegen ist.
Ich gehöre zu denen, die vorschlagen, Funktionen in Objekten einzukapseln.
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);
}
}
BEARBEITEN:Außerdem berücksichtigen Ihre Datumsbereiche keine Schaltjahre:
Unsere Jahreszeiten sehen so aus:Sommer (5-1 bis 8-31) Spring (3-1 bis 4-30) Herbst (9-1 bis 10-31) Winter (11-1 bis 2-28)
Ich stimme zu, dass Sie diese Logik auf jeden Fall hinter die saubere Schnittstelle setzen sollten:
public String lookupDays(String group, String date);
aber vielleicht sollten Sie die Daten in einer Eigenschaftendatei speichern.Ich bin nicht dagegen, diese Daten in Ihren Quelldateien fest zu kodieren, aber wie Sie bemerkt haben, kann Java ziemlich wortreich sein, wenn es um verschachtelte Sammlungen geht.Ihre Datei könnte so aussehen:
A.Sommer=M
A.Spring=tTS
B.Sommer=T
Normalerweise verschiebe ich solche statischen Daten nicht gerne in eine externe Datei, da dadurch der „Abstand“ zwischen den Daten und dem Code, der sie verwendet, vergrößert wird.Wenn Sie es jedoch mit verschachtelten Sammlungen, insbesondere mit Karten, zu tun haben, können die Dinge sehr schnell sehr hässlich werden.
Wenn Ihnen diese Idee nicht gefällt, können Sie vielleicht so etwas tun:
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);
}
}
Sie verlieren etwas an Lesbarkeit, aber zumindest sind die Daten näher an dem Ort, an dem sie verwendet werden sollen.
Muss das „Datum“ ein Parameter sein?Wenn Sie nur den aktuellen Bewässerungsplan anzeigen, kann die WateringSchedule-Klasse selbst herausfinden, welcher Tag und damit welche Jahreszeit ist.Dann haben Sie einfach eine Methode, die eine Karte zurückgibt, bei der der Schlüssel der Gruppenbuchstabe ist.Etwas wie:
public Map<String,List<String>> getGroupToScheduledDaysMap() {
// instantiate a date or whatever to decide what Map to return
}
Dann auf der JSP-Seite
<c:forEach var="day" items="${scheduler.groupToScheduledDaysMap["A"]}">
${day}
</c:forEach>
Wenn Sie die Zeitpläne für mehr als eine Saison anzeigen müssen, sollten Sie über eine Methode in der WateringSchedule-Klasse verfügen, die eine Karte zurückgibt, bei der Jahreszeiten die Schlüssel und dann Karten von groupToScheduledDays die Werte sind.
Eine bessere Lösung wäre möglicherweise, alle diese Daten in einer Datenbank abzulegen, anstatt sie in Ihren Quellen fest zu codieren oder Eigenschaftendateien zu verwenden.
Die Verwendung einer Datenbank wird viel einfacher zu warten sein, und es gibt eine Vielfalt von frei Datenbank Motoren zur Auswahl.
Zwei dieser Datenbank-Engines sind vollständig in Java implementiert und können einfach durch Einbinden einer JAR-Datei in eine Anwendung eingebettet werden.Es ist zwar etwas schwergewichtig, aber viel skalierbarer und einfacher zu warten.Nur weil es heute 20 Datensätze gibt, heißt das nicht, dass es später aufgrund geänderter Anforderungen oder Funktionserweiterungen nicht mehr geben wird.
Wenn Sie in ein paar Wochen oder Monaten entscheiden, dass Sie beispielsweise tageszeitliche Bewässerungsbeschränkungen hinzufügen möchten, ist es viel einfacher, diese Funktionalität hinzuzufügen, wenn Sie bereits eine Datenbank verwenden.Auch wenn das nie passiert, haben Sie ein paar Stunden damit verbracht, zu lernen, wie man eine Datenbank in eine Anwendung einbettet.
Eine schöne Lösung gibt es nicht.Java macht solche Dinge einfach nicht gut.Mikes Lösung ist im Großen und Ganzen der richtige Weg, wenn Sie Zeichenfolgen als Indizes (Schlüssel) möchten.Eine andere Option, wenn das Hash-of-Hashes-Setup zu hässlich ist, besteht darin, die Zeichenfolgen aneinander anzuhängen (schamlos von Mike gestohlen und modifiziert):
Hashtable<String, String> schedule = new Hashtable<String, String>();
schedule.put("A-Winter", "M");
schedule.put("A-Spring", "tTS");
und dann nachschlagen:
String val = schedule.get(group + "-" + season);
Wenn Sie mit der allgemeinen Hässlichkeit unzufrieden sind (und das kann ich Ihnen nicht verübeln), stecken Sie alles hinter einen Methodenaufruf:
String whenCanIWater(String group, Date date) { /* ugliness here */ }
tl;dr
Definieren Sie mithilfe moderner Java-Sprachfunktionen und -Klassen Ihre eigenen Enumerationen zur Darstellung der Jahreszeiten und Gruppen.
Schedule.daysForGroupOnDate(
Group.D ,
LocalDate.now()
)
Diese Methode ergibt a Set von DayOfWeek Aufzählungsobjekte (kein bloßer Text!), wie z DayOfWeek.TUESDAY & DayOfWeek.THURSDAY.
Modernes Java
Kann jemand einen wirklich coolen Weg vorschlagen, dies zu tun?
Ja.
Modernes Java verfügt über integrierte Klassen, Sammlungen und Aufzählungen, die Ihnen bei diesem Problem helfen.
Der java.time Das in Java integrierte Framework bietet die Month Aufzählung und DayOfWeek Aufzählung.
Der EnumSet Und EnumMap Bereitstellung von Implementierungen von Set Und Map die für die Verwendung mit Enumerationen für eine schnelle Ausführung bei sehr wenig Speicher optimiert sind.
Sie können Ihre eigenen definieren Aufzählungen um Ihre Saison und Ihre Gruppen (A, B usw.) darzustellen.Die Enum-Funktion in Java ist weitaus nützlicher und leistungsfähiger als in anderen Sprachen.Wenn Sie nicht vertraut sind, sehen Sie sich die an Oracle-Tutorial.
Die einfache Syntax zum Definieren eigener Enumerationen bietet tatsächlich einen Großteil der zur Lösung dieser Frage erforderlichen Funktionalität und eliminiert komplizierte Codierung.Neu Literale Syntax für Sets und Karten im Collections-Factory-Methoden in Java 9 (JEP 269) macht den Code jetzt noch einfacher.
Hier ist eine vollständig funktionierende App. Beachten Sie, wie wenig Code Es gibt für Algorithmen.Die Definition Ihrer eigenen benutzerdefinierten Aufzählungen erledigt den größten Teil der Arbeit.
Eine Einschränkung bei diesem App-Code:Dabei wird davon ausgegangen, dass sich an Ihren Geschäftsdefinitionen nichts ändert, oder dass Sie sich bei einer Änderung zumindest nur um die aktuellen Regeln kümmern: „Das Neueste ist das Größte“.Wenn sich Ihre Regeln im Laufe der Zeit ändern und Sie alle vergangenen, aktuellen und zukünftigen Versionen darstellen müssen, würde ich eine ganz andere App erstellen, wahrscheinlich mit einer Datenbank zum Speichern der Regeln.Aber diese App hier löst die gestellte Frage.
Season
Stellen Sie Ihre Saison als Aufzählung dar Season.Jedes Saisonobjekt enthält eine List von Month Aufzählungsobjekte, die die Länge dieser bestimmten Saison definieren.Das neue List.of Die zu Java 9 hinzugefügte Syntax definiert eine unveränderliche Liste in einer Literalsyntax über statische Factory-Methoden.
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
Stellen Sie jede Gruppierung der Rasenflächen/Höfe der Kunden (A, B, C, D, E) als Enumeration mit Namen dar Group.Jedes dieser Enum-Objekte enthält ein Map, Zuordnung a Season Enum-Objekt zu a Set von DayOfWeek Aufzählungsobjekte.Zum Beispiel, Group.A In Season.SPRING ermöglicht die Bewässerung an zwei Tagen, 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
Bringen Sie hier alles zusammen Schedule Klasse.
Diese Klasse nutzt die beiden oben definierten Enumerationen, um nützliche Aufgaben zu erledigen.Die einzige bisher implementierte Methode sagt Ihnen, welche Wochentage für eine bestimmte Gruppe an einem bestimmten Datum zulässig sind.Die Methode bestimmt welche Season gilt für diesen Termin.
Führen Sie das aus main Methode hier, um den Inhalt unserer beiden Aufzählungen zu sichern und über die Wochentage zu berichten, die die Bewässerung in jeder Gruppe für ein bestimmtes fest codiertes Datum ermöglichen.
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 );
}
}
}
Konsole
Beim Laufen Schedule.main, wir sehen, dass dies auf die Konsole übertragen wird.
Jahreszeit:FRÜHLING = [MÄRZ, APRIL]
Jahreszeit:SOMMER = [MAI, JUNI, JULI, AUGUST]
Jahreszeit:HERBST = [SEPTEMBER, OKTOBER]
Jahreszeit:WINTER = [NOVEMBER, DEZEMBER, JANUAR, FEBRUAR]
Gruppe:A = {FRÜHLING=[DIENSTAG, DONNERSTAG], HERBST=[DIENSTAG, DONNERSTAG], SOMMER=[MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG], WINTER=[DIENSTAG]}
Gruppe:B = {SPRING=[FREITAG], FALL=[DIENSTAG, FREITAG], SOMMER=[MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG], WINTER=[FREITAG]}
Gruppe:C = {SPRING=[MONTAG], FALL=[MONTAG, DIENSTAG], SOMMER=[MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG], WINTER=[MONTAG]}
Gruppe:D = {FRÜHLING=[MITTWOCH, FREITAG], HERBST=[FREITAG], SOMMER=[MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG], WINTER=[MITTWOCH]}
Gruppe:E = {SPRING=[DIENSTAG], FALL=[DIENSTAG, MITTWOCH], SUMMER=[MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG], WINTER=[MITTWOCH]}
Gruppe A – Bewässerungstage am 30.01.2018, Woche Nr. 2018-W05 ist:[DIENSTAG]
Gruppe B – Bewässerungstage am 30.01.2018, Woche Nr. 2018-W05 ist:[FREITAG]
Gruppe C – Bewässerungstage am 30.01.2018, Woche Nr. 2018-W05 ist:[MONTAG]
Gruppe D – Bewässerungstage am 30.01.2018, Woche Nr. 2018-W05 ist:[MITTWOCH]
Gruppe E – Bewässerungstage am 30.01.2018, Woche Nr. 2018-W05 ist:[MITTWOCH]
ISO 8601 Woche
Es kann hilfreich sein, mehr darüber zu erfahren ISO 8601 Standard für a Definition von Woche.Der Standard gibt „Woche“ eine bestimmte Bedeutung und definiert ein Textformat zur Darstellung einer bestimmten Woche oder eines bestimmten Tages innerhalb dieser Woche.
Wenn Sie mit solchen Wochen in Java arbeiten möchten, sollten Sie das hinzufügen ThreeTen-Extra Fügen Sie Ihrem Projekt eine Bibliothek hinzu, um sie zu nutzen YearWeek Klasse.
LocalDate
Der LocalDate Die Klasse stellt einen reinen Datumswert ohne Tageszeit und ohne Zeitzone dar.
Eine Zeitzone ist entscheidend für die Bestimmung eines Datums.Für jeden Zeitpunkt variiert das Datum rund um den Globus je nach Zone.Zum Beispiel ein paar Minuten nach Mitternacht Paris, Frankreich ist ein neuer Tag, obwohl er noch „gestern“ ist Montreal, Quebec.
Wenn keine Zeitzone angegeben ist, wendet die JVM implizit ihre aktuelle Standardzeitzone an.Diese Standardeinstellung kann sich jederzeit ändern, sodass Ihre Ergebnisse variieren können.Geben Sie Ihre gewünschte/erwartete Zeitzone besser explizit als Argument an.
Geben Sie a an Richtiger Zeitzonenname im Format von continent/region, wie zum Beispiel America/Montreal, Africa/Casablanca, oder Pacific/Auckland.Verwenden Sie niemals die 3-4-Buchstaben-Abkürzung wie z EST oder IST so wie sie sind nicht echte Zeitzonen, nicht standardisiert und nicht einmal eindeutig (!).
ZoneId z = ZoneId.of( "America/Montreal" ) ;
LocalDate today = LocalDate.now( z ) ;
Wenn Sie die aktuelle Standardzeitzone der JVM verwenden möchten, fragen Sie danach und übergeben Sie sie als Argument.Wenn es weggelassen wird, wird implizit der aktuelle Standard der JVM angewendet.Besser explizit sein.
ZoneId z = ZoneId.systemDefault() ; // Get JVM’s current default time zone.
Oder geben Sie ein Datum an.Sie können den Monat durch eine Zahl festlegen, wobei die Nummerierung 1-12 für Januar-Dezember sinnvoll ist.
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.
Oder, besser, verwenden Sie die Month Aufzählungsobjekte vordefiniert, eines für jeden Monat des Jahres.Tipp:Benutze diese Month Objekte in Ihrer gesamten Codebasis anstelle einer bloßen Ganzzahl, um Ihren Code selbstdokumentierender zu machen, gültige Werte sicherzustellen und bereitzustellen Typensicherheit.
LocalDate ld = LocalDate.of( 1986 , Month.FEBRUARY , 23 ) ;
Unveränderliche Sammlungen
Die oben gezeigten Listen, Mengen und Karten sollten idealerweise unveränderliche Sammlungen sein, da eine Änderung der Mitgliedschaft dieser Sammlungen wahrscheinlich verwirrend und fehlerhaft ist.
Die neue Java 9-Syntax List.of Und Map.of Es wird bereits versprochen, unveränderlich zu sein.In unserem Fall jedoch Map sollte idealerweise ein sein EnumMap für Effizienz von Leistung und Speicher.Die aktuelle Implementierung von Map.of Und Set.of Erkennen Sie offenbar nicht die Verwendung von Enumerationen als Mitglieder und optimieren Sie sie automatisch bei einer internen Verwendung von EnumMap Und EnumSet.Es wurde ein OpenJDK-Problem eröffnet, um solche Probleme zu berücksichtigen: Erwägen Sie Verbesserungen an EnumMap und EnumSet.
Eine Möglichkeit, ein unveränderliches EnumSet und eine unveränderliche EnumMap zu erhalten, ist die Google Guave Bibliothek:
Für die Ergebnisse wird jeweils ein Basiswert verwendet EnumSet/EnumMap.Operationen wie z get Und put eine Ausnahme auslösen.Sie erhalten also die enumbezogenen Optimierungen zusammen mit der Unveränderlichkeit.
Hier sind die Season Und Group Die oben gezeigten Klassen wurden geändert, um die Google Guava 23.6-Bibliothek zu verwenden.
Season mit Unveränderlichkeit
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 mit Unveränderlichkeit
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() );
}
}
}
Über java.time
Der java.time Das Framework ist in Java 8 und höher integriert.Diese Kurse ersetzen die lästigen alten Vermächtnis Datum-Uhrzeit-Klassen wie java.util.Date, Calendar, & SimpleDateFormat.
Der Joda-Zeit Projekt, jetzt in Wartungsmodus, rät zur Migration in die java.time Klassen.
Weitere Informationen finden Sie unter Oracle-Tutorial.Und durchsuchen Sie Stack Overflow nach vielen Beispielen und Erklärungen.Spezifikation ist JSR 310.
Wo erhält man die java.time-Klassen?
- Java SE 8, Java SE 9, und später
- Eingebaut.
- Teil der Standard-Java-API mit einer gebündelten Implementierung.
- Java 9 fügt einige kleinere Funktionen und Korrekturen hinzu.
- Java SE 6 Und Java SE 7
- Ein Großteil der java.time-Funktionalität wurde auf Java 6 und 7 zurückportiert ThreeTen-Backport.
- Android
- Spätere Versionen von Android-Bundle-Implementierungen der java.time-Klassen.
- Für frühere Android-Versionen ist die ThreeTenABP Projekt passt sich an ThreeTen-Backport (oben erwähnt).Sehen So verwenden Sie ThreeTenABP….
Der ThreeTen-Extra Das Projekt erweitert java.time um zusätzliche Klassen.Dieses Projekt ist ein Testgelände für mögliche zukünftige Ergänzungen zu java.time.Möglicherweise finden Sie hier einige nützliche Klassen, z Interval, YearWeek, YearQuarter, Und mehr.
