Diferença entre datas

Senhor google precisamos de você AQUI! :lol:

Seguinte velhinho tava dando uma olhada na API do java… aconselho a fazer o mesmo… Pra tirar de vez a dúvida mas eu acho que o método que vc precisa é este:

roll(int field, boolean up) da classe GregorianCalendar…

Mas da uma lida na API pra ver bem oque vc precisa e ver se o método vai ser realmente útil o que ele faz é basicamente uma subtração ou adição conforme o parametro ‘up’ …

Beleza !!! espero ter ajudado…

ola #@®®¡$

faca o seguinte
chame o metodo getTime ou getTimeInMillis, pega o tempo em milisegundos de cada um.
ai substrai um pelo outro

o que sobrar, voce divide por 246060*1000, que é quantidade de milisegundos em um dia.

Na verdade eu procurei tanto no google quanto na API :roll:

O roll seria válido se eu quisesse subtrair/adicionar uma quantidade específica a um certo campo sem considerar os outros da data. Não é isso o que eu quero, uma vez que eu quero tirar a diferença entre duas datas.

Na verdade, eu queria saber se existe alguma classe que já tinha esse método logo de cara, mas só achei as 3 classes que citei na API e nenhuma delas tinha nada disso… :roll:

Resultado: Fazer minha própria classe :twisted:

EDITADO: Paulo, valeu, eu estava tentando me virar aqui e vi algo parecido usando o SimpleDateFormat.parse(String) e já estava fazendo… vou fazer a tal classe e colocar isso lá.

A pedidos, achei meu codigo, ta ai

/**
     * Método para comparar as das e retornar o numero de dias de diferença entre elas
     *
     * Compare two date and return the difference between them in days.
     *
     * @param dataLow The lowest date
     * @param dataHigh The highest date
     *
     * @return int
     */
    public static int dataDiff(java.util.Date dataLow, java.util.Date dataHigh){

        GregorianCalendar startTime = new GregorianCalendar();
        GregorianCalendar endTime = new GregorianCalendar();
        
        GregorianCalendar curTime = new GregorianCalendar();
        GregorianCalendar baseTime = new GregorianCalendar();

        startTime.setTime(dataLow);
        endTime.setTime(dataHigh);
        
        int dif_multiplier = 1;
        
        // Verifica a ordem de inicio das datas
        if( dataLow.compareTo( dataHigh ) < 0 ){
            baseTime.setTime(dataHigh);
            curTime.setTime(dataLow);
            dif_multiplier = 1;
        }else{
            baseTime.setTime(dataLow);
            curTime.setTime(dataHigh);
            dif_multiplier = -1;
        }
        
        int result_years = 0;
        int result_months = 0;
        int result_days = 0;

        // Para cada mes e ano, vai de mes em mes pegar o ultimo dia para import acumulando
        // no total de dias. Ja leva em consideracao ano bissesto
        while( curTime.get(GregorianCalendar.YEAR) < baseTime.get(GregorianCalendar.YEAR) ||
               curTime.get(GregorianCalendar.MONTH) < baseTime.get(GregorianCalendar.MONTH)  )
        {
            
            int max_day = curTime.getActualMaximum( GregorianCalendar.DAY_OF_MONTH );
            result_months += max_day;
            curTime.add(GregorianCalendar.MONTH, 1);
            
        }
        
        // Marca que é um saldo negativo ou positivo
        result_months = result_months*dif_multiplier;
        
        
        // Retirna a diferenca de dias do total dos meses
        result_days += (endTime.get(GregorianCalendar.DAY_OF_MONTH) - startTime.get(GregorianCalendar.DAY_OF_MONTH));
        
        return result_years+result_months+result_days;
    }

Sem agradecimentos. Deposito somente em conta corrente, por favor… :shock:

rsssssss… 8)

JAVAALMANAC

http://javaalmanac.com/egs/java.util/CompDates.html

Edilson S. de Souza
www.javalinux.com.br

Tutorial no GUJ.

http://www.guj.com.br/servlet/guj?MAMUTE_ACTION=br.com.guj.action.ListTutorial&MAMUTE_TEMPLATE=ListTutorial&LIST_TUTORIAL_GROUP_BY_CATEGORY=true

