Java Duration.getSeconds方法代码示例

import java.time.Duration; //导入方法依赖的package包/类
public static String formatAsElapsed() {
    Duration elapsed = Duration.ofMillis(ManagementFactory.getRuntimeMXBean().getUptime());
    long days = elapsed.toDays();
    elapsed = elapsed.minusDays(days);
    long hours = elapsed.toHours();
    elapsed = elapsed.minusHours(hours);
    long minutes = elapsed.toMinutes();
    elapsed = elapsed.minusMinutes(minutes);
    long seconds = elapsed.getSeconds();
    elapsed = elapsed.minusSeconds(seconds);
    long millis = elapsed.toMillis();

    return String.format(TIME_FORMAT,
            days,
            hours,
            minutes,
            seconds,
            millis);
}
 

import java.time.Duration; //导入方法依赖的package包/类
public static String toCustom(String format, Duration time) {
    long millis = time.toMillis();
    long seconds = time.getSeconds();
    long minutes = time.toMinutes();
    long hours = time.toHours();
    long days = time.toDays();

    String ms = String.valueOf(millis - (seconds * 1000));
    String s = String.valueOf(seconds - (minutes * 60));
    String m = String.valueOf(minutes - (hours * 60));
    String h = String.valueOf(hours - (days * 24));
    String d = String.valueOf(days);

    if (format.contains("s")) {
        int msCount = StringUtils.countMatches(format, 's');
        ms = ms.substring(0, msCount - 1);
    }

    return format.replace("%D", d).replace("%H", h).replace("%M", m).replace("%S", s).replaceAll("%+s*", ms);
}
 

import java.time.Duration; //导入方法依赖的package包/类
@Override
public void onTick(Duration remaining, Duration total) {
    super.onTick(remaining, total);

    if(this.timeLimit.getShow()) {
        long secondsLeft = remaining.getSeconds();
        if(secondsLeft > 30) {
            if(this.shouldBeep()) {
                this.getMatch().playSound(NOTICE_SOUND);
            }
        }
        else if(secondsLeft > 0) {
            // Tick for the last 30 seconds
            this.getMatch().playSound(IMMINENT_SOUND);
        }
        if(secondsLeft == 5) {
            // Play the portal crescendo sound up to the last moment
            this.getMatch().playSound(CRESCENDO_SOUND);
        }
    }
}
 

import java.time.Duration; //导入方法依赖的package包/类
@Override
@SuppressWarnings("deprecation")
public void onTick(Duration remaining, Duration total) {
    super.onTick(remaining, total);

    if(remaining.getSeconds() >= 1 && remaining.getSeconds() <= 3) {
        // Auto-balance runs at match start as well, but try to run it a few seconds in advance
        if(this.tmm != null && !this.autoBalanced) {
            this.autoBalanced = true;
            this.tmm.balanceTeams();
        }
    }

    if(this.tmm != null && !this.autoBalanced && !this.balanceWarningSent && Comparables.lessOrEqual(remaining, BALANCE_WARNING_TIME)) {
        for(Team team : this.tmm.getTeams()) {
            if(team.isStacked()) {
                this.balanceWarningSent = true;
                this.getMatch().sendWarning(new TranslatableComponent("team.balanceWarning", team.getComponentName()), false);
            }
        }

        if(this.balanceWarningSent) {
            this.getMatch().playSound(COUNT_SOUND);
        }
    }
}
 

import java.time.Duration; //导入方法依赖的package包/类
public String format(Duration object) {
    if (object.isZero()) {
        return "0";
    }
    if (Duration.ofDays(object.toDays()).equals(object)) {
        return object.toDays() + "d";
    }
    if (Duration.ofHours(object.toHours()).equals(object)) {
        return object.toHours() + "h";
    }
    if (Duration.ofMinutes(object.toMinutes()).equals(object)) {
        return object.toMinutes() + "m";
    }
    if (Duration.ofSeconds(object.getSeconds()).equals(object)) {
        return object.getSeconds() + "s";
    }
    if (Duration.ofMillis(object.toMillis()).equals(object)) {
        return object.toMillis() + "ms";
    }
    return object.toNanos() + "ns";
}
 

