代码之家  ›  专栏  ›  技术社区  ›  Bruce the Hoon

Java中的数组

tomcat jsp php java
  •  14
  • Bruce the Hoon  · 技术社区  · 18 年前

    这对我来说是一个讨厌的。。。我是一个用Java开发JSP项目的PHP人员。我知道如何通过太多的代码和完全缺乏技巧来完成我正在尝试的事情。

    我正在写一个小展示,向客户展示根据他们的浇水组(ABCDE)可以在哪几天浇水,以及一年中的哪几天浇水。我们的季节是这样的: 弹簧(3-1至4-30) 下降(9-1至10-31) 冬季(11-1至2-28)

    例如:

    冬季:仅限星期一 春季:周二、周四、周六 秋季:周二、周四、周六 

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

    我可以制作days数组(数组(“星期二”、“星期四”、“星期六”)等,但这不是我真正想要完成的任务所必需的。 

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

    有人能提出一个很酷的方法吗?我会有今天的日期和团体信。我将需要一天(M)或一系列天(tTS),(任何时间)停止工作。

    12 回复  |  直到 8 年前
        1
  •  11
  •   Mike Stone    18 年前

    您可以对哈希表(或其他映射)执行基本相同的代码: 

    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不是一种动态语言,在语言级别上也没有哈希。

    注意:当我读到你的问题时,你可能会有更好的解决方案,这在我的脑海中突然出现。

        2
  •  9
  •   Vincent Robert    18 年前

    定义 

    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 HashMap 或 TreeMap .

        3
  •  6
  •   Ian Good    18 年前

    似乎每个人都在试图找到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);