Edilson S. de Souza
www.javalinux.com.br

tem aqui também:
http://www.javafree.com.br/forum/viewtopic.php?p=25228#25228

brlima,
poderia por favor disponiblizar a conta, agencia para depósito do valor???
kkkkkk
valew cara, me poupou um tempao aq quebrando a cabeça nisso.

http://www.guj.com.br/posts/list/0/16631.java#396801

brlima:

A pedidos, achei meu codigo, ta ai

/**
     * Método para comparar as das e retornar o numero de dias de diferença entre elas
     *
     * Compare two date and return the difference between them in days.
     *
     * @param dataLow The lowest date
     * @param dataHigh The highest date
     *
     * @return int
     */
    public static int dataDiff(java.util.Date dataLow, java.util.Date dataHigh){

        GregorianCalendar startTime = new GregorianCalendar();
        GregorianCalendar endTime = new GregorianCalendar();
        
        GregorianCalendar curTime = new GregorianCalendar();
        GregorianCalendar baseTime = new GregorianCalendar();

        startTime.setTime(dataLow);
        endTime.setTime(dataHigh);
        
        int dif_multiplier = 1;
        
        // Verifica a ordem de inicio das datas
        if( dataLow.compareTo( dataHigh ) < 0 ){
            baseTime.setTime(dataHigh);
            curTime.setTime(dataLow);
            dif_multiplier = 1;
        }else{
            baseTime.setTime(dataLow);
            curTime.setTime(dataHigh);
            dif_multiplier = -1;
        }
        
        int result_years = 0;
        int result_months = 0;
        int result_days = 0;

        // Para cada mes e ano, vai de mes em mes pegar o ultimo dia para import acumulando
        // no total de dias. Ja leva em consideracao ano bissesto
        while( curTime.get(GregorianCalendar.YEAR) < baseTime.get(GregorianCalendar.YEAR) ||
               curTime.get(GregorianCalendar.MONTH) < baseTime.get(GregorianCalendar.MONTH)  )
        {
            
            int max_day = curTime.getActualMaximum( GregorianCalendar.DAY_OF_MONTH );
            result_months += max_day;
            curTime.add(GregorianCalendar.MONTH, 1);
            
        }
        
        // Marca que é um saldo negativo ou positivo
        result_months = result_months*dif_multiplier;
        
        
        // Retirna a diferenca de dias do total dos meses
        result_days += (endTime.get(GregorianCalendar.DAY_OF_MONTH) - startTime.get(GregorianCalendar.DAY_OF_MONTH));
        
        return result_years+result_months+result_days;
    }

Sem agradecimentos. Deposito somente em conta corrente, por favor… :shock:

rsssssss… 8)

Olá BrLima, beleza?
Estava olhando este seu método e verifiquei que a variável result_years só é utilizada no retorno e
com valor zerado (Zero). E somar zero ao restante não faz diferença. Certo?

O que tem de errado, ou faltou algo?

Neste trecho abaixo:
// Marca que é um saldo negativo ou positivo
result_months = result_months*dif_multiplier;

porque vc não usou assim?
// Marca que é um saldo negativo ou positivo
result_months *= dif_multiplier;

Atenciosamente,
Jesus

Boa noite JavaBoys, me deparei com a mesma dúvida sobre como obter a diferença entre duas datas diferentes e vi que vocês utilizam um código complexo desnecessariamente, sendo assim segue minha contribuição:

