Java中的数组数组

时间:2008-08-15 23:07:03

标签: java php jsp tomcat

对我来说这是一个令人讨厌的问题...我是一个在Java项目中使用Java工作的PHP人员。我知道如何做我正在尝试通过太多的代码和完全缺乏技巧。

我宁愿做得对。情况如下:

我正在写一个小型展示,向客户展示他们根据浇水组(ABCDE)和一年中的什么时间浇灌草坪的日子。我们的季节看起来像这样: 夏天(5-1到8-31) 春天(3-1到4-30) 秋季(9-1至10-31) 冬季(11-1至2-28)

一个例子可能是:

如果我在A组,这将是我允许的时间: 冬季:仅限周一 春天:星期二,星期四,星期六 夏天:任何一天 秋季:周二,周四,周六

如果我用PHP编写这个,我会使用这样的数组:

//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';

我可以制作天数组(数组(“星期二”,“星期四”,“星期六”))等,但这并不是我真正想要完成的事情。

我还需要设置数组以确定我在哪个季节:

$seasons["Summer"]["start"]=0501;
$seasons["Summer"]["end"]=0801;

有人能提出一个非常酷的方法吗?我将有今天的日期和团体信。我需要在一天(M)或一系列日子(tTS),(任何)退出我的职能。

12 个答案:

答案 0 :(得分:9)

你可以用Hashtables(或其他一些Map)完成相同的代码:

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...

不那么优雅,但是再一次,Java不是一种动态语言,它在语言层面上没有哈希。

注意:你可以做一个更好的解决方案,这只是在我阅读你的问题时突然出现。

答案 1 :(得分:9)

不要试图像PHP一样动态。您可以尝试首先定义您需要的内容。

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);
}

请在使用之前阅读Hashtable的文档。这个类是同步的,这意味着每个调用都受到多线程保护,当你不需要额外的保护时,它会真正减慢访问速度。请使用任何Map实施,例如HashMapTreeMap

答案 2 :(得分:6)

似乎每个人都试图找到Java的方式,就像你在PHP中一样,而不是像在Java中那样。只需将数组的每个部分视为一个对象,或者至少将数组的第一级作为对象,每个子级作为对象内的变量。构建一个用所述对象填充的数据结构,并通过数据结构的给定访问器访问对象。

类似的东西:

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);
...

当然,这可能也不对。我会把每个季节都作为一个对象,也许每个工作日列表都是一个对象。无论如何,它比试图模仿PHP代码的混乱Hashtable更容易重用,理解和扩展。当然,PHP也有对象,你应该尽可能以类似的方式使用它们而不是uber-arrays。不过,我确实理解作弊的诱惑。 PHP让它变得如此简单,如此有趣!

答案 3 :(得分:4)

这是可以看起来的一种方式,你可以想出其余部分:

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 );

答案 4 :(得分:3)

我不是Java程序员,但是远离Java并且只是用更加语言无关的术语来思考 - 更简洁的方法可能是使用常量或枚举类型。这应该适用于任何支持多维数组的语言。

如果使用命名常量,例如:

int A = 0;
int B = 1;
int C = 2;
int D = 3;

int Spring = 0; 
int Summer = 1;
int Winter = 2; 
int Fall = 3;
...

然后常量用作更可读的数组下标:

schedule[A][Winter]="M";
schedule[A][Spring]="tTS";
schedule[A][Summer]="Any";
schedule[A][Fall]="tTS";
schedule[B][Winter]="t";

使用枚举类型:

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";

答案 5 :(得分:2)

我和那些建议在对象中封装函数的人。

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);
    }

}

编辑:此外,您的日期范围不会考虑闰年:

  

我们的季节看起来像这样:夏天   (5-1至8-31)春季(3-1至4-30)   秋季(9-1至10-31)冬季(11-1至10)   2-28)

答案 6 :(得分:2)

我完全不知道为什么你们中的一些人似乎认为在代码中投掷大量物体是可行的方法。例如,恰好有四个季节,他们不会存储任何事情。它如何简化任何使它们成为对象的东西? Wing非常正确,这些应该是 常量 (或者可能是enums)。

布鲁斯需要的是它的核心,它只是一个查找表。他不需要对象和接口的层次结构;他需要一种基于季节和组标识符来查找计划的方法。将事物变成对象只有在他们有责任或陈述时才有意义。如果它们都没有,那么它们只是标识符,为它们构建特殊对象只会使代码库更大。

可以构建,例如Group个对象,每个对象包含一组计划字符串(每个季节一个),但是如果所有Group对象都提供了查找功能,然后您以更不直观的方式重新创建查找表。如果他必须查找该组,然后查找该时间表,他所拥有的只是一个两步查找表,需要更长的代码,更有可能是错误的,并且将更难维护。

答案 7 :(得分:1)

我同意你绝对应该把这个逻辑放在干净的界面:

public String lookupDays(String group, String date);

但也许您应该将数据粘贴在属性文件中。我并不反对在源文件中对这些数据进行硬编码,但正如您所注意到的,当涉及嵌套集合时,Java可能非常冗长。您的文件可能如下所示:

  

