Como converter TimeStamp to Date em Java?

Como faço para converter ‘timeStamp’ para date depois de obter a contagem em java?

Meu código atual é o seguinte:

 public class GetCurrentDateTime { public int data() { int count = 0; java.sql.Timestamp timeStamp = new Timestamp(System.currentTimeMillis()); java.sql.Date date = new java.sql.Date(timeStamp.getTime()); System.out.println(date); //count++; try { Class.forName("com.mysql.jdbc.Driver"); Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/pro", "root", ""); PreparedStatement statement = con.prepareStatement("select * from orders where status='Q' AND date=CURDATE()"); ResultSet result = statement.executeQuery(); while (result.next()) { // Do something with the row returned. count++; //if the first col is a count. } } catch (Exception exc) { System.out.println(exc.getMessage()); } return count; } } 

Esta é minha base de dados: insira a descrição da imagem aqui

Aqui a saída que recebi foi 2012-08-07 0, mas a consulta equivalente retorna 3. Por que recebo 0?

Basta criar um novo object Date com o valor getTime() do carimbo como um parâmetro.

Aqui está um exemplo (eu uso um timestamp de exemplo da hora atual):

 Timestamp stamp = new Timestamp(System.currentTimeMillis()); Date date = new Date(stamp.getTime()); System.out.println(date); 
 // timestamp to Date long timestamp = 5607059900000; //Example -> in ms Date d = new Date(timestamp ); // Date to timestamp long timestamp = d.getTime(); //If you want the current timestamp : Calendar c = Calendar.getInstance(); long timestamp = c.getTimeInMillis(); 

Somente:

 Timestamp timestamp = new Timestamp(long); Date date = new Date(timestamp.getTime()); 

Primeiro de tudo, você não está aproveitando a vantagem de usar um PreparedStatement . Primeiramente, sugiro que você modifique seu PreparedStatement seguinte maneira:

 PreparedStatement statement = con.prepareStatement("select * from orders where status=? AND date=?") 

Você pode então usar statement.setXX(param_index, param_value) para definir os respectivos valores. Para conversão para timestamp , dê uma olhada nos seguintes javadocs:

PreparedStatement.setTimeStamp ()
Timestamp

Espero que isto ajude!

Não tenho certeza do que você está tentando selecionar na consulta, mas tenha em mente que UNIX_TIMESTAMP() sem argumentos retorna a hora agora. Você provavelmente deve fornecer um tempo válido como argumento ou alterar a condição.

EDITAR:

Aqui está um exemplo de uma consulta com limite de tempo com base na pergunta:

 PreparedStatement statement = con .prepareStatement("select * from orders where status='Q' AND date > ?"); Date date = new SimpleDateFormat("dd/MM/yyyy").parse("01/01/2000"); statement.setDate(1, new java.sql.Date(date.getTime())); 

EDIT: coluna de registro de data e hora

Em caso de registro de data e hora, use java.sql.Timestamp e PreparedStatement.setTimestamp () , ou seja:

 PreparedStatement statement = con .prepareStatement("select * from orders where status='Q' AND date > ?"); Date date = new SimpleDateFormat("dd/MM/yyyy").parse("01/01/2000"); Timestamp timestamp = new Timestamp(date.getTime()); statement.setTimestamp(1, timestamp); 

new Date(timestamp.getTime()) deve funcionar, mas o novo jeitão do Java 8 (que pode ser mais elegante e mais seguro, assim como ajudar você a usar as novas classs de tempo) é chamar Date.from(timestamp.toInstant()) .

(Não confie no fato de que o Timestamp si é uma instância de Date ; veja a explicação nos comentários de outra resposta .)

  Timestamp tsp = new Timestamp(System.currentTimeMillis()); java.util.Date dateformat = new java.util.Date(tsp.getTime()); 

No Android é muito simples. Basta usar a class Calender para obter currentTimeMillis.

 Timestamp stamp = new Timestamp(Calendar.getInstance().getTimeInMillis()); Date date = new Date(stamp.getTime()); Log.d("Current date Time is " +date.toString()); 

Em Java apenas use System.currentTimeMillis () para obter o timestamp atual

Eu tenho procurado por isso desde há muito tempo, acontece que o conversor Eposh faz isso facilmente:

 long epoch = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970 01:00:00").getTime() / 1000; 

Ou o oposto:

 String date = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(new java.util.Date (epoch*1000)); 

tl; dr

 LocalDate.now( ZoneId.of( "Africa/Tunis" ) ) .atStartOfDay( ZoneId.of( "Africa/Tunis" ) ) .toEpochSecond() 

 LocalDate.now( ZoneId.of( "Africa/Tunis" ) ) .plusDays( 1 ) .atStartOfDay( ZoneId.of( "Africa/Tunis" ) ) .toEpochSecond() 

 "SELECT * FROM orders WHERE placed >= ? AND placed < ? ; " 

 myPreparedStatement.setObject( 1 , start ) myPreparedStatement.setObject( 2 , stop ) 

java.time

Você está usando classs de data e hora antigas problemáticas que agora são herdadas, suplantadas pelas classs java.time modernas.

Aparentemente, você está armazenando um momento em seu database em uma coluna de algum tipo inteiro. Isso é uma pena. Em vez disso, você deve estar usando uma coluna de um tipo, como o padrão SQL TIMESTAMP WITH TIME ZONE . Mas, para esta resposta, trabalharemos com o que temos.

Se seus registros representam momentos com uma resolução de milissegundos e você deseja todos os registros por um dia inteiro, precisamos de um intervalo de tempo. Temos que ter um momento inicial e um momento de parada. Sua consulta tem apenas um único critério de data e hora em que deveria ter um par.

A class LocalDate representa um valor somente de datas sem hora do dia e sem fuso horário.

Um fuso horário é crucial para determinar uma data. Para qualquer momento, a data varia ao redor do globo por zona. Por exemplo, poucos minutos depois da meia-noite em Paris, a França é um novo dia ainda em “ontem” em Montreal, Quebec .

Se nenhum fuso horário for especificado, a JVM implicitamente aplicará seu fuso horário padrão atual. Esse padrão pode mudar a qualquer momento, então seus resultados podem variar. É melhor especificar explicitamente o fuso horário desejado / esperado como um argumento.

Especifique um nome de fuso horário adequado no formato de continent/region , como America/Montreal , Africa/Casablanca ou Pacific/Auckland . Nunca use a abreviação de 3 a 4 letras, como EST ou IST pois eles não são verdadeiros fusos horários, não são padronizados e nem mesmo exclusivos (!).

 ZoneId z = ZoneId.of( "America/Montreal" ) ; LocalDate today = LocalDate.now( z ) ; 

Se você quiser usar o fuso horário padrão atual da JVM, solicite-o e passe como um argumento. Se omitido, o padrão atual da JVM é aplicado implicitamente. Melhor ser explícito, pois o padrão pode ser alterado a qualquer momento durante a execução por qualquer código em qualquer thread de qualquer aplicativo dentro da JVM.

 ZoneId z = ZoneId.systemDefault() ; // Get JVM's current default time zone. 

Ou especifique uma data. Você pode definir o mês por um número, com número de sane 1-12 para janeiro-dezembro.

 LocalDate ld = LocalDate.of( 1986 , 2 , 23 ) ; // Years use sane direct numbering (1986 means year 1986). Months use sane numbering, 1-12 for January-December. 

Ou melhor, use os objects Month enum pré-definidos, um para cada mês do ano. Dica: use esses objects Month toda a sua base de código, em vez de um simples número inteiro, para tornar seu código mais auto-documentável, garantir valores válidos e fornecer segurança de tipo .

 LocalDate ld = LocalDate.of( 1986 , Month.FEBRUARY , 23 ) ; 

Com um LocalDate em mãos, precisamos transformar isso em um par de momentos, o início e o fim do dia. Não assuma que o dia começa às 00:00:00 hora do dia. Por causa de anomalias como o horário de verão (DST), o dia pode começar em outro horário, como 01:00:00. Então deixe java.time determinar o primeiro momento do dia. Nós passamos um argumento ZoneId para LocalDate::atStartOfDay para procurar tais anomalias. O resultado é um ZonedDateTime .

 ZonedDateTime zdtStart = ld.atStartOfDay( z ) ; 

Geralmente, a melhor abordagem para definir um período de tempo é a abordagem Half-Open, em que o início é inclusivo, enquanto o final é exclusivo . Então, um dia começa com seu primeiro momento e vai até, mas não incluindo, o primeiro momento do dia seguinte.

 ZonedDateTime zdtStop = ld.plusDays( 1 ).atStartOfDay( z ) ; // Determine the following date, and ask for the first moment of that day. 

Nossa consulta por um dia inteiro não pode fazer uso do comando SQL BETWEEN . Esse comando é Fully-Closed ( [] ) (tanto o início quanto o final são inclusivos), onde queremos Half-Open ( [) ). Nós usamos um par de critérios >= e < .

Sua coluna é mal nomeada. Evite qualquer uma das mil palavras reservadas por vários bancos de dados. Vamos usar placed neste exemplo.

Seu código deveria ter usado ? espaços reservados para especificar nossos momentos.

 String sql = "SELECT * FROM orders WHERE placed >= ? AND placed < ? ; " ; 

Mas temos objects ZonedDateTime em mãos, enquanto seu database aparentemente está armazenando inteiros como discutido acima. Se você tivesse definido sua coluna corretamente, poderíamos simplesmente passar os objects ZonedDateTime com qualquer driver JDBC que suporte JDBC 4.2 ou posterior.

Mas, em vez disso, precisamos obter uma contagem de épocas em segundos inteiros. Eu assumirei que sua data de referência é o primeiro momento de 1970 no UTC. Cuidado com possíveis perdas de dados, pois a class ZonedDateTime é capaz de resolução de nanossegundos. Qualquer segundo fracionário será truncado nas linhas a seguir.

 long start = zdtStart().toEpochSecond() ; // Transform to a count of whole seconds since 1970-01-01T00:00:00Z. long stop = zdtStop().toEpochSecond() ; 

Agora estamos prontos para passar esses inteiros ao nosso código SQL definido acima.

 PreparedStatement ps = con.prepareStatement( sql ); ps.setObject( 1 , start ) ; ps.setObject( 2 , stop ) ; ResultSet rs = ps.executeQuery(); 

Quando você recupera seus valores inteiros do ResultSet , é possível transformar em objects Instant (sempre em UTC) ou em objects ZonedDateTime (com um fuso horário atribuído).

 Instant instant = rs.getObject( … , Instant.class ) ; ZonedDateTime zdt = instant.atZone( z ) ; 

Sobre o java.time

O framework java.time está embutido no Java 8 e posterior. Essas classs substituem as antigas classs herdadas de data e hora legadas , como java.util.Date , Calendar e SimpleDateFormat .

O projeto Joda-Time , agora em modo de manutenção , aconselha a migration para as classs java.time .

Para saber mais, veja o Oracle Tutorial . E pesquise o Stack Overflow para muitos exemplos e explicações. A especificação é JSR 310 .

Onde obter as classs java.time?

  • Java SE 8 , Java SE 9 e posterior
    • Construídas em.
    • Parte da API Java padrão com uma implementação integrada.
    • O Java 9 adiciona alguns resources e correções menores.
  • Java SE 6 e Java SE 7
    • Grande parte da funcionalidade java.time é transferida para o Java 6 e 7 no ThreeTen-Backport .
  • Android
    • Versões posteriores das implementações do pacote Android das classs java.time.
    • Para o Android anterior, o projeto ThreeTenABP adapta o ThreeTen-Backport (mencionado acima). Veja Como usar o ThreeTenABP… .

O projeto ThreeTen-Extra estende java.time com classs adicionais. Este projeto é um campo de testes para possíveis futuras adições ao java.time. Você pode encontrar algumas classs úteis aqui como Interval , YearWeek , YearQuarter e muito mais .

Sinto-me obrigado a responder, pois outras respostas parecem ser agnósticas em fuso horário, o que uma aplicação no mundo real não pode se dar ao luxo de ser. Para tornar a conversão de data e hora em data correta quando o registro de data e hora e a JVM estão usando fusos horários diferentes, é possível usar LocalDateTime do Joda Time (ou LocalDateTime em Java8) desta forma:

 Timestamp timestamp = resultSet.getTimestamp("time_column"); LocalDateTime localDateTime = new LocalDateTime(timestamp); Date trueDate = localDateTime.toDate(DateTimeZone.UTC.toTimeZone()); 

O exemplo abaixo assume que o registro de data e hora é UTC (como é geralmente o caso com bancos de dados). Caso seus timestamps estejam em um fuso horário diferente, altere o parâmetro timezone da instrução toDate .

tente usar este código java:

 enter code here Timestamp stamp = new Timestamp(System.currentTimeMillis()); Date date = new Date(stamp.getTime()); DateFormat f = new SimpleDateFormat("yyyy-MM-dd"); DateFormat f1 = new SimpleDateFormat("yyyy/MM/dd"); String d=f.format(date); String d1=f1.format(date); System.out.println(d); System.out.println(d1); 

Supondo que você tenha uma java.util.Date date pré-existente:

 Timestamp timestamp = new Timestamp(long); date.setTime( l_timestamp.getTime() ); 
 String timestamp=""; Date temp=null; try { temp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(getDateCurrentTimeZone(Long.parseLong(timestamp))); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } int dayMonth=temp.getDate(); int dayWeek=temp.getDay(); int hour=temp.getHours(); int minute=temp.getMinutes(); int month=temp.getMonth()+1; int year=temp.getYear()+1900; 
 DateFormat df = new SimpleDateFormat("dd/MM/yyyy"); Date fecha = getDateInTimestamp();