import java.time.Duration; //导入方法依赖的package包/类
@Override
public void beforeEditorTyping(char c, DataContext dataContext) {
    Instant now = Instant.now();
    Duration between = Duration.between(lastInputTime, now);
    lastInputTime = now;

    if (between.getSeconds() < comboCoolTimeSec) {
        comboCount++;
    } else {
        comboCount = 0;
        return;
    }

    RihoReactionNotifier publisher = project.getMessageBus().syncPublisher(RihoReactionNotifier.REACTION_NOTIFIER);
    switch (comboCount) {
        case 5: publisher.reaction(Reaction.of(FacePattern.SMILE1, Duration.ofSeconds(3))); break;
        case 10: publisher.reaction(Reaction.of(FacePattern.SMILE2, Duration.ofSeconds(3))); break;
        case 15: publisher.reaction(Reaction.of(FacePattern.SURPRISE, Duration.ofSeconds(5))); break;
        case 20:
        case 30: publisher.reaction(Reaction.of(FacePattern.AWAWA, Duration.ofSeconds(3))); break;
    }
}
 

import java.time.Duration; //导入方法依赖的package包/类
public static String durationToString(final Duration duration) {
  final long seconds = duration.getSeconds();
  if (seconds < 0) {
    throw new IllegalArgumentException("negative duration");
  }

  return String.format("%dh%dm%ds",
                       seconds / 3600,
                       (seconds % 3600) / 60,
                       seconds % 60);
}
 

import java.time.Duration; //导入方法依赖的package包/类
/**
 * Converts the given duration to a string in the format of "x days hh:mm:ss", "hh:mm:ss", or "x seconds",
 * depending on the amount of time in the duration.
 * @param duration The duration to convert to a string.
 * @return The duration as a string.
 */
public static String getPrettyTime(Duration duration) {
    StringBuilder timeString = new StringBuilder();
    long seconds = duration.getSeconds();
    addDays(duration, timeString);
    addHours(duration, timeString, seconds);
    addMinutesAndSeconds(duration, timeString, seconds);
    return timeString.toString();
}
 

import java.time.Duration; //导入方法依赖的package包/类
public static long toUnit(TemporalUnit unit, Duration duration) {
    switch((ChronoUnit) unit) {
        case NANOS:     return duration.toNanos();
        case MICROS:    return toMicros(duration);
        case MILLIS:    return duration.toMillis();
        case SECONDS:   return duration.getSeconds();
    }

    if(unit.getDuration().getNano() == 0) {
        return duration.getSeconds() / unit.getDuration().getSeconds();
    }

    throw new IllegalArgumentException("Unsupported sub-second unit " + unit);
}
 

import java.time.Duration; //导入方法依赖的package包/类
private void updateTimedEvents() {
    Long now = System.currentTimeMillis();
    Duration timeTick = Duration.ofMillis(now - lastTickSent);
    this.syncProcessor.onTimePassed(timeTick);
    lastTickSent = now;

    //Refresh status to peers every 10 seconds or so
    Duration timeStatus = Duration.ofMillis(now - lastStatusSent);
    if (timeStatus.getSeconds() > 10) {
        sendStatusToAll();
        lastStatusSent = now;
    }
}
 

import java.time.Duration; //导入方法依赖的package包/类
@Override
protected MongoSession convert(Document sessionWrapper) {

	Object maxInterval = sessionWrapper.getOrDefault(MAX_INTERVAL, this.maxInactiveInterval);

	Duration maxIntervalDuration = (maxInterval instanceof Duration)
		? (Duration) maxInterval
		: Duration.parse(maxInterval.toString());

	MongoSession session = new MongoSession(
		sessionWrapper.getString(ID), maxIntervalDuration.getSeconds());

	Object creationTime = sessionWrapper.get(CREATION_TIME);
	if (creationTime instanceof Instant) {
		session.setCreationTime(((Instant) creationTime).toEpochMilli());
	} else if (creationTime instanceof Date) {
		session.setCreationTime(((Date) creationTime).getTime());
	}

	Object lastAccessedTime = sessionWrapper.get(LAST_ACCESSED_TIME);
	if (lastAccessedTime instanceof Instant) {
		session.setLastAccessedTime((Instant) lastAccessedTime);
	} else if (lastAccessedTime instanceof Date) {
		session.setLastAccessedTime(Instant.ofEpochMilli(((Date) lastAccessedTime).getTime()));
	}

	session.setExpireAt((Date) sessionWrapper.get(EXPIRE_AT_FIELD_NAME));
	
	deserializeAttributes(sessionWrapper, session);

	return session;
}
 

import java.time.Duration; //导入方法依赖的package包/类
@Override
public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException {
	if (args.length == 0 || args.length > 1) {
		throw new WrongUsageException("<Owner>");
	}
	
	ForgePlayer forgePlayer = Universe.get().getPlayer(args[0]);
	
	if (forgePlayer == null) {
		throw new CommandException(String.format("There is no player called %s that has been on this server", args[0]));
	}
	
	ForgeTeam team = forgePlayer.getTeam();
	
	if (team == null) {
		throw new CommandException(String.format("Player %s is not in a team", forgePlayer.getName()));
	}
	
	Set<ClaimedChunk> teamClaimedChunks = ClaimedChunks.get().getTeamChunks(team);
	
	if (teamClaimedChunks.isEmpty()) {
		throw new CommandException(String.format("team %s has not claimed any chunks", team.getName()));
	}
	
	ArrayList<PlayerInChunk> playersInChunks = new ArrayList<PlayerInChunk>();
	for (ClaimedChunk claimedChunk : teamClaimedChunks) {
		ChunkDimPos dimPos = claimedChunk.getPos();
		WorldServer world = FMLCommonHandler.instance().getMinecraftServerInstance().getWorld(dimPos.dim);
		Chunk chunk = world.getChunkFromChunkCoords(dimPos.posX, dimPos.posZ);
		ChunkListOfPlayers chunkListOfPlayers = AllChunks.getChunk(chunk);
		if (chunkListOfPlayers == null) {
			continue;
		}
		
		playersInChunks.addAll(chunkListOfPlayers.playersInChunk);
	}
	
	Collections.sort(playersInChunks, new PlayersInChunkListComparator());
	for (PlayerInChunk player : playersInChunks) {
		String playerName = server.getPlayerProfileCache().getProfileByUUID(player.getPlayer()).getName();
		String enterTime = player.getEnterTimeCalendar().format(DateTimeFormatter.ofPattern("u/M/d H:m:s"));
		if (player.hasLeft()) {
			String leaveTime = player.getLeaveTimeCalendar().format(DateTimeFormatter.ofPattern("u/M/d H:m:s"));
			Duration stayTime = player.getStayTime();
			Long years = stayTime.toDays() / 365L;
			Long months = stayTime.toDays() / 30L;
			Long days = stayTime.toDays();
			Long hours = stayTime.toHours();
			Long minutes = stayTime.toMinutes();
			Long seconds = stayTime.getSeconds();
			if (months > 11) {
				months = months - (years * 12);
			}
			if (days > 29) {
				days = days - (days / 30 * 30);
			}
			if (hours > 23) {
				hours = hours - (hours / 24 * 24);
			}
			if (minutes > 59) {
				minutes = minutes - (minutes / 60 * 60);
			}
			if (seconds > 59) {
				seconds = seconds - (seconds / 60 * 60);
			}
			sender.sendMessage(new TextComponentString(String.format("Player %s was in one of the chunks from %s to %s for %s years and %s months and %s days and %s hours and %s minutes and %s seconds.", playerName, enterTime, leaveTime, years, months, days, hours, minutes, seconds)));
		} else {
			sender.sendMessage(new TextComponentString(String.format("Player %s was in one of the chunks from %s and has not left yet", playerName, enterTime)));
		}
	}
}
 

