Existem muitas maneiras de comparar duas datas na linguagem de programação Java. Em computadores, uma data é representada por um número (o tipo de dados Longo) em unidades de tempo - ou seja, o número de milissegundos decorridos desde 1º de janeiro de 1970. Em Java, Data é um objeto, o que significa que tem vários métodos para fazer comparações. Qualquer método usado para comparar duas datas é essencialmente comparar as unidades de tempo das duas datas.
Etapa
Método 1 de 4: usando compareTo
Etapa 1. Use compareTo
O objeto Date implementa Comparable para que 2 datas possam ser comparadas entre si diretamente com o método compareTo. Se ambas as datas tiverem o mesmo número em unidades de tempo, o método retornará zero. Se a segunda data for menor que a primeira, um valor menor que zero será retornado. Se a segunda data for maior que a primeira, o método retornará um valor maior que zero. Se as duas datas forem iguais, o método retornará um valor nulo.
Etapa 2. Crie vários objetos Date
Você deve criar vários objetos Date antes de compará-los. Uma das maneiras mais fáceis de fazer isso é usar a classe SimpleDateFormat. Essa classe facilita a conversão de um valor de data de entrada em um objeto Date.
SimpleDateFormat sdf = new SimpleDateFormat ("aaaa-MM-dd"). Para declarar um valor em uma nova '' Data do Objeto '', use o mesmo formato de data ao criar a data. Data data1 = sdf.parse ("1995-02-23"); // data1 é 23 de fevereiro de 1995 Data date2 = sdf.parse ("2001-10-31"); // data2 é 31 de outubro de 2001 Data date3 = sdf.parse ("1995-02-23"); // data 3 é 23 de fevereiro de 1995
Etapa 3. Compare os objetos Date
O código a seguir mostrará exemplos para cada caso - menor que, igual e maior que.
date1.compareTo (date2); // data1 <data2, retorna um valor menor que 0 date2.compareTo (data1); // data2> data1, retorna um valor maior que 0 date1.compareTo (date3); // data1 = data3, então a saída será 0 no console
Método 2 de 4: usando igual, depois e antes
Etapa 1. Use igual, antes e depois
As datas podem ser comparadas usando os métodos equals, after e before. Se duas datas tiverem o mesmo valor no tempo, o método equals retornará verdadeiro. O exemplo a seguir usará o objeto Date criado no método compareTo de exemplo.
Etapa 2. Compare com o método anterior
O código a seguir mostra um caso de exemplo que retorna verdadeiro e falso. Se date1 for uma data anterior a date2, o método before retorna true. Caso contrário, o método before retorna false.
System.out.print (date1.before (date2)); // exibe o valor '' true '' System.out.print (date2.before (date2)); // retorna o valor '' falso ''
Etapa 3. Compare usando o método depois
O código a seguir mostra um caso de exemplo que retorna verdadeiro e falso. Se data2 for a data posterior a data1, o método posterior retornará verdadeiro. Caso contrário, o método after retornará false.
System.out.print (date2.after (date1)); // exibe o valor '' true '' System.out.print (date1.after (date2)); // exibe o valor '' false ''
Etapa 4. Compare com o método de igualdade
O código a seguir mostra um caso de exemplo que retorna verdadeiro e falso. Se as duas datas forem iguais, o método equals retorna verdadeiro. Caso contrário, o método equals retorna falso.
System.out.print (date1.equals (date3)); // exibe o valor '' true '' System.out.print (date1.equals (date2)); // exibe o valor '' false ''
Método 3 de 4: usando o calendário da turma
Etapa 1. Use o calendário da aula
A classe Calendar também possui métodos compareTo, equals, after e before que funcionam da mesma forma que os descritos anteriormente para a classe Date. Portanto, se as informações de data estiverem armazenadas em um calendário de aula, você não precisa extrair a data apenas para fazer uma comparação.
Etapa 2. Crie uma instância do Calendário
Para usar métodos no calendário da classe, você deve criar várias instâncias do calendário. Felizmente, você pode usar os valores de uma instância de Date criada anteriormente.
Calendário cal1 = Calendar.getInstance (); // declara cal1 Calendar cal2 = Calendar.getInstance (); // declara cal2 Calendar cal3 = Calendar.getInstance (); // declara cal3 cal1.setTime (date1); // coloque a data em cal1 cal2.setTime (date2); cal3.setTime (date3);
Etapa 3. Compare cal1 e cal2 usando o método anterior
O código a seguir irá gerar o valor de tr
System.out.print (cal1.before (cal2)); // retornará o valor '' true ''
Etapa 4. Compare cal1 e cal2 usando o método posterior
O código a seguir retornará falso porque cal1 é a data anterior a cal2.
System.out.print (cal1.after (cal2)); // retorna o valor '' falso ''
Etapa 5. Compare cal1 e cal2 usando o método equals
O código a seguir mostrará um caso de exemplo que retorna verdadeiro e falso. O estado depende da instância do Calendar que está sendo comparada. O código a seguir retornará o valor "true" e, em seguida, "false" na próxima linha.
System.out.println (cal1.equals (cal3)); // retorna o valor '' true '': cal1 == cal3 System.out.print (cal1.equals (cal2)); // retorna o valor '' falso '': cal1! = cal2
Método 4 de 4: usando getTime
Etapa 1. Use getTime
Você também pode comparar diretamente os valores da unidade de tempo de duas datas, embora os dois métodos anteriores possam ser mais fáceis de ler e preferíveis. Desta forma, você comparará 2 tipos de dados primitivos, para que possa usar os operandos "" e "==".
Etapa 2. Crie um objeto de hora no formato de número longo
Antes de comparar as datas, você deve criar um valor Inteiro longo a partir do objeto Date criado anteriormente. Felizmente, o método getTime () fará isso por você.
longo tempo1 = getTime (data1); // declara o tempo1 primitivo de data1 longo tempo2 = getTime (data2); // declara o valor de time2 primitivo de data2
Etapa 3. Faça uma comparação inferior
Use o operando menor que (<) para comparar esses dois valores inteiros. Como o tempo1 é menor que o tempo2, a primeira mensagem aparecerá. A instrução else é incluída para completar a sintaxe.
if (hora1 <hora2) {System.out.println ("data1 é a data anterior à data2"); // mostrará porque time1 <time2} else {System.out.println ("date1 não é uma data anterior a date2"); }
Etapa 4. Faça uma comparação maior que
Use o operando maior que (>) para comparar esses dois valores inteiros. Como time1 é maior que time2, a primeira mensagem aparecerá. A instrução else é incluída para completar a sintaxe.
if (hora2> hora1) {System.out.println ("data2 é a data depois da data1"); // mostrará porque hora2> hora1} else {System.out.println ("a data2 não é a data após a data1"); }
Etapa 5. Faça uma comparação de igual
Use a função operando para verificar a igualdade dos valores (==) para comparar esses dois inteiros. Visto que time1 é igual a time3, a primeira mensagem aparecerá. Se o fluxo do programa for para a instrução else, significa que os dois tempos não têm o mesmo valor.
if (time1 == time2) {System.out.println ("ambas as datas são iguais"); } else {System.out.println ("O primeiro não é igual ao segundo"); // mostrará porque time1! = time2}