...

        4
  •  4
  •   Akira    18 年前

    这里有一个方法 能够 看起来,你可以找出剩下的: 

    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 );
        5
  •  3
  •   Wing    18 年前

    我不是一个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";
        6
  •  2
  •   Derek Park    18 年前

    我完全搞不懂为什么你们中的一些人似乎认为朝代码扔一堆东西才是正确的选择。例如,有整整四个季节,而它们没有 做 任何东西它如何简化任何东西,使它们成为对象?Wing说的很对,这些应该是 常数

    布鲁斯所需要的,在它的核心,只是一个查找表。他不需要对象和接口的层次结构;他需要一种根据赛季和小组标识符查找时间表的方法。只有当事物有责任或状态时,将其转化为对象才有意义。如果两者都没有,那么它们只是标识符,为它们构建特殊对象只会使代码库更大。

    你 能够 建造,例如。, Group 组 对象确实提供了查找功能,然后您以一种不那么直观的方式重新创建了查找表。如果他必须查找组,然后查找计划,那么他所拥有的只是一个两步查找表,它需要更长的时间来编写代码,更有可能出现错误,并且更难维护。

        7
  •  2
  •   McDowell rahul gupta    18 年前

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

    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至

        8
  •  1
  •   Tim Frey    18 年前

    我同意,您应该明确地将此逻辑置于以下干净界面的后面: 

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

}

    您会失去一些可读性,但至少数据更接近它将被使用的位置。

        9
  •  1
  •   bpapa    18 年前 

    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的地图是值。

        10
  •  1
  •   Bernhard Barker    8 年前

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

    使用数据库将更易于维护,而且 variety of free database 可供选择的引擎。

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

        11
  •  0
  •   Derek Park    18 年前

    没有什么好办法。Java就是做不好这样的事情。Mike的解决方案基本上就是这样做的,如果您想要字符串作为索引(键)。如果哈希设置太难看,另一个选项是将字符串附加在一起(不知羞耻地从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 */ }
        12
  •  0
  •   Basil Bourque    8 年前

    tl;博士 

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

    这种方法产生了一个新的结果 Set DayOfWeek DayOfWeek.TUESDAY & DayOfWeek.THURSDAY

    现代爪哇

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

    对

    这个 java.time Java内置的框架提供了 Month DayOfWeek

    EnumSet 和 EnumMap 提供的实现 Set Map 优化后可与枚举一起使用,以便在非常少的内存中快速执行。

    你可以定义你自己的 enums Oracle Tutorial .

    定义自己的枚举的简单语法实际上提供了解决此问题所需的许多功能,消除了一些复杂的编码。刚出现的 literals syntax 对于中的集合和贴图 collections factory methods 在Java9中( JEP 269

    这里是一个完整的工作应用程序。 注意代码是多么少 对于算法来说,这是非常困难的。定义自己的自定义枚举完成了大部分繁重的工作。

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

    Season

    将您的季节表示为枚举 季 . 每个季节对象都有一个 List 月 枚举定义特定季节长度的对象。新的 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.A 在里面 Season.SPRING 允许在两天内浇水, & 星期四 . 

    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

    把所有这些都放在一起 班

    此类使用上面定义的两个枚举来完成有用的工作。到目前为止实现的唯一方法告诉您在特定日期允许特定组在一周中的哪几天。该方法确定 申请该日期。

    运行 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 ,我们看到它被转储到控制台。

    季节:春季=[三月、四月]

    季节:秋季=[九月、十月]

    季节:冬季=[11月、12月、1月、2月]

    组:A={春季=[周二,周四],秋季=[周二,周四],夏季=[周一,周二,周三,周四,周五,周六,周日],冬季=[周二]}

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

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

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

    2018-01-30周A组浇水日#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为:[周三]

    ISO 8601每周

    您可能会发现了解 ISO 8601 definition of week . 该标准给出了周的具体含义,并定义了表示该周内某一周或某一天的文本格式。

    在java中使用这些星期,请考虑添加 ThreeTen-Extra 库到您的项目中,以利用 YearWeek 班

    LocalDate

    LocalDate 类表示一个仅限日期的值,该值不包含一天中的时间,也不包含时区。

    时区对于确定日期至关重要。在任何一个特定的时刻,世界各地的日期都因地区而异。例如,午夜后几分钟 Paris France 新的一天还在昨天吗 Montréal Québec

    指定一个 proper time zone name continent/region 例如 America/Montreal , Africa/Casablanca Pacific/Auckland EST IST 事实上 不 真正的时区,没有标准化,甚至不是唯一的(!)。 

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


    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.

    月 枚举对象是预定义的,一年中每个月一个。提示:使用这些 月 对象,而不仅仅是一个整数,以使代码更具自文档性,确保有效值,并提供 type-safety . 

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

    不变集合

    上面看到的列表、集合和映射在理想情况下应该是不可变的集合,因为更改这些集合的成员身份可能会混淆和错误。

    Map.of 已经承诺是不变的。然而,在我们的案例中 地图 理想情况下应该是一个 枚举图 为了提高性能和内存效率。目前的执行情况 地图 Set.of 显然,不检测枚举作为成员的使用,而是通过内部使用 和 . 有一个OpenJDK问题开始考虑这样的问题: consider enhancements to EnumMap and EnumSet .

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

    每次使用的结果都有一个基础 枚举集 / 枚举图 . 操作,例如 get 和 put 抛出异常。因此,您可以获得与枚举相关的优化以及不变性。

    季 和 组

    不变性 

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


    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 legacy 日期时间类,例如 java.util.Date , Calendar SimpleDateFormat .

    这个 Joda-Time 项目,现在在 maintenance mode ,建议迁移到 上课。

    要了解更多信息,请参阅 Oracle Tutorial . 并搜索堆栈溢出以获得许多示例和解释。规格是 JSR 310 .

    从哪里获得java.time类?

    这个 ThreeTen-Extra project使用其他类扩展了java.time。这个项目是java.time将来可能添加的一个试验场。您可以在这里找到一些有用的类,例如 Interval , 年鉴 , YearQuarter 和 more

    推荐文章
    Ilkhom Tashkulov  ·  (Spring)未满足的依赖项异常
    4 年前
    Naveen Kumar  ·  使用spring引导安全性的web应用程序中的循环依赖
    4 年前
    hhuntercu  ·  带Tomcat 9.0的DSpace 7.2-循环占位符引用“DSpace”。属性定义中的dir
    4 年前
    david  ·  Spring war文件“java.sql.SQLException:找不到适合jdbc:postgresql的驱动程序:”
    8 年前
    Rasool Ghafari  ·  如何在spring boot和嵌入式tomcat中设置mod_reqtimeout?
    8 年前
    gigashark  ·  部署生成的Maven Spring项目不起作用
    8 年前
    blackdog  ·  如何在Springboot中禁止'DELETE'http请求?
    8 年前
    Tristan Le Gacque  ·  ApachePOI:NoClassDefFoundError:org。阿帕奇。poi。openxml4j。例外情况。invalidFormatException无效格式异常
    8 年前
    Carlos Chávez  ·  Tomcat/Hibernate配置
    8 年前
    Created Bylucky  ·  我正在获取异常组织。阿帕奇。卡特琳娜。果心应用程序Dispatcher。invoke引发java异常。lang.IllegalStateException异常
    8 年前
    关于   移动版
    代码之家 - 一站式码农服务社区
    沪ICP备11025650号