A.Summer = M
  A.Spring = TTS
  B.Summer = T

通常我不喜欢将这样的静态数据移动到外部文件,因为它增加了数据与使用它的代码之间的“距离”。但是,无论何时处理嵌套集合,特别是地图,事情都会变得非常丑陋,真正快速。

如果你不喜欢这个想法,也许你可以这样做:

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);
  }

}

你失去了一些可读性,但至少数据更接近于它将被使用的地方。

答案 8 :(得分:1)

更好的解决方案可能是将所有数据放入数据库,而不是在源代码中使用硬编码或使用属性文件。

使用数据库将更容易维护,并且有variety of free database个引擎可供选择。

其中两个数据库引擎完全用Java实现,只需包含一个jar文件就可以嵌入到应用程序中。它确实有点重量级,但它更具可扩展性,更易于维护。仅仅因为今天有20条记录并不意味着由于需求或功能不断变化而不会有更多记录。

如果您在几周或几个月内决定要添加时间浇水限制,那么如果您已经在使用数据库,则添加该功能会更容易。即使这种情况从未发生过,但您花了几个小时学习如何在应用程序中嵌入数据库。

答案 9 :(得分:1)

“日期”必须是参数吗?如果您只是显示当前的浇水时间表,WateringSchedule类本身可以确定它是什么日子,因此它是什么季节。然后只需要一个返回地图的方法,其中Key是组字母。类似的东西:

public Map<String,List<String>> getGroupToScheduledDaysMap() {
  // instantiate a date or whatever to decide what Map to return
}

然后在JSP页面中

<c:forEach var="day" items="${scheduler.groupToScheduledDaysMap["A"]}">
   ${day}
</c:forEach>

如果您需要显示多个季节的时间表,您应该在WateringSchedule类中有一个方法,该方法返回一个以Seasons为键的地图,然后groupToScheduledDays的地图就是值。

答案 10 :(得分:0)

没有漂亮的解决方案。 Java只是不做这样的事情。如果你想要字符串作为索引(键),迈克的解决方案几乎就是这样做的。如果hash-of-hashes设置太难看,另一个选择是将字符串附加在一起(从Mike无耻地窃取并修改):

Hashtable<String, String> schedule = new Hashtable<String, String>();
schedule.put("A-Winter", "M");
schedule.put("A-Spring", "tTS");

然后查找:

String val = schedule.get(group + "-" + season);

如果你对一般的丑陋感到不满意(我不怪你),请把它全部放在方法调用之后:

String whenCanIWater(String group, Date date) { /* ugliness here */ }

答案 11 :(得分:0)

TL;博士

使用现代Java语言特性和类,定义自己的枚举来表示季节和组。

Schedule.daysForGroupOnDate( 
    Group.D , 
    LocalDate.now()
)  

该方法会生成SetDayOfWeek枚举对象(不仅仅是文字!),例如DayOfWeek.TUESDAY&amp; DayOfWeek.THURSDAY

Modern Java

  

有人能提出一个非常酷的方法吗?

Modern Java具有内置的类,集合和枚举,可以帮助您解决此问题。

Java内置的 java.time 框架提供了Month枚举和DayOfWeek枚举。

EnumSetEnumMap提供SetMap的实现,这些实现经过优化,可与枚举一起使用,以便在极少的内存中快速执行。

您可以定义自己的enums来代表您的赛季和您的小组(A,B等)。 Java中的枚举工具比其他语言更有用,更强大。如果不熟悉,请参阅Oracle Tutorial

定义自己的枚举的简单语法实际上提供了解决此问题所需的大部分功能,从而消除了一些复杂的编码。 Java 9中literals syntax中的集合和映射的新collections factory methodsJEP 269)使代码现在变得更加简单。

这是一个完整的应用程序。 请注意算法的代码有多少。定义自己的自定义枚举可以解决大部分繁重问题。

使用此应用程序代码的一个警告:它假设您的业务定义没有任何变化,或者至少如果有变化您只关心当前规则,“最新是最好的”。如果您的规则随着时间的推移而变化,并且您需要表示所有过去,现在和将来的版本,我将构建一个非常不同的应用程序,可能还有一个用于存储规则的数据库。但这个应用程序在这里解决问题。

Season

将您的季节表示为枚举Season。每个季节对象都包含ListMonth枚举对象,用于定义特定季节的长度。添加到Java 9的新List.of语法通过静态工厂方法在文字语法中定义了不可变列表。

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

将每组客户的草坪/码(A,B,C,D,E)表示为名为Group的枚举。这些枚举对象中的每一个都包含Map,将Season枚举对象映射到Set枚举对象的DayOfWeek。例如,Group.A中的Season.SPRING允许在两天内进行浇水,DayOfWeek.TUESDAY&amp; 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

在这个Schedule课程中全部拉出来。

本课程使用上面定义的两个枚举来完成有用的工作。到目前为止,唯一实现的方法是告诉您特定日期的特定组允许一周中的哪几天。该方法确定哪个Season适用于该日期。

