Hacer un temporizador de cuenta regresiva en Java

1. Temporizador de cuenta regresiva en Java usando ScheduledExecutorService
2. Temporizador de cuenta regresiva en Java usando Timer y TimerTask

Hoy, demostraremos cómo puede hacer un temporizador de cuenta regresiva en Java usando dos métodos sin depender de ninguna biblioteca de terceros. Podemos usar el temporizador en una ventana GUI o la consola solo para probarlo. ¡Mira los códigos que tenemos a continuación!

Temporizador de cuenta regresiva en Java usando ScheduledExecutorService

En este primer método, usamos la interfaz ExecutorService para llamar a su método newScheduledThreadPool(), que crea un grupo de subprocesos que utiliza el mismo número fijo de subprocesos asignados. En el método newScheduledThreadPool(), pasamos el número de subprocesos que queremos en el grupo. En este caso, queremos que solo un hilo ejecute el temporizador.

La función Executors.newScheduledThreadPool() devuelve un objeto ScheduledExecutorService que llamamos scheduler. A continuación, anulamos el método run() de la interfaz Runnable. Se utiliza una instancia Runnable para ejecutar el hilo. En Runnable, creamos una variable countdownStarter y la inicializamos con el número en segundos desde donde queremos iniciar el temporizador de cuenta regresiva.

Ahora, dentro del método run(), imprimimos countdownStarter y disminuimos su valor en uno. Para detener el temporizador cuando llega a cero, creamos una condición para verificar el valor de countdownStarter. Si su valor llega a ser menor que cero, imprime un mensaje y apaga el scheduler, que es el Servicio Ejecutor utilizando el comando scheduler.shutdown().

Por último, usamos el objeto scheduler para llamar al método scheduleAtFixedRate() que ejecuta la acción dada periódicamente y toma cuatro argumentos. El primer argumento es la instancia runnable; el segundo es el retraso de tiempo en la primera ejecución; el tercero es el retraso entre acciones. Aquí, dimos el retraso como uno que debería ser igual a un segundo, como sugiere el cuarto 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);
  }
}

Producción :

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

Temporizador de cuenta regresiva en Java usando Timer y TimerTask

En este ejemplo, usamos dos clases, Timer y TimerTask, que vienen con el paquete java.util. Ambas clases se utilizan para programar tareas para su ejecución en el hilo de fondo. Para este ejemplo, usamos el objeto jFrame para mostrar el temporizador en una ventana GUI. Primero, creamos un objeto jFrame, luego un jLabel que muestra el texto del temporizador. Establecemos el diseño del marco como FlowLayout() y establecemos la posición y el tamaño de la ventana.

A continuación, agregamos el jLabel al marco. Para crear el temporizador de cuenta atrás, creamos un objeto Timer y llamamos a su método scheduleAtFixedRate(), que programa y repite la tarea especificada a una velocidad fija, como sugiere el nombre.

Ahora, como el compañero scheduleAtFixedRate() toma un objeto TimerTask como su primer argumento, creamos un objeto usando new TimerTask(). Para el segundo y tercer argumento, programan la tarea a ejecutar y el período en milisegundos entre cada ejecución.

Para el siguiente paso, necesitamos crear una variable e inicializarla con el número con el que queremos comenzar la cuenta atrás. Luego, llamamos al método run() y establecemos el texto del componente jLabel como i. Para detener el temporizador, llamamos 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);
  }
}

Producción: