Faça um cronômetro de contagem regressiva em Java

1. Temporizador de contagem regressiva em Java usando ScheduledExecutorService
2. Timer de contagem regressiva em Java usando Timer e TimerTask

Hoje, vamos demonstrar como você pode fazer uma contagem regressiva em Java usando dois métodos sem depender de nenhuma biblioteca de terceiros. Podemos usar o cronômetro em uma janela GUI ou o console apenas para testá-lo. Confira os códigos que temos abaixo!

Temporizador de contagem regressiva em Java usando ScheduledExecutorService

Neste primeiro método, usamos a interface ExecutorService para chamar seu método newScheduledThreadPool(), que cria um pool de threads que usa o mesmo número fixo de threads atribuídas. No método newScheduledThreadPool(), passamos o número de threads que queremos no pool. Nesse caso, queremos apenas um encadeamento para executar o cronômetro.

A função Executors.newScheduledThreadPool() retorna um objeto ScheduledExecutorService que denominamos scheduler. Em seguida, substituímos o método run() da interface Runnable. Uma instância Runnable é usada para executar a thread. Em Runnable, criamos uma variável countdownStarter e a inicializamos com o número em segundos de onde queremos iniciar a contagem regressiva.

Agora, dentro do método run(), imprimimos countdownStarter e diminuímos seu valor em um. Para parar o cronômetro quando chegar a zero, criamos uma condição para verificar o valor countdownStarter. Se seu valor se tornar menor que zero, ele imprime uma mensagem e fecha o planejador, que é o Serviço Executor usando o comando scheduler.shutdown().

Por fim, usamos o objeto scheduler para chamar o método scheduleAtFixedRate() que executa a ação fornecida periodicamente e recebe quatro argumentos. O primeiro argumento é a instância runnable; o segundo é o atraso de tempo na primeira execução; o terceiro é o atraso entre as ações. Aqui, atribuímos ao atraso um valor que deve ser igual a um segundo, como sugere o quarto argumento.

import static java.util.concurrent.TimeUnit.SECONDS;

import java.util.concurrent.*;

public class Countdown {
  public static void main(String[] args) {
    final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    final Runnable runnable = new Runnable() {
      int countdownStarter = 20;

      public void run() {
        System.out.println(countdownStarter);
        countdownStarter--;

        if (countdownStarter < 0) {
          System.out.println("Timer Over!");
          scheduler.shutdown();
        }
      }
    };
    scheduler.scheduleAtFixedRate(runnable, 0, 1, SECONDS);
  }
}

Resultado:

20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
Timer Over!

Timer de contagem regressiva em Java usando Timer e TimerTask

Neste exemplo, usamos duas classes, Timer e TimerTask, que vêm com o pacote java.util. Ambas as classes são usadas para agendar tarefas para execução no thread de segundo plano. Para este exemplo, usamos o objeto jFrame para mostrar o cronômetro em uma janela GUI. Primeiro, criamos um objeto jFrame, depois um jLabel que mostra o texto do temporizador. Definimos o layout do quadro como FlowLayout() e definimos a posição e o tamanho da janela.

Em seguida, adicionamos o jLabel ao quadro. Para criar o cronômetro de contagem regressiva, criamos um objeto Timer e chamamos seu método scheduleAtFixedRate(), que agenda e repete a tarefa especificada em uma taxa fixa, como o nome sugere.

Agora, como o mate scheduleAtFixedRate() leva um objeto TimerTask como seu primeiro argumento, criamos um objeto usando new TimerTask(). Para o segundo e terceiro argumentos, eles programam a tarefa a ser executada e o período em milissegundos entre cada execução.

Para a próxima etapa, precisamos criar uma variável e inicializá-la com o número com o qual queremos iniciar a contagem regressiva. Em seguida, chamamos o método run() e definimos o texto do componente jLabel como i. Para parar o cronômetro, chamamos timer.cancel().

import java.awt.*;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.*;

public class Countdown {
  public static void main(String[] args) {
    JFrame jframe = new JFrame();
    JLabel jLabel = new JLabel();
    jframe.setLayout(new FlowLayout());
    jframe.setBounds(500, 300, 400, 100);

    jframe.add(jLabel);
    jframe.setVisible(true);

    Timer timer = new Timer();

    timer.scheduleAtFixedRate(new TimerTask() {
      int i = 20;

      public void run() {
        jLabel.setText("Time left: " + i);
        i--;

        if (i < 0) {
          timer.cancel();
          jLabel.setText("Time Over");
        }
      }
    }, 0, 1000);
  }
}

Resultado: