阵阵列在Java

Question

这是一个讨厌我的唯一...我PHP的家伙工作Java在JSP项目。我知道如何做什么，我尝试过太多的代码和一个完全缺乏技巧。

我更愿意这样做的权利。这里是这种情况：

我正在写一个小小的显示客户什么样的天，他们可以水上他们的草坪的基础上他们的灌溉集团(ABCDE)和什么时候的一年。我们的赛季是这样的：夏季(5-1至为8-31) 弹簧(3-1至4至30) 秋天(9-1至10-31) 冬季(11-1到2至28)

一个例子可能是：

如果我是在一个组，在这里就是我的允许的时间：冬天：星期一只 春天：星期二,星期四，星期六 夏天：任何一天 秋天：星期二,星期四，星期六

如果我写这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';

我可以让日子阵列(array("周二","星期四","六"))等，但这是没有必要为什么我真的想要完成的任务。

我还需要安装阵列，以确定是什么季节，我在：

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

任何人都可以建议一个很酷的方式做到这一点？我会有今天的日期和组字母。我需要滚出我的功能一天(M)或一系列的天(合成),(任何).

Answer 1

你可以做到基本上相同的代码与Hashtables(或其他一些地图):

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不是一个动态的语言，它没有哈希上的语言水平。

注：你可以做一个更好的解决方案，这只是突然出现在我的头上为我读了你的问题。

Answer 2

尽量不要动态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 前使用它。此类是同步，这意味着每个呼吁受到保护，不多，真正减缓访问的时候你不需要额外的保护。请使用任何 地图 执行，而不是喜欢 哈希 或 树形图.

Answer 3

好像每个人都试图找到Java的方式做到这一点像你这样做是在PHP，而不是它应该完成。只是考虑每一块你的阵列的对象，或者，至少第一级的阵作为一个目和每个次级变量内部的对象。该建立一个数据结构填充与上述目的和访问的目的是通过数据结构的给予访问器。

是这样的：

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

当然，这可能不是正确的。我会让每个赛季的对象，也许每个工作日，清单作为对象。无论如何，它更容易地重新使用,理解，并可扩展比一步履蹒跚-一起Hashtable，试图模仿你PHP code.当然，PHP有对象了，你应该使用他们在一个类似的方式而不是你的超级阵列，在可能的情况。我理解的诱惑欺骗，虽然。PHP使得它很容易和很有趣！

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

Answer 5

我不是一个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";

Answer 6

我完全处于亏损状态，因为为为什么有些人似乎认为，投掷大量的目的代码的路要走。例如，有四季，他们不 做 或 商店 任何东西。它是如何简化任何使他们的对象？翼是完全正确的，这些也许应该 常量 (或者，也许枚举).

什么布鲁斯的需要，在它的心脏，是只是一个查找表。他不需要一个层次的对象和接口；他需要一种方法来查找一个时间表的基础上一个季节和一组标识符。把东西放到的对象才有意义，如果他们有责任或国家。如果他们既没有，那么他们只是标识符，并建立特殊目的他们只是让的代码的更大。

你的 可能 建立，例如， Group 对象，每个都包含一定的时间表串(每个季节)，但如果所有的 Group 目的不是提供查询功能，那么你已经彻底改造查询表在一个更直观的方式。如果他看起来最多的群组，然后查找的时间表，他所是一个分两步的查询表，花较长的时间代码，是更有可能越野车，并将难以维持。

Answer 7

我与那些建议包封功能物体。

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 2至28)

Answer 8

我同意，你绝对应该把这种逻辑背后的干净的界面：

public String lookupDays(String group, String date);

但也许你应该坚持的数据属性文件。我不反对硬编码这个数据源文件，但是，正如你所注意到的、Java可能很冗长，当它涉及到嵌套的集合。你的文件中可能看起来像:

A.夏季=M
A.弹=合成
B.夏季=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);
  }

}

