Module  java.base
软件包  java.time

Class YearMonth

  • All Implemented Interfaces:
    SerializableComparable<YearMonth>TemporalTemporalAccessorTemporalAdjuster


    public final class YearMonth
    extends Object
    implements Temporal, TemporalAdjuster, Comparable<YearMonth>, Serializable
    在ISO- 2007-12 ,如2007-12

    YearMonth是一个不变的日期时间对象,表示一年和一个月的组合。 可以获得可以从年和月派生的任何字段,例如四分之一年份。

    此类不存储或表示一天,时间或时区。 例如,值“2007年10月”可以存储在YearMonth

    ISO-8601日历系统是当今世界绝大多数的现代民用日历系统。 它相当于今天的闰年规则一直适用于日常生活的公历日历系统。 对于今天写的大多数应用,ISO-8601规则是完全合适的。 然而,任何利用历史日期并要求它们准确的应用程序都将发现ISO-8601方法不合适。

    这是一个value-based类; YearMonth实例上使用身份敏感操作(包括引用等式( == ),身份哈希码或同步)可能会产生不可预测的结果,应该避免。 equals方法应用于比较。

    实现要求:
    这个类是不可变的和线程安全的。
    从以下版本开始:
    1.8
    另请参见:
    Serialized Form
    • 方法详细信息

      • now

        public static YearMonth now​()
        从默认时区的系统时钟获取当前的一个月。

        这将查询默认时区中的system clock以获取当前的年月。

        使用此方法将阻止使用备用时钟进行测试,因为时钟是硬编码的。

        结果
        当前年份使用系统时钟和默认时区,不为空
      • now

        public static YearMonth now​(ZoneId zone)
        从指定时区的系统时钟获取当前的一个月。

        这将查询system clock获取当前的一个月。 指定时区可以避免对默认时区的依赖。

        使用此方法将阻止使用备用时钟进行测试,因为时钟是硬编码的。

        参数
        zone - 要使用的区域ID,不为空
        结果
        当前年份使用系统时钟,不为空
      • now

        public static YearMonth now​(Clock clock)
        从指定的时钟获取当前的一个月。

        这将查询指定的时钟以获取当前的年月。 使用此方法可以使用备用时钟进行测试。 可以使用dependency injection引入备用时钟。

        参数
        clock - 要使用的时钟,不为空
        结果
        当年,不为零
      • of

        public static YearMonth of​(int year,
                                   Month month)
        从一年和一个月获得 YearMonth的实例。
        参数
        year - 从MIN_YEAR到MAX_YEAR的年份
        month - 代表的月份,不为null
        结果
        年月,不为零
        异常
        DateTimeException - 如果年值无效
      • of

        public static YearMonth of​(int year,
                                   int month)
        从一年和一个月获得 YearMonth的实例。
        参数
        year - 从MIN_YEAR到MAX_YEAR的年份
        month - 从1月1日至12日(12月)的月份,
        结果
        年月,不为零
        异常
        DateTimeException - 如果任一字段值无效
      • from

        public static YearMonth from​(TemporalAccessor temporal)
        从时间对象获取YearMonth的实例。

        这取决于指定时间的一个月。 A TemporalAccessor表示日期和时间信息的任意集合,该工厂将转换为YearMonth的实例。

        该转换提取了YEARMONTH_OF_YEAR字段。 只有当时间对象具有ISO年表,或者可以转换为LocalDate ,才允许提取。

        该方法匹配功能接口TemporalQuery的签名,允许其通过方法参考YearMonth::from用作查询。

        参数
        temporal - 要转换的时间对象,不为null
        结果
        年月,不为零
        异常
        DateTimeException - 如果无法转换为 YearMonth
      • parse

        public static YearMonth parse​(CharSequence text)
        从文本字符串(例如2007-12获取YearMonth的实例。

        字符串必须表示有效的一个月。 格式必须为uuuu-MM 超出范围0000到9999之间的年份必须加上加号或减号。

        参数
        text - 要解析的文本,如“2007-12”,不为空
        结果
        解析的年月,不为零
        异常
        DateTimeParseException - 如果文本无法解析
      • parse

        public static YearMonth parse​(CharSequence text,
                                      DateTimeFormatter formatter)
        使用特定的格式化程序从文本字符串获取YearMonth的实例。

        使用格式化程序解析文本,返回一个月。

        参数
        text - 要解析的文本,不为空
        formatter - 要使用的格式化程序,不为null
        结果
        解析的年月,不为零
        异常
        DateTimeParseException - 如果文本无法解析
      • isSupported

        public boolean isSupported​(TemporalField field)
        检查指定的字段是否受支持。

        这将检查是否可以查询指定字段的年月。 如果是假,然后调用rangegetwith(TemporalField, long)方法会抛出异常。

        如果该字段是一个ChronoField那么查询是在这里实现的。 支持的字段有:

        • MONTH_OF_YEAR
        • PROLEPTIC_MONTH
        • YEAR_OF_ERA
        • YEAR
        • ERA
        所有其他ChronoField实例将返回false。

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用得到TemporalField.isSupportedBy(TemporalAccessor)传递this作为参数。 字段是否受支持由字段决定。

        Specified by:
        isSupported在接口 TemporalAccessor
        参数
        field - 要检查的字段,null返回false
        结果
        如果该字段在今年支持,则为true,否则为false
      • isSupported

        public boolean isSupported​(TemporalUnit unit)
        检查指定的单位是否受支持。

        这将检查指定的单位是否可以添加到今年或从今年减去。 如果是false,那么调用plus(long, TemporalUnit)minus方法会抛出异常。

        如果单位是ChronoUnit那么查询是在这里实现的。 支持的单位是:

        • MONTHS
        • YEARS
        • DECADES
        • CENTURIES
        • MILLENNIA
        • ERAS
        所有其他ChronoUnit实例将返回false。

        如果该单元不是ChronoUnit ,则此方法的结果是通过调用得到TemporalUnit.isSupportedBy(Temporal)传递this作为参数。 设备是否受支持由本机决定。

        Specified by:
        isSupported在接口 Temporal
        参数
        unit - 要检查的单位,null返回false
        结果
        如果可以添加/减去单位,则为真,否则为false
      • range

        public ValueRange range​(TemporalField field)
        获取指定字段的有效值的范围。

        范围对象表示字段的最小和最大有效值。 今年用于提高返回范围的准确性。 如果不可能返回范围,因为该字段不受支持或出于某种其他原因,则抛出异常。

        如果该字段是一个ChronoField那么查询是在这里实现的。 supported fields将返回适当的范围实例。 所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用得到TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。 是否可以获得范围由字段确定。

        Specified by:
        range在接口 TemporalAccessor
        参数
        field - 查询范围的字段,不为null
        结果
        字段的有效值的范围不为null
        异常
        DateTimeException - 如果无法获取字段的范围
        UnsupportedTemporalTypeException - 如果该字段不被支持
      • get

        public int get​(TemporalField field)
        从本年度获取指定字段的值作为int

        这个年月查询指定字段的值。 返回的值将始终在该字段的值的有效范围内。 如果不可能返回值,因为该字段不受支持或出于某种其他原因,则抛出异常。

        如果该字段是一个ChronoField那么查询是在这里实现的。 supported fields将返回基于今年的有效值,除了PROLEPTIC_MONTH ,这太大,无法适应int并抛出DateTimeException 所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。 该值是否可以获得,该值代表什么值由该字段决定。

        Specified by:
        get在接口 TemporalAccessor
        参数
        field - 要获取的字段,不为null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值的范围
        UnsupportedTemporalTypeException - 如果该字段不受支持或值的范围超过 int
        ArithmeticException - 如果发生数字溢出
      • getLong

        public long getLong​(TemporalField field)
        从这个年月获得指定字段的值作为long

        这个年月查询指定字段的值。 如果不可能返回值,因为该字段不受支持或出于某种其他原因,则抛出异常。

        如果该字段是一个ChronoField那么查询是在这里实现的。 supported fields将返回基于今年的有效值。 所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。 该值是否可以获得,该值代表什么值由该字段决定。

        Specified by:
        getLong在接口 TemporalAccessor
        参数
        field - 要获取的字段,不为null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取字段的值
        UnsupportedTemporalTypeException - 如果该字段不被支持
        ArithmeticException - 如果发生数字溢出
      • getYear

        public int getYear​()
        获取年份字段。

        此方法返回一年的原始值int

        通过这种方法返回的年份是根据get(YEAR)是灵巧的。

        结果
        年,从MIN_YEAR到MAX_YEAR
      • getMonthValue

        public int getMonthValue​()
        将月份字段从1到12。

        此方法将一个月作为int从1到12返回。如果通过调用getMonth()使用枚举Month应用程序代码通常更清晰。

        结果
        从1到12年的月份
        另请参见:
        getMonth()
      • getMonth

        public Month getMonth​()
        使用Month枚举获取月份字段。

        此方法返回本月的枚举Month 这避免了int值意味着什么的混乱。 如果您需要访问原始的int值,则枚举将提供int value

        结果
        月份,不为零
        另请参见:
        getMonthValue()
      • isLeapYear

        public boolean isLeapYear​()
        根据ISO培训日历系统规则,检查年份是否是闰年。

        这种方法在整个时间线上应用目前的闰年规则。 一般来说,一年是一个闰年,如果没有余数可以被四分割。 但是,除了100岁之外,年份可以被分割为100岁,除了年龄可以被400除外。

        例如,1904年是一个闰年,可以被4整除。1900年不是一个闰年,因为它可以被100整除,然而2000年是一个闰年,因为它可以被400除数。

        计算是应激的 - 将相同的规则应用到远未来很远的地方。 这在历史上是不准确的,但对于ISO-8601标准是正确的。

        结果
        如果一年是飞跃,否则为假
      • isValidDay

        public boolean isValidDay​(int dayOfMonth)
        检查月日是否在今年有效。

        此方法检查年,月和输入日形成有效日期。

        参数
        dayOfMonth - 验证的月份,从1到31,无效值返回false
        结果
        如果当天在今年有效,则为真
      • lengthOfMonth

        public int lengthOfMonth​()
        返回月份的长度,考虑到年份。

        这将以天为单位返回月份的长度。 例如,1月份的日期将返回31。

        结果
        月份的天数,从28天到31天
      • lengthOfYear

        public int lengthOfYear​()
        返回一年的长度。

        这将返回年份的长度,以天数为365或366。

        结果
        366如果一年是飞跃,否则为365
      • with

        public YearMonth with​(TemporalAdjuster adjuster)
        返回今年的调整副本。

        这将返回一个YearMonth ,基于此,与年月调整。 调整使用指定的调整器策略对象进行。 阅读调整器的文档,了解将进行什么调整。

        一个简单的调整器可能只是设置一个字段,如年份字段。 一个更复杂的调整者可能会将下个月的月份设定为Halley的彗星将通过地球。

        该方法的结果是通过调用TemporalAdjuster.adjustInto(Temporal)方法在指定的调整器通过this作为参数获得的。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        with在接口 Temporal
        参数
        adjuster - 调整器使用,不为空
        结果
        一个 YearMonth基于 this进行了调整,不为null
        异常
        DateTimeException - 如果不能进行调整
        ArithmeticException - 如果发生数字溢出
      • with

        public YearMonth with​(TemporalField field,
                              long newValue)
        返回此年月份的副本,并将指定的字段设置为新值。

        这将返回一个YearMonth ,基于此,更改指定字段的值。 这可以用于更改任何支持的字段,例如年份或月份。 如果不可能设置该值,因为该字段不受支持或出于某种其他原因,则抛出异常。

        如果该字段是ChronoField则在此处执行调整。 支持的字段的行为如下:

        • MONTH_OF_YEAR - 返回指定月份的YearMonth 年将不变。
        • PROLEPTIC_MONTH - 返回一个YearMonth具有指定的月份。 这完全取代了这个对象的年和月。
        • YEAR_OF_ERA - 返回指定年龄的YearMonth月份和时代将不变。
        • YEAR - 返回指定年份的YearMonth 这个月不变。
        • ERA - 返回指定时代的YearMonth 月份和年龄将不变。

        在所有情况下,如果新值超出该字段值的有效范围,那么将抛出DateTimeException

        所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用得到TemporalField.adjustInto(Temporal, long)传递this作为参数。 在这种情况下,该字段决定是否以及如何调整即时。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        with在接口 Temporal
        参数
        field - 要在结果中设置的字段,不为null
        newValue - 结果中字段的新值
        结果
        一个 YearMonth基于 this指定字段集,不为null
        异常
        DateTimeException - 如果字段无法设置
        UnsupportedTemporalTypeException - 如果该字段不被支持
        ArithmeticException - 如果发生数字溢出
      • withYear

        public YearMonth withYear​(int year)
        返回这个YearMonth的副本,并更改年份。

        此实例是不可变的,不受此方法调用的影响。

        参数
        year - 从MIN_YEAR到MAX_YEAR的返回年份设置的年份
        结果
        一个 YearMonth基于今年所要求的一年,不为零
        异常
        DateTimeException - 如果年值无效
      • withMonth

        public YearMonth withMonth​(int month)
        返回这个YearMonth的副本,其中YearMonth了月份。

        此实例是不可变的,不受此方法调用的影响。

        参数
        month - 从1月(1月)至12月(12月),在返回的年份中设定的月份
        结果
        一个 YearMonth基于今年月份与请求的月份,不为null
        异常
        DateTimeException - 如果月份值无效
      • plus

        public YearMonth plus​(TemporalAmount amountToAdd)
        返回此年份的副本,并添加指定的金额。

        这将返回一个YearMonth ,基于此,添加了指定的数量。 金额通常为Period但可能是实现TemporalAmount接口的任何其他类型。

        通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。 数量执行可以以任何方式实现添加,但是它通常会回调到plus(long, TemporalUnit) 请参阅金额执行的文档,以确定是否可以成功添加。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        plus在接口 Temporal
        参数
        amountToAdd - 要添加的金额,不为null
        结果
        一个 YearMonth基于今年的增加,不是null
        异常
        DateTimeException - 如果不能添加
        ArithmeticException - 如果发生数字溢出
      • plus

        public YearMonth plus​(long amountToAdd,
                              TemporalUnit unit)
        返回此年份的副本,并添加指定的金额。

        这将返回一个YearMonth ,基于这一个,以添加的单位数量。 如果不可能添加金额,因为单位不受支持或出于某种其他原因,则抛出异常。

        如果该字段是一个ChronoUnit那么添加在这里实现。 支持的字段的行为如下:

        • MONTHS - 返回一个YearMonth ,加上指定的月数。 这相当于plusMonths(long)
        • YEARS - 返回指定年数的YearMonth 这相当于plusYears(long)
        • DECADES - 返回一个YearMonth ,加上指定的几十年。 这相当于调用plusYears(long) ,数量乘以10。
        • CENTURIES - 返回一个YearMonth具有指定的几个世纪。 这相当于调用plusYears(long) ,数量乘以100。
        • MILLENNIA - 返回一个YearMonth ,加上指定的几千年。 这相当于调用plusYears(long) ,数量乘以1,000。
        • ERAS - 返回一个YearMonth ,其中添加了指定的时间。 只支持两个时间,所以数量必须是1,零或者减1。 如果金额不是零,那么这个年份就会改变,使得年龄不变。

        所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoUnit ,则此方法的结果是通过调用得到TemporalUnit.addTo(Temporal, long)传递this作为参数。 在这种情况下,单元确定是否以及如何执行添加。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        plus在接口 Temporal
        参数
        amountToAdd - 要添加到结果中的单位数量,可能为负数
        unit - 要添加的单位,不为null
        结果
        一个 YearMonth基于这个年月加上指定的金额,不为null
        异常
        DateTimeException - 如果不能添加
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • plusYears

        public YearMonth plusYears​(long yearsToAdd)
        返回此YearMonth的副本,并附加指定的年数。

        此实例是不可变的,不受此方法调用的影响。

        参数
        yearsToAdd - 多年来补充,可能是负数
        结果
        一个 YearMonth基于今年增加的年份,不为零
        异常
        DateTimeException - 如果结果超出了支持的范围
      • plusMonths

        public YearMonth plusMonths​(long monthsToAdd)
        返回此YearMonth的副本,并附加指定的月数。

        此实例是不可变的,不受此方法调用的影响。

        参数
        monthsToAdd - 要添加的月份,可能为负数
        结果
        一个 YearMonth基于今年月份增加的月份,不为空
        异常
        DateTimeException - 如果结果超出了支持的范围
      • minus

        public YearMonth minus​(TemporalAmount amountToSubtract)
        返回减去指定数量的今年的副本。

        这将返回一个YearMonth ,基于此,减去指定的数量。 金额通常为Period但可能是实现TemporalAmount接口的任何其他类型。

        通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。 数量执行可以以任何方式实现减法,但是它通常会调用到minus(long, TemporalUnit) 请参阅数量执行的文档,以确定是否可以成功减去它们。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        minus在接口 Temporal
        参数
        amountToSubtract - 减去量,不为空
        结果
        一个 YearMonth基于今年的减法而不是null
        异常
        DateTimeException - 如果不能进行减法
        ArithmeticException - 如果发生数字溢出
      • minus

        public YearMonth minus​(long amountToSubtract,
                               TemporalUnit unit)
        返回减去指定数量的今年的副本。

        这将返回一个YearMonth ,基于此,减去单位的数量。 如果不可能减去金额,因为该单位不受支持或出于某种其他原因,则会抛出异常。

        该方法相当于plus(long, TemporalUnit) ,其数量被否定。 请参阅该方法,以了解如何添加,从而减去运算。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        minus在接口 Temporal
        参数
        amountToSubtract - 从结果中减去的单位数量可能为负数
        unit - 减去量的单位,不为空
        结果
        一个 YearMonth基于今年减去指定数量,不为null
        异常
        DateTimeException - 如果不能进行减法
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • minusYears

        public YearMonth minusYears​(long yearsToSubtract)
        返回此YearMonth的副本,并减去指定的年数。

        此实例是不可变的,不受此方法调用的影响。

        参数
        yearsToSubtract - 减去年份,可能为负数
        结果
        一个 YearMonth基于今年减去年,不为零
        异常
        DateTimeException - 如果结果超出了支持的范围
      • minusMonths

        public YearMonth minusMonths​(long monthsToSubtract)
        返回此YearMonth的副本,并减去指定的月数。

        此实例是不可变的,不受此方法调用的影响。

        参数
        monthsToSubtract - 减去数月,可能为负数
        结果
        一个 YearMonth基于今年减少的月份,不为零
        异常
        DateTimeException - 如果结果超出了支持范围
      • query

        public <R> R query​(TemporalQuery<R> query)
        使用指定的查询查询今年。

        这使用指定的查询策略对象查询今年。 TemporalQuery对象定义了用于获取结果的逻辑。 阅读查询的文档,以了解该方法的结果。

        该方法的结果是通过在指定的查询this作为参数调用TemporalQuery.queryFrom(TemporalAccessor)方法获得的。

        Specified by:
        query在接口 TemporalAccessor
        参数类型
        R - 结果的类型
        参数
        query - 要调用的查询,不为空
        结果
        查询结果可能返回null(由查询定义)
        异常
        DateTimeException - 如果无法查询(由查询定义)
        ArithmeticException - 如果发生数字溢出(由查询定义)
      • adjustInto

        public Temporal adjustInto​(Temporal temporal)
        将指定的时间对象调整为今年。

        这返回与年和月份的输入相同的可观察类型的时间对象与此相同。

        该调整是相当于使用Temporal.with(TemporalField, long)通过ChronoField.PROLEPTIC_MONTH作为字段。 如果指定的时间对象不使用ISO日历系统,则抛出DateTimeException

        在大多数情况下,通过使用Temporal.with(TemporalAdjuster)更正呼叫模式:

          // these two lines are equivalent, but the second approach is recommended
           temporal = thisYearMonth.adjustInto(temporal);
           temporal = temporal.with(thisYearMonth); 

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        adjustInto在接口 TemporalAdjuster
        参数
        temporal - 要调整的目标对象,不为null
        结果
        调整对象,不为null
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • until

        public long until​(Temporal endExclusive,
                          TemporalUnit unit)
        根据指定单位计算直到另一个一个月的时间量。

        这可以计算一个YearMonth对象之间的时间量,单个TemporalUnit 起点和终点是this和指定的年月。 如果结束在开始之前,结果将为负数。 所述Temporal传递给此方法被转换为YearMonth使用from(TemporalAccessor) 例如,可以使用startYearMonth.until(endYearMonth, YEARS)计算两年之间的年数。

        计算返回一个整数,表示两个月之间的完整单位数。 例如,2012-06年至2032-05年间的数十年将只有二十年的一个月。

        使用这种方法有两种等效的方法。 第一个是调用这个方法。 二是使用TemporalUnit.between(Temporal, Temporal)

          // these two lines are equivalent
           amount = start.until(end, MONTHS);
           amount = MONTHS.between(start, end); 
        应该根据这种做法进行选择,使代码更易读。

        以此方法计算ChronoUnit 单位MONTHSYEARSDECADESCENTURIESMILLENNIAERAS的支持。 其他ChronoUnit值会抛出异常。

        如果该单元不是ChronoUnit ,则此方法的结果是通过调用得到TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        until在接口 Temporal
        参数
        endExclusive - 结束日期,排他,转换为 YearMonth ,不为空
        unit - 衡量金额的单位,不为空
        结果
        今年至今年底的时间
        异常
        DateTimeException - 如果不能计算金额,或者结束时间不能转换为 YearMonth
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • format

        public String format​(DateTimeFormatter formatter)
        使用指定的格式化程序在今年的格式。

        今年将被传递给格式化程序来生成一个字符串。

        参数
        formatter - 要使用的格式化程序,不为null
        结果
        格式化的年份字符串,不为空
        异常
        DateTimeException - 打印过程中是否发生错误
      • atDay

        public LocalDate atDay​(int dayOfMonth)
        结合今年的月份,创造一个LocalDate

        这将返回一个LocalDate ,从今年月份和指定的日期形成。

        月日的价值必须在年月有效。

        该方法可以用作链的一部分来生成日期:

          LocalDate date = year.atMonth(month).atDay(day); 
        参数
        dayOfMonth - 使用月份,从1到31
        结果
        从今年和特定日期形成的日期不为零
        异常
        DateTimeException - 如果一天的年份无效
        另请参见:
        isValidDay(int)
      • atEndOfMonth

        public LocalDate atEndOfMonth​()
        在本月底返回LocalDate

        这将返回一个基于今年的LocalDate 每月的最后一个有效日期,考虑到闰年。

        该方法可以用作链的一部分来生成日期:

          LocalDate date = year.atMonth(month).atEndOfMonth(); 
        结果
        今年的最后有效日期,不为空
      • compareTo

        public int compareTo​(YearMonth other)
        比较今年至另一个月。

        这个比较首先是基于年的价值,然后是月的价值。 它与“等于”一致,如Comparable所定义。

        Specified by:
        compareTo在接口 Comparable<YearMonth>
        参数
        other - 与其他年份进行比较,不为空
        结果
        比较器值为负,如果较小,则如果较大则为正
      • isAfter

        public boolean isAfter​(YearMonth other)
        检查这个年月是否在指定的年月之后。
        参数
        other - 其他年月比较,不为null
        结果
        如果这是指定的年月之后,则为真
      • isBefore

        public boolean isBefore​(YearMonth other)
        检查这个年月是否在指定的年份之前。
        参数
        other - 其他年月比较,不为null
        结果
        如果这一点在指定的年月之前,则为真
      • equals

        public boolean equals​(Object obj)
        检查这个年月是否等于另一个一个月。

        比较是基于年月日的时间位置。

        重写:
        equalsObject
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于其他年份,则为true
        另请参见:
        Object.hashCode()HashMap
      • toString

        public String toString​()
        今年产量为String ,如2007-12

        输出格式为uuuu-MM

        重写:
        toStringObject
        结果
        今年的字符串表示,不为空