Java unix timestamp from date

java — Epoch or Unix timestamp and convert to from Date with examples

Epoch time is many seconds that already passed from 1 January 1970 UTC.

For a day, the total number of seconds is 24* 60*60 seconds. Epoch time returns the long number between the current time and 1 January 1970.

It is also called Epoch Unix time .

Every programming language provides API for handling Unix time. Java also provides a Date API for manipulation of Epoch Time.

The reason for 1970 is time in UNIX OS was introduced by taking this time.

EPOCH time = unix epoch time = Number of millseconds 01/01/1970 00:00:00

Epcoh/Unix time Examples in java

• Find epoch time in
• Convert Date and time to milliseconds
• Convert epoch time to LocalDate and LocalDateTime

How to get Epoch time or Unix timestamp in java?

Epoch time is a number of seconds that already passed since 1970 January 1 UTC. Prior to java8, Used System class to get Epoch time,

long epochTimeinSeconds = System.currentTimeMillis() / 1000L; System.out.println(epochTimeinSeconds); With java8, Date and Time API is improved and introduced java.time package for dealing with date, time, and zones over legacy classes.\ Instant is a class of points in a time zone.

long epochTimewithJava8 = Instant.now().getEpochSecond(); System.out.println(epochTimewithJava8); Both return the same output

java.time.Instant class provides the toEpochMilli() method to convert the date with time into epoch milliseconds.

Here is a code for converting Date and time into epoch milliseconds

long epochTimewithJava81= Instant.now().toEpochMilli(); //Long = 1450879900184 System.out.println(epochTimewithJava81);

Convert epoch time java.time.LocalDateTime

LocalDateTime represents Date and time zone information, epoch time is in long seconds. For this, we need to have the System Default Timezone retrieved and the Instant object is required to convert to it.

long epochTimewithJava8 = System.currentTimeMillis(); System.out.println(epochTimewithJava8); Instant instant = Instant.ofEpochMilli(epochTimewithJava8); LocalDateTime localDateTime = instant.atZone(ZoneId.systemDefault()).toLocalDateTime(); System.out.println(localDateTime); The output of the above java program is

 1535949786956 2018-09-03T10:13:06.956

Convert epoch time to LocalDate

LocalDate represents date only. To convert, Instant object creation is required with the default timezone.

long epochTimewithJava8 = System.currentTimeMillis(); System.out.println(epochTimewithJava8); Instant instant = Instant.ofEpochMilli(epochTimewithJava8); LocalDate localDate = instant.atZone(ZoneId.systemDefault()).toLocalDate(); System.out.println(localDate); Output is

String data is first converted to Date using SimpleDateFormat. The date format class accepts a formatted string and returns the Date object by calling the parse()method

String str="2018-09-03T04:51:00+05:0"; DateFormat parser = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX"); Date date=null; try  date = parser.parse(str); > catch (ParseException e)  // TODO Auto-generated catch block e.printStackTrace(); > System.out.println(date.getTime()/1000l); Output is

1535932260 You learned epoch milliseconds in java with examples and convert from/to date,localdate, and LocalDatetime from Unix milliseconds.

Источник

Create Date From Unix Timestamp in Java

The Kubernetes ecosystem is huge and quite complex, so it’s easy to forget about costs when trying out all of the exciting tools.

To avoid overspending on your Kubernetes cluster, definitely have a look at the free K8s cost monitoring tool from the automation platform CAST AI. You can view your costs in real time, allocate them, calculate burn rates for projects, spot anomalies or spikes, and get insightful reports you can share with your team.

Connect your cluster and start monitoring your K8s costs right away:

We rely on other people’s code in our own work. Every day.

It might be the language you’re writing in, the framework you’re building on, or some esoteric piece of software that does one thing so well you never found the need to implement it yourself.

The problem is, of course, when things fall apart in production — debugging the implementation of a 3rd party library you have no intimate knowledge of is, to say the least, tricky.

Lightrun is a new kind of debugger.

It’s one geared specifically towards real-life production environments. Using Lightrun, you can drill down into running applications, including 3rd party dependencies, with real-time logs, snapshots, and metrics.

Learn more in this quick, 5-minute Lightrun tutorial:

Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.

The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.

Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.

Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

The Kubernetes ecosystem is huge and quite complex, so it’s easy to forget about costs when trying out all of the exciting tools.

To avoid overspending on your Kubernetes cluster, definitely have a look at the free K8s cost monitoring tool from the automation platform CAST AI. You can view your costs in real time, allocate them, calculate burn rates for projects, spot anomalies or spikes, and get insightful reports you can share with your team.

Connect your cluster and start monitoring your K8s costs right away:

We’re looking for a new Java technical editor to help review new articles for the site.

1. Introduction

In this quick tutorial, we’ll learn how to parse representations of dates from a Unix timestamp. Unix time is the number of seconds elapsed since January 1, 1970. However, a timestamp can represent time down to nanosecond precision. So, we’ll see the tools available and create a method to convert timestamps of any range to a Java object.

2. Old Way (Before Java 8)

Before Java 8, our simplest options were Date and Calendar. The Date class has a constructor that directly accepts a timestamp in milliseconds:

public static Date dateFrom(long input)

With Calendar, we have to call setTimeInMillis() after getInstance():

public static Calendar calendarFrom(long input)

In other words, we must know if our input is in seconds, nanoseconds, or any other precision in between. Then, we have to convert our timestamp to milliseconds manually.

3. New Way (Java 8+)

Java 8 introduced Instant. This class has utility methods to create instances from seconds and milliseconds. Also, one of them accepts a nanoseconds adjustment parameter:

Instant.ofEpochSecond(seconds, nanos);

But we still must know in advance the precision of our timestamp. So, for example, some calculations are needed if we know our timestamp is in nanoseconds:

public static Instant fromNanos(long input) < long seconds = input / 1_000_000_000; long nanos = input % 1_000_000_000; return Instant.ofEpochSecond(seconds, nanos); >

First, we divide our timestamp by one billion to get the seconds. Then, we use its remainder to get the part after seconds.

4. Universal Solution With Instant

To avoid extra work, let’s create a method that can convert any input to milliseconds, which most classes can parse. Firstly, we check in what range our timestamp is. Then, we perform calculations to extract the milliseconds. Moreover, we’ll use scientific notations to make our conditions more readable.

Also, remember that timestamps are signed, so we have to check both the positive and negative ranges (negative timestamps mean they’re counted backward from 1970).

So, let’s start by checking if our input is in nanoseconds:

private static long millis(long timestamp) < if (millis >= 1E16 || millis // next range checks >

First, we check if it’s in the 1E16 range, which is one followed by 16 zeroes. Negative values represent dates before 1970, so we also have to check them. Then, we divide our value by one million to get to milliseconds.

Similarly, microseconds are in the 1E14 range. This time, we divide by one thousand:

if (timestamp >= 1E14 || timestamp 

We don’t need to change anything when our value is in the 1E11 to -3E10 range. That means our input is already in milliseconds precision:

if (timestamp >= 1E11 || timestamp

Finally, if our input isn’t any of these ranges, then it must be in seconds, so we need to convert this to milliseconds:

4.1. Normalizing Input for Instant

Now, let’s create a method that returns an Instant from input in any precision with Instant.ofEpochMilli():

public static Instant fromTimestamp(long input)

Note that every time we divide or multiply values, precision is lost.

4.2. Local Time With LocalDateTime

An Instant represents a moment in time. But, without a time zone, it’s not easily readable, as it depends on our location in the world. So, let’s create a method to generate a local time representation. We’ll use the UTC to avoid different results in our tests:

public static LocalDateTime localTimeUtc(Instant instant)

Now, we can test how using wrong precisions can result in entirely different dates when methods expect specific formats. First, let’s pass a timestamp in nanoseconds we already know the correct date for, but convert it to microseconds and use the fromNanos() method we created earlier:

@Test void givenWrongPrecision_whenInstantFromNanos_thenUnexpectedTime() < long microseconds = 1660663532747420283l / 1000; Instant instant = fromNanos(microseconds); String expectedTime = "2022-08-16T15:25:32"; LocalDateTime time = localTimeUtc(instant); assertThat(!time.toString().startsWith(expectedTime)); assertEquals("1970-01-20T05:17:43.532747420", time.toString()); >

This problem won’t happen when we use the fromTimestamp() method we created in the previous subsection:

@Test void givenMicroseconds_whenInstantFromTimestamp_thenLocalTimeMatches() < long microseconds = 1660663532747420283l / 1000; Instant instant = fromTimestamp(microseconds); String expectedTime = "2022-08-16T15:25:32"; LocalDateTime time = localTimeUtc(instant); assertThat(time.toString().startsWith(expectedTime)); >

5. Conclusion

In this article, we learned how to convert timestamps with core Java classes. Then, we saw how they can have different levels of precision and how that affects our results. Lastly, we created a simple way to normalize our input and get consistent results.

And, as always, the source code is available over on GitHub.

Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.

The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.

Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.

Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:

Источник

How to get the Unix timestamp in Java

The Unix timestamp is an integer value representing the number of seconds elapsed since the Unix Epoch on January 1st, 1970, at 00:00:00 UTC. In short, a Unix timestamp is the number of seconds between a specific date and the Unix Epoch.

There are multiple ways to compute a Unix timestamp in Java.

The simplest way to get a Unix atimestamp is using the Instant class. The Instant class is part of new date and time API and provides several methods to work with timestamps.

long unixTime = Instant.now().getEpochSecond(); System.out.println(unixTime); // 1665083712 

The getEpochSecond() method returns the seconds from the Unix epoch of 1970-01-01T00:00:00Z .

To convert a Unix timestamp back to an instance of Instant , use the Instant.ofEpochSecond() method:

long unixTime = 1665083712; Instant instant = Instant.ofEpochSecond(unixTime); System.out.println(instant); // 2022-10-06T19:15:12Z 

An Instant object represents an unique moment in the timeline using a universal timezone (UTC).

In Java 7 and below, you can use the System.currentTimeMillis() method to get the current time in milliseconds.

Later, you can convert the milliseconds into seconds to get the Unix timestamp, as shown below:

long unixTime = System.currentTimeMillis() / 1000L; System.out.println(unixTime); // 1665083712 

Finally, the last method to get the Unix timestamp in Java is using the legacy Date class:

Date date = new Date(); long unixTime = date.getTime() / 1000L; System.out.println(unixTime); // 1665083712 

You may be interested in reading the following Java date and time tutorials:

✌️ Like this article? Follow me on Twitter and LinkedIn. You can also subscribe to RSS Feed.

You might also like.

Источник