你会失去一些可读性，但在少数据更接近它就会被使用。

Answer 9

没有"日期"必须是一个参数？如果你只是表示当前的灌溉计划的WateringSchedule类本身可以找出今天是什么日子，因此是什么季节。然后只有一种方法，该方法返回的地图在哪里关键的是组字母。是这样的：

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类将返回的地图在哪里季的关键是，和随后的地图groupToScheduledDays是值。

Answer 10

一个更好的解决办法或许是把所有这些数据纳入一个数据库，而不是硬编码的，它在你的来源或使用属性文件。

使用一个数据库将更容易维持，并有一个 多种 的 免费的 数据库 发动机的选择。

这两个数据库引擎是实现完全在爪哇和可嵌入一个应用程序，只是通过包括一个罐子的文件。这是一点点重量级的，肯定的，但这是一个很大的多个可扩展和更易于维护。只是因为有20个记录今天并不意味着将不会有更多后来由于不断变化的要求或功能蔓延。

如果在几个星期或几个月，你决定要添加的，比如说，一天时间浇水的限制，它将更容易增加，功能如果你已经在使用一个数据库。即使这从未发生过,然后你已经花了几个小时学习如何嵌入一个数据库应用程序。

Answer 11

没有漂亮的解决方案。Java只是不做这样的事情。麦克的方案是很多的方式做到这一点，如果你想要串的指数(键)。另一种选择，如果将散列的散列安装的是太丑陋的是追加的串在一起(无耻地窃迈克和修改):

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 */ }

Answer 12

tl博士

使用现代Java语言特征和类、定义自己的枚举，以表示季节和团体。

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

这种方法会产生一个 Set 的 DayOfWeek 枚举的对象(不仅仅是文字!), 如 DayOfWeek.TUESDAY & DayOfWeek.THURSDAY.

现代Java

任何人都可以建议一个很酷的方式做到这一点？

是的。

现代Java已经建立类、集合和枚举，以帮助你解决这个问题。

的 java。时间 框架建成Java提供的 Month 枚举， DayOfWeek 枚举。

的 EnumSet 和 EnumMap 提供实现的 Set 和 Map 是的优化用于与枚举的快速执行在非常小的记忆。

你可以定义自己的 枚举 以表示你和你的团(A，B，等等)。Enum设施是远远更有用、更强大比在其他语言。如果不熟悉，看到 Oracle教程.

简单的语法中的定义自己的枚举的实际提供的许多功能需要解决这个问题，消除了一些复杂的编码。新的 文字的语法 对于集和地图的 集工厂的方法 在Java9(JEP269)使代码甚至更简单。

这里是一个完整的工作程序。 注意到多少代码 有算法。定义自己的定义枚举的最大的重型起吊。

一个警告与这个程序的代码:它假定没有什么变化，在你的业务定义，或者至少是如果有变化，你只关心目前的规则，"新的是最大的".如果你的规则随时间改变你需要代表所有的过去、现在和未来的版本中，我将建立一个非常不同的应用程序，可能与一个数据库，用以储存的规则。但是，这个程序在这里解决了这个问题作为要求。

Season

代表你的赛季为一个枚举 Season.每个赛季的对象保留一个 List 的 Month 枚举对象，定义的长度，特别是季节。新的 List.of 语法加入Java9定义不可改变的清单在文字的语法通过静态工厂的方法。

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 & 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, 我们看到这个扔到控制台。

季节：弹簧=[三月、四月]

季节：夏季=[五月、六月，七月，八月]

季节：落=[日，日]

季节：冬季=[日，一月、二月]

小组：A={弹=[星期二、星期四]，落=[星期二、星期四]，夏季=[星期一、星期二、星期三、四、五、六、日]，冬季=[二]}

小组：B={弹=[五]，落=[星期二、星期五]，夏季=[星期一、星期二、星期三、四、五、六、日]，冬季=[五]}

