@Override
    public long until(Temporal endExclusive, TemporalUnit unit) {
        Year end = Year.from(endExclusive);
        if (unit instanceof ChronoUnit) {
            long yearsUntil = ((long) end.year) - year;  // no overflow
            switch ((ChronoUnit) unit) {
                case YEARS: return yearsUntil;
                case DECADES: return yearsUntil / 10;
                case CENTURIES: return yearsUntil / 100;
                case MILLENNIA: return yearsUntil / 1000;
                case ERAS: return end.getLong(ERA) - getLong(ERA);
            }
            throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
        }
        return unit.between(this, end);
    }
@ Override public long until ( Temporal endExclusive , TemporalUnit unit ) { Year end = Year . from ( endExclusive ) ; if ( unit instanceof ChronoUnit ) { long yearsUntil = ( ( long ) end . year ) - year ; switch ( ( ChronoUnit ) unit ) { case YEARS : return yearsUntil ; case DECADES : return yearsUntil / 10 ; case CENTURIES : return yearsUntil / 100 ; case MILLENNIA : return yearsUntil / 1000 ; case ERAS : return end . getLong ( ERA ) - getLong ( ERA ) ; } throw new UnsupportedTemporalTypeException ( "Unsupported unit: " + unit ) ; } return unit . between ( this , end ) ; }
Calculates the amount of time until another year in terms of the specified unit.
<p>
This calculates the amount of time between two {@code Year}
objects in terms of a single {@code TemporalUnit}.
The start and end points are {@code this} and the specified year.
The result will be negative if the end is before the start.
The {@code Temporal} passed to this method is converted to a
{@code Year} using {@link #from(TemporalAccessor)}.
For example, the amount in decades between two year can be calculated
using {@code startYear.until(endYear, DECADES)}.
<p>
The calculation returns a whole number, representing the number of
complete units between the two years.
For example, the amount in decades between 2012 and 2031
will only be one decade as it is one year short of two decades.
<p>
There are two equivalent ways of using this method.
The first is to invoke this method.
The second is to use {@link TemporalUnit#between(Temporal, Temporal)}:
<pre>
// these two lines are equivalent
amount = start.until(end, YEARS);
amount = YEARS.between(start, end);
</pre>
The choice should be made based on which makes the code more readable.
<p>
The calculation is implemented in this method for {@link ChronoUnit}.
The units {@code YEARS}, {@code DECADES}, {@code CENTURIES},
{@code MILLENNIA} and {@code ERAS} are supported.
Other {@code ChronoUnit} values will throw an exception.
<p>
If the unit is not a {@code ChronoUnit}, then the result of this method
is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)}
passing {@code this} as the first argument and the converted input temporal
as the second argument.
<p>
This instance is immutable and unaffected by this method call.

@param endExclusive  the end date, exclusive, which is converted to a {@code Year}, not null
@param unit  the unit to measure the amount in, not null
@return the amount of time between this year and the end year
@throws DateTimeException if the amount cannot be calculated, or the end
temporal cannot be converted to a {@code Year}
@throws UnsupportedTemporalTypeException if the unit is not supported
@throws ArithmeticException if numeric overflow occurs