import java.time.Duration; //导入方法依赖的package包/类
LongRunningMessageHandler(@NonNull ScheduledExecutorService timeoutExtensionExecutor,
        int maxNumberOfMessages, int numberOfThreads,
        @NonNull MessageHandlingRunnableFactory messageHandlingRunnableFactory,
        @NonNull VisibilityTimeoutExtenderFactory timeoutExtenderFactory,
        @NonNull MessageWorkerWithHeaders<I, O> worker, @NonNull Queue queue,
        @NonNull FinishedMessageCallback<I, O> finishedMessageCallback,
        @NonNull Duration timeUntilVisibilityTimeoutExtension,
        @NonNull Duration awaitShutDown) {
    if (timeUntilVisibilityTimeoutExtension.isZero() || timeUntilVisibilityTimeoutExtension
            .isNegative()) {
        throw new IllegalArgumentException("the timeout has to be > 0");
    }
    this.timeoutExtensionExecutor = timeoutExtensionExecutor;
    this.messageHandlingRunnableFactory = messageHandlingRunnableFactory;
    this.timeoutExtenderFactory = timeoutExtenderFactory;
    this.worker = worker;
    this.queue = queue;
    this.finishedMessageCallback = finishedMessageCallback;
    this.timeUntilVisibilityTimeoutExtension = timeUntilVisibilityTimeoutExtension;

    messageProcessingExecutor = new ThreadPoolTaskExecutor();
    messageProcessingExecutor.setMaxPoolSize(numberOfThreads);
    messageProcessingExecutor.setCorePoolSize(numberOfThreads);
    /*
     * Since we only accept new messages if one slot in the messagesInProcessing-Set
     * / executor is free we can schedule at least one message for instant execution
     * while (maxNumberOfMessages - 1) will be put into the queue
     */
    messageProcessingExecutor.setQueueCapacity(maxNumberOfMessages - 1);
    messageProcessingExecutor.setAwaitTerminationSeconds((int) awaitShutDown.getSeconds());
    if (awaitShutDown.getSeconds() > 0) {
        Runtime.getRuntime().addShutdownHook(new Thread(messageProcessingExecutor::shutdown));
    }
    messageProcessingExecutor.afterPropertiesSet();

    messagesInProcessing = new SetWithUpperBound<>(numberOfThreads);

    if (queue.getDefaultVisibilityTimeout().minusSeconds(5).compareTo(
            timeUntilVisibilityTimeoutExtension) < 0) {
        throw new IllegalStateException("The extension interval of "
                + timeUntilVisibilityTimeoutExtension.getSeconds()
                + " is too close to the VisibilityTimeout of " + queue
                        .getDefaultVisibilityTimeout().getSeconds()
                + " seconds of the queue, has to be at least 5 seconds less.");
    }
}
 

import java.time.Duration; //导入方法依赖的package包/类
public static String toMultiText(Duration time, boolean isShort) {
    long millis = time.toMillis();
    long seconds = time.getSeconds();
    long minutes = time.toMinutes();
    long hours = time.toHours();
    long days = time.toDays();

    millis = millis - (seconds * 1000);
    seconds = seconds - (minutes * 60);
    minutes = minutes - (hours * 60);
    hours = hours - (days * 24);

    StringBuilder builder = new StringBuilder();

    if (days != 0) {
        builder.append(days);
        if (isShort) builder.append("d");
        else builder.append(" Days");
    }
    if (hours != 0) {
        builder.append(" ");
        builder.append(hours);
        if (isShort) builder.append("h");
        else builder.append(" Hours");
    }
    if (minutes != 0) {
        builder.append(" ");
        builder.append(minutes);
        if (isShort) builder.append("m");
        else builder.append(" Minutes");
    }
    if (seconds != 0) {
        builder.append(" ");
        builder.append(seconds);
        if (isShort) builder.append("s");
        else builder.append(" Seconds");
    }
    if (millis != 0) {
        builder.append(" ");
        builder.append(millis);
        if (isShort) builder.append("ms");
        else builder.append(" Milliseconds");
    }

    return builder.toString().trim();
}
 

import java.time.Duration; //导入方法依赖的package包/类
private static long getMinutes(Duration duration){
	Long totalSecs = duration.getSeconds();
	return (totalSecs % HOUER_CONVERTION) / SECOND_CONVERSION;
}