在此处运行main方法以转储我们两个枚举的内容,并报告一周中的日期,以便在每个组中为特定的硬编码日期浇水。

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 );
        }
    }
}

控制台

运行Schedule.main时,我们会看到这个转储到控制台。

  

季节:春天= [3月4日]

     

季节:夏天= [5月,6月,7月,8月]

     

季节:FALL = [9月,10月]

     

季节:冬季= [1月,12月,1月2日]

     

组:A = {SPRING = [星期二,星期四],FALL = [星期二,星期四],夏天= [星期一,星期二,星期三,星期四,星期五,星期六,星期日],冬天= [星期二]}

     

组:B = {SPRING = [星期五],FALL = [星期二,星期五],夏天= [星期一,星期二,星期三,星期四,星期五,星期六,星期日],冬天= [星期五]}

     

组:C = {SPRING = [星期一],FALL = [星期一,星期二],夏天= [星期一,星期二,星期三,星期四,星期五,星期六,星期日],冬天= [星期一]}

     

组:D = {SPRING = [WEDNESDAY,星期五],FALL = [星期五],夏天= [星期一,星期二,星期三,星期四,星期五,星期六,星期日],冬天= [星期三]}

     

组:E = {春天= [星期二],秋天= [星期二,星期三],夏天= [星期一,星期二,星期三,星期四,星期五,星期六,星期日],冬天= [星期三]}

     

A组 - 2018-01-30周的浇水日#2018-W05是:[星期二]

     

B组 - 2018-01-30周的浇水日#2018-W05是:[星期五]

     

C组 - 2018-01-30周的浇水日#2018-W05为:[星期一]

     

D组 - 2018-01-30周的浇水日#2018-W05是:[WEDNESDAY]

      E组 - 2018-01-30周的浇水日#2018-W05为:[WEDNESDAY]

ISO 8601周

您可能会发现了解ISO 8601definition of week标准会很有帮助。该标准给出了“周”的特定含义,并定义了用于表示该周内特定周或特定日的文本格式。

要在Java中使用这些周,请考虑将ThreeTen-Extra库添加到项目中以使用YearWeek类。

LocalDate

LocalDate类表示没有时间且没有时区的仅限日期的值。

时区对于确定日期至关重要。对于任何给定的时刻,日期在全球范围内因地区而异。例如,在Paris France午夜后的几分钟是新的一天,而Montréal Québec中仍然是“昨天”。

如果未指定时区,则JVM会隐式应用其当前的默认时区。该默认值可能随时更改,因此您的结果可能会有所不同。最好明确指定您期望/预期的时区作为参数。

continent/region的格式指定proper time zone name,例如America/MontrealAfrica/CasablancaPacific/Auckland。切勿使用诸如ESTIST之类的3-4字母缩写,因为它们不是真正的时区,不是标准化的,甚至不是唯一的(!)。

ZoneId z = ZoneId.of( "America/Montreal" ) ;  
LocalDate today = LocalDate.now( z ) ;

如果要使用JVM的当前默认时区,请求它并作为参数传递。如果省略,则隐式应用JVM的当前默认值。最好是明确的。

ZoneId z = ZoneId.systemDefault() ;  // Get JVM’s current default time zone.

或指定日期。您可以将月份设置为一个数字,1月至12月的数字为1-12。

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.

或者,更好的是,使用预定义的Month枚举对象,一年中的每个月一个。提示:在整个代码库中使用这些Month对象,而不仅仅是整数,以使代码更具自我记录功能,确保有效值,并提供type-safety

LocalDate ld = LocalDate.of( 1986 , Month.FEBRUARY , 23 ) ;

不可变的集合

上面看到的列表,集合和地图理想情况下应该是不可变的集合,因为更改这些集合的成员资格可能会造成混淆和错误。

新的Java 9语法List.ofMap.of已经被承诺是不可变的。但是,在我们的情况下,Map理想情况下应该是EnumMap,以提高性能和内存的效率。 Map.ofSet.of的当前实施显然未检测到枚举作为成员的使用,并通过内部使用EnumMapEnumSet自动优化。打开了一个OpenJDK问题来考虑此类问题:consider enhancements to EnumMap and EnumSet

获取不可变EnumSet和不可变EnumMap的一种方法是通过Google Guava库:

每项结果使用基础EnumSet / EnumMapgetput等操作会引发异常。因此,您可以获得与枚举相关的优化以及不变性。

以上是SeasonGroup类,经过修改后可以使用Google Guava 23.6库。

具有不变性的

Season

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

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() );
        }
    }

}

关于java.time

java.time框架内置于Java 8及更高版本中。这些类取代了麻烦的旧legacy日期时间类,例如java.util.DateCalendar和&amp; SimpleDateFormat

现在位于Joda-Timemaintenance mode项目建议迁移到java.time类。

要了解详情,请参阅Oracle Tutorial。并搜索Stack Overflow以获取许多示例和解释。规范是JSR 310

从哪里获取java.time类?

ThreeTen-Extra项目使用其他类扩展java.time。该项目是未来可能添加到java.time的试验场。您可以在此处找到一些有用的课程,例如IntervalYearWeekYearQuartermore