/**
	 * Calcula a diferença de duas datas em dias
	 * <br>
	 * <b>Importante:</b> Quando realiza a diferença em dias entre duas datas, este método considera as horas restantes e as converte em fração de dias.
	 * @param dataInicial
	 * @param dataFinal
	 * @return quantidade de dias existentes entre a dataInicial e dataFinal.
	 */
	public static double diferencaEmDias(Date dataInicial, Date dataFinal){
		double result = 0;
		long diferenca = dataFinal.getTime() - dataInicial.getTime();
		double diferencaEmDias = (diferenca /1000) / 60 / 60 /24; //resultado é diferença entre as datas em dias
		long horasRestantes = (diferenca /1000) / 60 / 60 %24; //calcula as horas restantes
		result = diferencaEmDias + (horasRestantes /24d); //transforma as horas restantes em fração de dias
	
		return result;
	}
	
	/**
	 * Calcula a diferença de duas datas em horas
	 * <br>
	 * <b>Importante:</b> Quando realiza a diferença em horas entre duas datas, este método considera os minutos restantes e os converte em fração de horas.
	 * @param dataInicial
	 * @param dataFinal
	 * @return quantidade de horas existentes entre a dataInicial e dataFinal.
	 */
	public static double diferencaEmHoras(Date dataInicial, Date dataFinal){
		double result = 0;
		long diferenca = dataFinal.getTime() - dataInicial.getTime();
		long diferencaEmHoras = (diferenca /1000) / 60 / 60;
		long minutosRestantes = (diferenca / 1000)/60 %60;
		double horasRestantes = minutosRestantes / 60d;
		result = diferencaEmHoras + (horasRestantes);
		
		return result;
	}
	
	/**
	 * Calcula a diferença de duas datas em minutos
	 * <br>
	 * <b>Importante:</b> Quando realiza a diferença em minutos entre duas datas, este método considera os segundos restantes e os converte em fração de minutos.
	 * @param dataInicial
	 * @param dataFinal
	 * @return quantidade de minutos existentes entre a dataInicial e dataFinal.
	 */
	public static double diferencaEmMinutos(Date dataInicial, Date dataFinal){
		double result = 0;
		long diferenca = dataFinal.getTime() - dataInicial.getTime();
		double diferencaEmMinutos = (diferenca /1000) / 60; //resultado é diferença entre as datas em minutos
		long segundosRestantes = (diferenca / 1000)%60; //calcula os segundos restantes
		result = diferencaEmMinutos + (segundosRestantes /60d); //transforma os segundos restantes em minutos
	
		return result;
	}

Os métodos acima são autoexplicativos, mas caso não entendam estou à disposição para retirar vossas dúvidas.

confundi aqui, janeiro é o mês 0 rsrsrs agora tá tudo certo

Encontrei aqui no google mesmo uma solução creio que a mais rápida!!

public static void main(String[] args) {   
      SimpleDateFormat sdf = new SimpleDateFormat("dd/mm/yyyy");   
      try {   
         Date date1 = sdf.parse("05/09/2003");   
         Date date2 = sdf.parse("06/09/2003");   
         long differenceMilliSeconds = date2.getTime() - date1.getTime();   
         System.out.println("diferenca em milisegundos: " + differenceMilliSeconds);    
         System.out.println("diferenca em segundos: " + (differenceMilliSeconds/1000));    
         System.out.println("diferenca em minutos: " + (differenceMilliSeconds/1000/60));    
         System.out.println("diferenca em horas: " + (differenceMilliSeconds/1000/60/60));    
         System.out.println("diferenca em dias: " + (differenceMilliSeconds/1000/60/60/24));    
      } catch (ParseException e) {   
         e.printStackTrace();   
      }   
   }

Ola pessoal poderiam me dizer o que seria o 1000, os dois 60 e o 24 no trecho do codigo do amigo José Castilho??

double diferencaEmDias = (diferenca /1000) / 60 / 60 /24;

Obrigado pela atenção!

Solução muito boa! 8)

Ou se preferir ainda usar uma api, pode usa a o joda-time, ela tem algumas classes como Days, com métodos tais daysBetween(arg1, arg2) que retorna um objeto Days, apartir dele tu consegue informações como getDays() que retorna a quantidade de dias de diferença entre eles, ou o método toStandardHours() que retorna um objeto Hours que também possui um método getHours() que retorna a quantidade de horas entre os pontos

Bom, curti mais um otro jeito ake… não é AQUELA coisa, mas no meu caso ( calcular a idade de um pessoa dados dia mes e ano de nascimento ).
Espero que seja útil

