Java Temporal.with方法代碼示例

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have this year-month.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the year and month changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#PROLEPTIC_MONTH} as the field.
 * If the specified temporal object does not use the ISO calendar system then
 * a {@code DateTimeException} is thrown.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisYearMonth.adjustInto(temporal);
 *   temporal = temporal.with(thisYearMonth);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Temporal adjustInto(Temporal temporal) {
    if (Chronology.from(temporal).equals(IsoChronology.INSTANCE) == false) {
        throw new DateTimeException("Adjustment only supported on ISO date-time");
    }
    return temporal.with(PROLEPTIC_MONTH, getProlepticMonth());
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have this month-day.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the month and day-of-month changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * twice, passing {@link ChronoField#MONTH_OF_YEAR} and
 * {@link ChronoField#DAY_OF_MONTH} as the fields.
 * If the specified temporal object does not use the ISO calendar system then
 * a {@code DateTimeException} is thrown.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisMonthDay.adjustInto(temporal);
 *   temporal = temporal.with(thisMonthDay);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Temporal adjustInto(Temporal temporal) {
    if (Chronology.from(temporal).equals(IsoChronology.INSTANCE) == false) {
        throw new DateTimeException("Adjustment only supported on ISO date-time");
    }
    temporal = temporal.with(MONTH_OF_YEAR, month);
    return temporal.with(DAY_OF_MONTH, Math.min(temporal.range(DAY_OF_MONTH).getMaximum(), day));
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have this year.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the year changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#YEAR} as the field.
 * If the specified temporal object does not use the ISO calendar system then
 * a {@code DateTimeException} is thrown.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisYear.adjustInto(temporal);
 *   temporal = temporal.with(thisYear);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Temporal adjustInto(Temporal temporal) {
    if (Chronology.from(temporal).equals(IsoChronology.INSTANCE) == false) {
        throw new DateTimeException("Adjustment only supported on ISO date-time");
    }
    return temporal.with(YEAR, year);
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have the same time as this object.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the time changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#NANO_OF_DAY} as the field.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisLocalTime.adjustInto(temporal);
 *   temporal = temporal.with(thisLocalTime);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Temporal adjustInto(Temporal temporal) {
    return temporal.with(NANO_OF_DAY, toNanoOfDay());
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have the same date as this object.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the date changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#EPOCH_DAY} as the field.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisLocalDate.adjustInto(temporal);
 *   temporal = temporal.with(thisLocalDate);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
default Temporal adjustInto(Temporal temporal) {
    return temporal.with(EPOCH_DAY, toEpochDay());
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have the same era as this object.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the era changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#ERA} as the field.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisEra.adjustInto(temporal);
 *   temporal = temporal.with(thisEra);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
default Temporal adjustInto(Temporal temporal) {
    return temporal.with(ERA, getValue());
}
 

import java.time.temporal.Temporal; //導入方法依賴的package包/類
/**
 * Adjusts the specified temporal object to have the same offset as this object.
 * <p>
 * This returns a temporal object of the same observable type as the input
 * with the offset changed to be the same as this.
 * <p>
 * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
 * passing {@link ChronoField#OFFSET_SECONDS} as the field.
 * <p>
 * In most cases, it is clearer to reverse the calling pattern by using
 * {@link Temporal#with(TemporalAdjuster)}:
 * <pre>
 *   // these two lines are equivalent, but the second approach is recommended
 *   temporal = thisOffset.adjustInto(temporal);
 *   temporal = temporal.with(thisOffset);
 * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param temporal  the target object to be adjusted, not null
 * @return the adjusted object, not null
 * @throws DateTimeException if unable to make the adjustment
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Temporal adjustInto(Temporal temporal) {
    return temporal.with(OFFSET_SECONDS, totalSeconds);
}