小组：C={弹=[星期一]，落=[星期一、星期二]，夏季=[星期一、星期二、星期三、四、五、六、日]，冬季=[星期一]}

小组：D={弹=[星期三、星期五]，落=[五]，夏季=[星期一、星期二、星期三、四、五、六、日]，冬季=[三]}

小组：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是：[三]

E组--水天上2018-01-30周#2018-W05是：[三]

ISO8601周

你可能会发现它有助于了解 ISO8601 标准对于一个 定义的一周.该标准给一个具体的含义为"一周"和定义的文本格式的用于表示某一周或某一个特定日内，星期。

对于工作与这个星期内Java，考虑加入 ThreeTen-额外的 图书馆项目使用的 YearWeek 类。

LocalDate

的 LocalDate 类表示一个日期只有价值没有时间和没有时区。

一次区域至关重要的是在确定一个日期。对于任何给定的时刻，日期不同世界各地的区域。例如，几分钟后在午夜 巴黎法国 是新的一天，同时仍然"昨天"在 蒙特利尔魁北克.

如果没有指定时区，JVM隐含地适用其目前的默认时区。这可以在任何时刻改变，因此结果可能有所不同。最好指定你所需要/期望时间的区域明确作为一个参数。

指定一个 适当时区名称 在格式 continent/region, 如 America/Montreal, Africa/Casablanca, 或 Pacific/Auckland.永远不会使用的3-4个字母的缩写如 EST 或 IST 因为他们是 不 真正的时区，未标准化，甚至不是唯一的(!).

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月。

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 目的在你的代码，而不仅仅是一个整数使你的代码的更多的自的记录，确保有效值，并提供 类型的安全.

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

不可改变的集合

名单、集和地图上可见应最理想的是一成不变的集合，作为改变的成员，这些集合的可能的混淆和误。

New Java9语法 List.of 和 Map.of 已经答应将不可改变的。然而，在我们的情况 Map 应最理想的是一个 EnumMap 为提高效率的业绩和存储器中。目前的执行情况 Map.of 和 Set.of 显然不检测的使用枚举的成员和自动地优化用一个内部使用 EnumMap 和 EnumSet.有一个们可根据最新的技术提供一些问题打开考虑这样的问题： 考虑增强EnumMap和EnumSet.

一种方法获得一个不可改变的EnumSet和不可改变的EnumMap是通过 谷歌的番石榴 图书馆：

• Sets.immutableEnumSet( … )
• Maps.immutableEnumMap( … )

结果，每使用一个基础 EnumSet/EnumMap.等操作 get 和 put 扔一个例外。所以你得到的枚举相关的优化随着不变性。

这里是的 Season 和 Group 类看出上述修改以使用的谷歌番石榴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。时间

的 java。时间 框架是建立成Java8和后。这些类别取代的麻烦老 遗产 日间课程，例如 java.util.Date, Calendar, & SimpleDateFormat.

的 乔达时 项目,现在 维护模式, 建议迁移到 java。时间 课程。

若要了解更多信息，请参见的 Oracle教程.和搜索堆溢出许多实例和解释。说明书 JSR310.

在那里获得java。时间上课？

• Java SE8, Java SE9, 和之后
  • 内置。
  • 标准的一部分API与捆绑的执行情况。
  • Java9中增加了一些次要设和修复。
• Java SE6 和 Java SE7
  • 许多java。时间功能回来了-移植到Java6&7 ThreeTen-移植.
• 安卓
  • 后来版本的安卓束实现java。时间课程。
  • 早期， ThreeTenABP 项目适应 ThreeTen-移植 (所提到的上文)。看看 如何使用ThreeTenABP....

的 ThreeTen-额外的 项目的延伸java。时与附加课程。这个项目是一个试验场于今后可能增加java。时间。你可以找一些有用的类在这里 Interval, YearWeek, YearQuarter, ， 更多.