Is there any other way to convert "timestamp = System.currentTimeMillis()" to normal date time, say for example "DD-MM-YYYY HH:MM:SS"

Question

Actually we are using a "timestamp = System.currentTimeMillis()", which is an Epoch time! We are looking to convert the same to normal format ex: 15-03-2020 (dd-mm-yyyy).

We are using:

timestamp = System.currentTimeMillis()
var date = Date(timestamp)
var formattedTime = "$date"

I tried to convert using the above method! I got output as : formatted time is Wed Mar 15 11:32:44 GMT+05:30 2023 I need output as : dd-mm-yyyy hh:mm:ss format, example : 15-03-2023 10:00:00

More precisely the data stored according to the code is some numbers. Example: 1678962531. This number is getting stored in our database. Instead of this number (1678962531) I'm expecting a date to store as yyyy-mm-dd format. Looking a code for this in Kotlin.

Answer 1

you could consider directly getting the LocalDateTime instead of getting an epoch using System.currentTimeMillis()

see the following example which does not use parse from this site

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

    fun main(args: Array) {
    
        val x = LocalDateTime.now()
        val todayFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd") <--change your format here.
        val todayFormatted = x.format(todayFormatter)
    
        println("Today's date is : "+todayFormatted)
    }

if you want to continue using Date() instead, you can check this site and the example they provide

String pattern = "yyyy-MM-dd";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
String date = simpleDateFormat.format(new Date());
System.out.println(date);

And this is what i wrote to simulate an epoch without milliseconds:

        long seconds = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
        System.out.println(seconds);
        LocalDateTime time = LocalDateTime.ofEpochSecond(seconds, 0, ZoneOffset.ofHours(0));
        String formatted = time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));

        System.out.println(formatted);

output:

1679017835  
2023-03-17

Answer 2

(Using Java syntax, as I’ve not yet learned Kotlin.)

tl;dr

Instant                         // Represents a moment as seen in UTC, that is, with an offset from UTC of zero hours-minutes-seconds.
.ofEpochMilli(
    System.currentTimeMillis()  // Returns a `long` value, a count of milliseconds since the epoch reference of 1970-01-01T00:00Z.
)                               // Returns an `Instant` object.
.atZone( 
    ZoneId.systemDefault() 
)                               // Returns a `ZonedDateTime` object.
.toLocalDate()                  // Returns a `LocalDate` object.
.format(
    DateTimeFormatter
    .ofPattern( "dd-MM-uuuu" )  // Returns a `DateTimeFormatter` object.
)                               // Returns a `String` object.

java.time

timestamp = System.currentTimeMillis()

The method System.currentTimeMillis() returns a count of milliseconds since the epoch reference of the first moment in 1970 in UTC, 1970-01-01T00:00Z.

You can parse that number into an Instant, which represents a moment as seen in UTC as well (an offset from UTC of zero hours-minutes-seconds).

Instant instant = Instant.ofEpochMilli( millisSinceEpoch ) ;

To get that same number:

long millisSinceEpoch = Instant.now().toEpochMilli() ;

Ever better, just stop using System.currentTimeMillis(). Just use Instant in the first place. The Instant class resolves to nanoseconds, though most implementations are constrained to capturing the current moment in microseconds because of the limits of today's computer hardware clocks. Still, that is better that mere milliseconds.

Instant instant = Instant.now() ;  // Likely contains microseconds in Java 9+, though limited to milliseconds in Java 8 (generally).

Your code:

var date = Date(timestamp)

No, no, no. Never use the terrible legacy class java.util.Date nor java.sql.Date. Both were supplanted years ago by the modern java.time classes built into Java 8+, defined by JSR 310. Those two classes were specifically replaced by java.time.Instant and java.time.LocalDate, respectively.

Android 26+ has java.time classes built-in. For earlier Android, the latest tooling provides access to most of the java.time functionality via “API desugaring”.

You said:

convert the same to normal format ex: 15-03-2020 (dd-mm-yyyy)

Determining the date requires a time zone. For any given moment, the date around the world varies by time zone (think about it!).

Apply a time zone (ZoneId) to get a ZonedDateTime.

ZoneId z = ZoneId.of( "Asia/Tokyo" ) ;  // Or perhaps `ZoneId.systemDefault()`.
ZonedDateTime zdt = instant.atZone( z ) ;

Extract the date-only.

LocalDate ld = zdt.toLocalDate() ;

Date-time objects do not have text, so they do not have “format”. You need to generate text in your desired format.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd-MM-uuuu" ) ;
String output = ld.format( f ) ;