public static int calculaIdade (int diaNasc, int mesNasc, int anoNasc) {
		
		Calendar calendar = GregorianCalendar.getInstance();
		calendar.set(anoNasc, mesNasc-1, diaNasc);
		
		Date diaHoje = new Date();
		Date diaNiver = calendar.getTime();
		
		calendar.setTimeInMillis(diaHoje.getTime() - diaNiver.getTime());
		
		return calendar.get(Calendar.YEAR) - 1970 ;
	}

//import org.apache.commons.lang.time.DateFormatUtils;

/**
	 * Calcula o tempo de execução em relação à data atual e a data de execução.
	 * Retorna a concatenação das diferenças entre as horas, minutos e segundos.
	 * 
	 * @return String hora:min:sec
	 */
	private String calculaTempoExecucao() {
	
		long timeAtual = new java.util.Date().getTime();
		long timeExecucao = process.getDtHrExecucao().getTime();

		String tempoExecucao = DateFormatUtils.formatUTC(timeAtual - timeExecucao, "HH:mm:ss");
		return tempoExecucao;
	}

O problema era recuperar as datas no formato UTC, ou seja, no Java a data inicial é 01/01/1970, o que sem zerar esta data o retorno, a diferença, era relativa ao ano de 1969.

Bizarro, mas aconteceu.
Espero que ajudem.
Esta solução tem a colaboração de um amigo, Carioca Man.
Vulgo: Felipe

:thumbup: :thumbup: :thumbup: :thumbup:

Att.
Jesus

Algum motivo para estar reinventado a roda?
Seria para utilizar as classes do Java mesmo ou desconhece a API Joda Time como foi citada?

Muito simples de se trabalhar e faz exatamente o que você precisa.
Podes calcular para você diferença de meses, dias, horas, minutos, segundos…

Abraços.

Boa Menino Jesus!Não deixa o mané ai te zoar não!

Utilzar uma API externa nem sempre é a melhor solução. Pode até ser desconhecimento da API JodaTime, mas o cara que usa uma API dessa tem o desconhecimento da linguagem Java :). Usa uma API com 1000coisas e usar so 1 é desnecessário. basta fazer isso:

long dias = (dataMaior.getTime() - dataMenor.getTime()) / 1000 / 60 / 60 / 24;

Quem quer saber o q é os 1000, 60 e 24 é so rever a thread q o Paulo Silveira explica isso no começo.

Fala Pessoal, boa noite a todos,

Amigos utilizei a solução do amigo jimmyhc mas estou enfrentando um problema e espero que possam me ajudar, vejam o meu código:

String dtObito	=	request.getParameter("dataobito").toString();

SimpleDateFormat sdf = new SimpleDateFormat("dd/mm/yyyy");     

try {     
   Date date2 = new Date();
   System.out.println(date2);
   Date date1 = (java.util.Date)sdf.parse(dtObito);
   System.out.println(date1);
   System.out.println(dtObito);
   
   long differenceMilliSeconds = date2.getTime() - date1.getTime();     
   System.out.println("diferenca em milisegundos: " + differenceMilliSeconds);      
   System.out.println("diferenca em segundos: " + (differenceMilliSeconds/1000));      
   System.out.println("diferenca em minutos: " + (differenceMilliSeconds/1000/60));      
   System.out.println("diferenca em horas: " + (differenceMilliSeconds/1000/60/60));      
   System.out.println("diferenca em dias: " + (differenceMilliSeconds/(1000*60*60*24)));      
} catch (RuntimeException e) {     
   e.printStackTrace();     
}

Esta é a minha saida:

Fri Jun 15 17:45:37 BRT 2012 Tue Jan 10 00:06:00 BRST 2012 10/06/2012 diferenca em milisegundos: [telefone removido] diferenca em segundos: 13631977 diferenca em minutos: 227199 diferenca em horas: 3786 diferenca em dias: 157

Reparem que a data que informo no formulário anterior é "10/06/2012", ou seja este é o valor do meu request.getParameter("dataobito")
Se mando pro console o conteúdo da variável vai certo (String)...
Se faço o cast muda para outra data (2ª linha da saída no console)

O que estou fazendo de errado? Alguma "luz".

Até mais...