Java ChronoUnit.HOURS屬性代碼示例

/**
 * To chrono unit.
 *
 * @param tu the tu
 * @return the chrono unit
 */
public static ChronoUnit toChronoUnit(final TimeUnit tu) {
    if (tu == null) {
        return null;
    }
    switch (tu) {
        case DAYS:
            return ChronoUnit.DAYS;
        case HOURS:
            return ChronoUnit.HOURS;
        case MINUTES:
            return ChronoUnit.MINUTES;
        case SECONDS:
            return ChronoUnit.SECONDS;
        case MICROSECONDS:
            return ChronoUnit.MICROS;
        case MILLISECONDS:
            return ChronoUnit.MILLIS;
        case NANOSECONDS:
            return ChronoUnit.NANOS;
        default:
            return null;
    }
}
 

/**
 * Converts a {@code TimeUnit} to a {@code ChronoUnit}.
 * <p>
 * This handles the seven units declared in {@code TimeUnit}.
 *
 * @param unit  the unit to convert, not null
 * @return the converted unit, not null
 */
private static ChronoUnit chronoUnit(final TimeUnit unit) {
    Objects.requireNonNull(unit, "unit");
    switch (unit) {
        case NANOSECONDS:
            return ChronoUnit.NANOS;
        case MICROSECONDS:
            return ChronoUnit.MICROS;
        case MILLISECONDS:
            return ChronoUnit.MILLIS;
        case SECONDS:
            return ChronoUnit.SECONDS;
        case MINUTES:
            return ChronoUnit.MINUTES;
        case HOURS:
            return ChronoUnit.HOURS;
        case DAYS:
            return ChronoUnit.DAYS;
        default:
            throw new IllegalArgumentException("Unknown TimeUnit constant");
    }
}
 

private static ChronoUnit toChronoUnit(TimeUnit unit) { 
    Objects.requireNonNull(unit, "unit"); 
    switch (unit) { 
        case NANOSECONDS: 
            return ChronoUnit.NANOS; 
        case MICROSECONDS: 
            return ChronoUnit.MICROS; 
        case MILLISECONDS: 
            return ChronoUnit.MILLIS; 
        case SECONDS: 
            return ChronoUnit.SECONDS; 
        case MINUTES: 
            return ChronoUnit.MINUTES; 
        case HOURS: 
            return ChronoUnit.HOURS; 
        case DAYS: 
            return ChronoUnit.DAYS; 
        default: 
            throw new IllegalArgumentException("Unknown TimeUnit constant"); 
    } 
}
 

/**
 * Returns the parent ChronoUnit for the given ChronoUnit.
 *
 * @param chronoUnit desired ChronoUnit
 * @return parent ChronoUnit of the given ChronoUnit
 */
@NotNull
public static ChronoUnit getParentChronoUnit(@NotNull ChronoUnit chronoUnit) {
    switch (requireNonNull(chronoUnit)) {
        case NANOS:
            return ChronoUnit.SECONDS;
        case MICROS:
            return ChronoUnit.SECONDS;
        case MILLIS:
            return ChronoUnit.SECONDS;
        case SECONDS:
            return ChronoUnit.MINUTES;
        case MINUTES:
            return ChronoUnit.HOURS;
        case HOURS:
            return ChronoUnit.DAYS;
        case DAYS:
            return ChronoUnit.WEEKS;
        case WEEKS:
            return ChronoUnit.MONTHS;
        case MONTHS:
            return ChronoUnit.YEARS;
        case YEARS:
            return ChronoUnit.DECADES;
        case DECADES:
            return ChronoUnit.CENTURIES;
        case CENTURIES:
            return ChronoUnit.ERAS;
        default:
            throw new UnsupportedOperationException("Unsupported chrono unit: " + chronoUnit);
    }
}
 

/**
 * Returns the child ChronoUnit for the given ChronoUnit.
 *
 * @param chronoUnit desired ChronoUnit
 * @return child ChronoUnit of the given ChronoUnit
 */
@NotNull
public static ChronoUnit getChildChronoUnit(@NotNull ChronoUnit chronoUnit) {
    switch (requireNonNull(chronoUnit)) {
        case MICROS:
            return ChronoUnit.NANOS;
        case MILLIS:
            return ChronoUnit.MICROS;
        case SECONDS:
            return ChronoUnit.MILLIS;
        case MINUTES:
            return ChronoUnit.SECONDS;
        case HOURS:
            return ChronoUnit.MINUTES;
        case DAYS:
            return ChronoUnit.HOURS;
        case WEEKS:
            return ChronoUnit.DAYS;
        case MONTHS:
            return ChronoUnit.WEEKS;
        case YEARS:
            return ChronoUnit.MONTHS;
        case DECADES:
            return ChronoUnit.YEARS;
        case MILLENNIA:
            return ChronoUnit.DECADES;
        case ERAS:
            return ChronoUnit.MILLENNIA;
        default:
            throw new UnsupportedOperationException("Unsupported chrono unit: " + chronoUnit);
    }
}
 

/**
 * Create a RollingFileWriter as specified
 *
 * @param directory Path where the log files will be created
 * @param name Base name to use for log files
 * @param zone Time zone of timestamps on rolling file names
 * @param minuteRotation If true, rotate logs every minute, if false rotate every hour
 */
RollingFileWriter(Path directory, String name, TimeZone zone, boolean minuteRotation)
{
    if (directory == null) {
        throw new IllegalArgumentException("Directory required");
    }
    if (name == null) {
        throw new IllegalArgumentException("File base name required");
    }
    if (zone == null) {
        throw new IllegalArgumentException("Time zone required");
    }

    this.directory = directory;
    this.baseName = name;
    this.timeZone = zone.toZoneId();

    final String formatPattern = (minuteRotation ? ".yyyy-MM-dd-HH-mm" : ".yyyy-MM-dd-HH");
    this.format = DateTimeFormatter.ofPattern(formatPattern);

    if (minuteRotation) {
        rollInterval = ChronoUnit.SECONDS;
    } else {
        rollInterval = ChronoUnit.HOURS;
    }

    // Set to roll immediately on first write, to ensure file is created
    this.rollAt = Instant.now().truncatedTo(rollInterval);
}
 

static Duration parseDuration(String input) {
  if (input.startsWith("P") || input.startsWith("-P") || input.startsWith("+P")) {
    return Duration.parse(input);
  }

  String[] parts = splitNumericAndChar(input);
  String numberString = parts[0];
  String originalUnitString = parts[1];
  String unitString = originalUnitString;

  if (numberString.length() == 0) {
    throw new IllegalArgumentException(String.format("No number in duration value '%s'", input));
  }

  if (unitString.length() > 2 && !unitString.endsWith("s")) {
    unitString = unitString + "s";
  }

  ChronoUnit units;
  switch (unitString) {
    case "ns":
      units = ChronoUnit.NANOS;
      break;
    case "us":
      units = ChronoUnit.MICROS;
      break;
    case "":
    case "ms":
      units = ChronoUnit.MILLIS;
      break;
    case "s":
      units = ChronoUnit.SECONDS;
      break;
    case "m":
      units = ChronoUnit.MINUTES;
      break;
    case "h":
      units = ChronoUnit.HOURS;
      break;
    case "d":
      units = ChronoUnit.DAYS;
      break;
    default:
      throw new IllegalArgumentException(
          String.format("Could not parse time unit '%s' (try ns, us, ms, s, m, h, d)", originalUnitString));
  }

  return Duration.of(Long.parseLong(numberString), units);
}