HOWTO · Java

Subtrair Datas em Java

Este tutorial explica como subtrair duas datas em Java.

Por Rupam YadavPublicado 2021-02-06Atualizado 2023-10-12
Nesta página

Este artigo explica como podemos subtrair duas datas ou obter a diferença entre duas datas em Java.

Utilize java.util.Date para subtrair duas datas em Java

A classe java.text.SimpleDateFormat é utilizada para formatar e analisar as datas de acordo com o padrão especificado. Calculamos o valor absoluto da diferença de tempo entre as duas datas em milissegundos.

O método convert() da classe TimeUnit aceita dois parâmetros, que são duração do tempo e unidade da duração do tempo. Criamos um objecto TimeUnit time e convertemos os milissegundos em dias utilizando o método convert().

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.concurrent.TimeUnit;

public class Main {
  public static void main(String[] args) throws Exception {
    SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy", Locale.ENGLISH);
    Date firstDate = sdf.parse("04/22/2020");
    Date secondDate = sdf.parse("04/27/2020");

    long diff = secondDate.getTime() - firstDate.getTime();

    TimeUnit time = TimeUnit.DAYS;
    long diffrence = time.convert(diff, TimeUnit.MILLISECONDS);
    System.out.println("The difference in days is : " + diffrence);
  }
}

Resultado:

The difference in days is : 5

Utilize java.time.Duration e java.time.Period para Subtrair Duas Datas em Java

A classe Duration mede uma quantidade de tempo em segundos e nanossegundos, enquanto que a classe Period mede o tempo em anos, meses e dias. O método aStartofDay() apresenta a hora da meia-noite como a data local.

Obtemos o objecto Period como a diferença entre duas datas, enquanto obtemos a diferença entre dois instantes como o objecto Duration utilizando o método between(). A Duration é preferida para quantidades de tempo mais curtas.

A duração diff é convertida em dias utilizando o método toDays(). Da mesma forma, podemos obter as unidades de data de período utilizando getYears(), getMonths, e getDays().

import java.time.Duration;
import java.time.LocalDate;
import java.time.Period;
import java.time.format.DateTimeFormatter;

public class Main {
  public static void main(String[] args) throws Exception {
    LocalDate d1 = LocalDate.parse("2020-05-06", DateTimeFormatter.ISO_LOCAL_DATE);
    LocalDate d2 = LocalDate.parse("2020-05-30", DateTimeFormatter.ISO_LOCAL_DATE);

    LocalDate d3 = LocalDate.parse("2018-05-06", DateTimeFormatter.ISO_LOCAL_DATE);
    LocalDate d4 = LocalDate.parse("2020-01-23", DateTimeFormatter.ISO_LOCAL_DATE);

    Duration diff = Duration.between(d1.atStartOfDay(), d2.atStartOfDay());
    Period period = Period.between(d3, d4);

    long diffDays = diff.toDays();
    int years = Math.abs(period.getYears());
    int months = Math.abs(period.getMonths());
    int days = Math.abs(period.getDays());
    System.out.println("Diffrence between dates is : " + diffDays + "days");
    System.out.println(
        "Diffrence is : " + years + " year, " + months + " months, " + days + " days");
  }
}

Resultado:

Diffrence between dates is : 24days
Diffrence is : 1 year, 8 months, 17 days

Utilize java.time.temporal.ChronoUnit para subtrair duas datas em Java

Em Java 8, o Time API representa uma unidade de data e hora utilizando a interface TemporalUnit. Cada unidade fornece uma implementação do método denominado between(). Este método calcula a quantidade de tempo entre dois objectos temporais.

A ChronoUnit é o array padrão de unidades de data e hora que fornece acesso com base na unidade para manipular uma data, hora, ou data e hora.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class Main {
  public static void main(String[] args) throws Exception {
    LocalDate dBefore = LocalDate.parse("2018-05-06", DateTimeFormatter.ISO_LOCAL_DATE);
    LocalDate dAfter = LocalDate.parse("2018-05-30", DateTimeFormatter.ISO_LOCAL_DATE);

    long diff = ChronoUnit.DAYS.between(dBefore, dAfter);
    System.out.println("difference is : " + diff);
  }
}

Resultado:

difference is : 24

Utilize java.time.temporal.Temporal until() subtrair duas datas em Java

O método until() calcula a quantidade de tempo até outro tempo em termos da unidade especificada. O resultado será negativo se o fim for antes do início.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;

public class Main {
  public static void main(String[] args) throws Exception {
    LocalDate dBefore = LocalDate.parse("2018-05-21", DateTimeFormatter.ISO_LOCAL_DATE);
    LocalDate dAfter = LocalDate.parse("2018-05-30", DateTimeFormatter.ISO_LOCAL_DATE);

    long diff = dBefore.until(dAfter, ChronoUnit.DAYS);
    System.out.println("difference is : " + diff + " days");
  }
}

Resultado:

difference is : 9 days

Sobre o autor

Rupam Yadav

Rupam Saini is an android developer, who also works sometimes as a web developer., He likes to read books and write about various things.

Ver perfil do autor
LinkedIn