## 1. Overview

Calculating the difference between two time periods is a common task when dealing with date and time-related operations. We can find it useful while determining the duration between two events or tracking time intervals.

In this tutorial, we’ll learn different ways to calculate the time difference between two time periods in Kotlin.

## 2. Using kotlin.time.Duration

We can use the kotlin.time.Duration class from the Kotlin standard library to represent a time period in seconds, minutes, hours, and so on.

Let’s initialize two time periods, namely, startDuration and endDuration as Duration objects:

``````val startDuration = 1.days + 12.hours + 15.minutes
val endDuration = 8.hours + 45.minutes``````

Now, we can conveniently find the difference between the two time periods using the minus() method:

``val difference: Duration = startDuration.minus(endDuration)``

Lastly, let’s verify that difference has got the correct time duration:

``assertEquals(1.days + 3.hours + 30.minutes, difference)``

Great! It looks like we’ve got this one right.

## 3. Using kotlinx.datetime.Instant

We can use the kotlinx.datetime.Instant class from the kotlinx-datetime library to represent an exact point in time in UTC. In this section, let’s learn how to measure the difference between two time periods represented as epoch timestamps.

### 3.1. Dependency Setup

To use the kotlinx-datetime library, we must add the dependency to kotlinx-datetime-jvm in the project’s pom.xml:

``````<dependency>
<groupId>org.jetbrains.kotlinx</groupId>
<artifactId>kotlinx-datetime-jvm</artifactId>
<version>0.4.0</version>
</dependency>``````

That’s it. We can now use this library to solve our use case.

### 3.2. Finding Difference

First, let’s define the startEpochMillis and endEpochMillis timestamps:

``````val startEpochMillis = 1700617592000L
val endEpochMillis = 1700617692000L``````

We can use one of the epoch converter utilities to see that these represent “Wednesday, November 22, 2023 1:46:32 AM” and “Wednesday, November 22, 2023 1:48:12 AM” in UTC.

Next, let’s create two objects of the Instant class, namely, instant1 and instant2 from startEpochMillis and endEpochMillis:

``````val instant1 = Instant.fromEpochMilliseconds(startEpochMillis)
val instant2 = Instant.fromEpochMilliseconds(endEpochMillis)``````

Now, we can determine the difference between these two events using the minus() method:

``val durationDiff = instant2.minus(instant1)``

Finally, let’s verify that our approach works correctly:

``assertEquals(1.minutes + 40.seconds, durationDiff)``

It works as expected.

## 4. Using kotlin.time.TimeSource

One of the popular use cases for calculating time difference is to measure the time taken by an operation. We can use the TimeSource API to find the time difference for such scenarios.

First, let’s initialize the timeSource object with the TimeSource.Monotonic implementation for TimeSource:

``val timeSource = TimeSource.Monotonic``

Now, we can use the markNow() method to mark a point, mark1, on the timeline provided by timeSource:

``val mark1 = timeSource.markNow()``

Further, we can call the operation for which we’re doing the time measurement and then mark a new point, mark2 on the timeline:

``````// call operation
val mark2 = timeSource.markNow()``````

Finally, we can compute the time difference by subtracting the two values:

``val difference = mark2 - mark1``

That’s it. We get the time difference as a Duration object in the difference object.

## 5. Conclusion

In this article, we learned how to find the time difference between two time periods in Kotlin. Furthermore, we explored the Kotlin.time.Duration, Kotlinx.datetime.Instant, and kotlin.time.TimeSource classes to solve the use case of measuring time difference.