You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pekko.apache.org by he...@apache.org on 2025/09/13 10:45:51 UTC

(pekko) branch duration created (now e050da82fa)

This is an automated email from the ASF dual-hosted git repository.

hepin pushed a change to branch duration
in repository https://gitbox.apache.org/repos/asf/pekko.git


      at e050da82fa chore: Use scala.jdk.DurationConverters

This branch includes the following new commits:

     new e050da82fa chore: Use scala.jdk.DurationConverters

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pekko.apache.org
For additional commands, e-mail: commits-help@pekko.apache.org


(pekko) 01/01: chore: Use scala.jdk.DurationConverters

Posted by he...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

hepin pushed a commit to branch duration
in repository https://gitbox.apache.org/repos/asf/pekko.git

commit e050da82fadda8e0709ec726dd12724998685d83
Author: He-Pin <he...@gmail.com>
AuthorDate: Sat Sep 13 18:45:33 2025 +0800

    chore: Use scala.jdk.DurationConverters
---
 CONTRIBUTING.md                                    | 20 ++++----
 .../apache/pekko/actor/testkit/typed/Effect.scala  | 14 +++---
 .../actor/testkit/typed/TestKitSettings.scala      |  4 +-
 .../testkit/typed/internal/TestProbeImpl.scala     | 34 +++++++-------
 .../actor/testkit/typed/javadsl/ActorTestKit.scala |  8 ++--
 .../actor/testkit/typed/javadsl/Effects.scala      |  8 ++--
 .../actor/testkit/typed/javadsl/ManualTime.scala   |  6 +--
 .../apache/pekko/pattern/CircuitBreakerTest.java   |  8 ++--
 .../pekko/util/JavaConverterScala3InlineTest.java  |  5 +-
 .../pekko/actor/typed/SupervisorStrategy.scala     | 10 ++--
 .../actor/typed/delivery/ConsumerController.scala  | 12 ++---
 .../actor/typed/delivery/ProducerController.scala  | 12 ++---
 .../delivery/WorkPullingProducerController.scala   |  6 +--
 .../actor/typed/internal/ActorContextImpl.scala    |  6 +--
 .../actor/typed/internal/TimerSchedulerImpl.scala  | 12 ++---
 .../pekko/actor/typed/javadsl/AskPattern.scala     |  6 +--
 .../org/apache/pekko/actor/AbstractScheduler.java  |  4 +-
 .../java-duration-converters.excludes              |  6 +++
 .../apache/pekko/util/JavaDurationConverters.scala | 35 --------------
 .../apache/pekko/util/JavaDurationConverters.scala | 39 ----------------
 .../org/apache/pekko/actor/AbstractActor.scala     | 15 +++---
 .../scala/org/apache/pekko/actor/AbstractFSM.scala | 12 ++---
 .../org/apache/pekko/actor/ActorSelection.scala    |  6 +--
 .../main/scala/org/apache/pekko/actor/FSM.scala    |  6 +--
 .../org/apache/pekko/actor/FaultHandling.scala     | 18 ++++----
 .../scala/org/apache/pekko/actor/Scheduler.scala   | 25 +++++-----
 .../main/scala/org/apache/pekko/actor/Timers.scala | 12 ++---
 actor/src/main/scala/org/apache/pekko/io/Tcp.scala |  4 +-
 .../org/apache/pekko/io/dns/CachePolicy.scala      |  8 ++--
 .../org/apache/pekko/io/dns/DnsSettings.scala      |  4 +-
 .../org/apache/pekko/pattern/BackoffOptions.scala  |  6 +--
 .../org/apache/pekko/pattern/CircuitBreaker.scala  | 10 ++--
 .../scala/org/apache/pekko/pattern/Patterns.scala  | 26 +++++------
 .../routing/OptimalSizeExploringResizer.scala      |  8 ++--
 .../routing/ScatterGatherFirstCompleted.scala      |  6 +--
 .../org/apache/pekko/routing/TailChopping.scala    |  6 +--
 .../main/scala/org/apache/pekko/util/Timeout.scala |  4 +-
 .../sharding/typed/ClusterShardingQuery.scala      |  4 +-
 .../sharding/typed/ClusterShardingSettings.scala   | 28 +++++------
 .../typed/ShardedDaemonProcessSettings.scala       |  6 +--
 .../delivery/ShardingProducerController.scala      | 14 +++---
 .../typed/internal/ClusterShardingImpl.scala       |  6 +--
 .../typed/internal/testkit/TestEntityRefImpl.scala |  6 +--
 .../sharding/ClusterShardingHealthCheck.scala      |  4 +-
 .../cluster/sharding/ClusterShardingSettings.scala | 10 ++--
 .../external/ExternalShardAllocationStrategy.scala |  4 +-
 .../ExternalShardAllocationClientImpl.scala        |  4 +-
 .../singleton/ClusterSingletonManager.scala        |  4 +-
 .../ddata/typed/internal/ReplicatorBehavior.scala  |  8 ++--
 .../ddata/typed/javadsl/DistributedData.scala      |  4 +-
 .../cluster/ddata/typed/javadsl/Replicator.scala   | 14 +++---
 .../typed/javadsl/ReplicatorMessageAdapter.scala   |  4 +-
 .../ddata/typed/scaladsl/DistributedData.scala     |  4 +-
 .../pekko/cluster/typed/ClusterSingleton.scala     | 12 ++---
 .../org/apache/pekko/cluster/StreamRefSpec.scala   |  2 +-
 .../coordination/lease/LeaseUsageSettings.scala    |  4 +-
 .../pekko/coordination/lease/TimeoutSettings.scala | 20 ++++----
 .../apache/pekko/cluster/ddata/Replicator.scala    | 18 ++++----
 .../testkit/javadsl/PersistenceInit.scala          |  4 +-
 .../testkit/javadsl/PersistenceTestKit.scala       | 10 ++--
 .../testkit/javadsl/SnapshotTestKit.scala          | 10 ++--
 .../typed/delivery/EventSourcedProducerQueue.scala | 14 +++---
 .../typed/javadsl/PersistentFSMMigration.scala     |  4 +-
 .../pekko/persistence/fsm/PersistentFSM.scala      |  5 +-
 .../pekko/persistence/fsm/PersistentFSMBase.scala  |  8 ++--
 .../jackson/FiniteDurationModule.scala             |  6 +--
 .../pekko/stream/testkit/StreamTestKit.scala       | 36 +++++++--------
 .../pekko/stream/typed/javadsl/ActorFlow.scala     | 13 +++---
 .../scala/org/apache/pekko/stream/Attributes.scala | 12 ++---
 .../org/apache/pekko/stream/RestartSettings.scala  | 14 +++---
 .../apache/pekko/stream/SystemMaterializer.scala   |  4 +-
 .../org/apache/pekko/stream/javadsl/BidiFlow.scala |  4 +-
 .../pekko/stream/javadsl/DelayStrategy.scala       |  4 +-
 .../org/apache/pekko/stream/javadsl/Flow.scala     | 38 +++++++--------
 .../pekko/stream/javadsl/FlowWithContext.scala     | 10 ++--
 .../apache/pekko/stream/javadsl/RetryFlow.scala    |  8 ++--
 .../org/apache/pekko/stream/javadsl/Source.scala   | 40 ++++++++--------
 .../pekko/stream/javadsl/SourceWithContext.scala   | 10 ++--
 .../pekko/stream/javadsl/StreamConverters.scala    |  6 +--
 .../org/apache/pekko/stream/javadsl/SubFlow.scala  | 38 +++++++--------
 .../apache/pekko/stream/javadsl/SubSource.scala    | 38 +++++++--------
 .../org/apache/pekko/stream/javadsl/Tcp.scala      |  4 +-
 .../org/apache/pekko/stream/scaladsl/Tcp.scala     |  4 +-
 .../org/apache/pekko/stream/stage/GraphStage.scala | 12 ++---
 .../org/apache/pekko/testkit/javadsl/TestKit.scala | 54 +++++++++++-----------
 85 files changed, 475 insertions(+), 546 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6b93cd8d2c..caa8e157c6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -552,16 +552,16 @@ Scala has proven the most viable way to do it, as long as you keep the following
 
 #### Overview of Scala types and their Java counterparts
 
-| Scala | Java |
-|-------|------|
-| `scala.Option[T]` | `java.util.Optional<T>` (`OptionalDouble`, ...) |
-| `scala.collection.immutable.Seq[T]` | `java.util.List<T>` |
-| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage<T>` |
-| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture<T>` |
-| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `org.apache.pekko.util.JavaDurationConverters`) |
-| `T => Unit` | `java.util.function.Consumer<T>` |
-| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier<R>` |
-| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function<T, R>` |
+| Scala | Java                                                           |
+|-------|----------------------------------------------------------------|
+| `scala.Option[T]` | `java.util.Optional<T>` (`OptionalDouble`, ...)                |
+| `scala.collection.immutable.Seq[T]` | `java.util.List<T>`                                            |
+| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage<T>`                      |
+| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture<T>`                    |
+| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `scala.jdk.japi.DurationConverters`) |
+| `T => Unit` | `java.util.function.Consumer<T>`                               |
+| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier<R>`                               |
+| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function<T, R>`                            |
 
 ### Contributing new Pekko Streams operators
 
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala
index 28887d6cb0..10bcdba274 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala
@@ -19,7 +19,7 @@ import org.apache.pekko
 import pekko.actor.typed.{ ActorRef, Behavior, Props }
 import pekko.annotation.{ DoNotInherit, InternalApi }
 import pekko.util.FunctionConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.unused
 
 /**
@@ -198,7 +198,7 @@ object Effect {
     /**
      * Java API
      */
-    def duration(): java.time.Duration = d.asJava
+    def duration(): java.time.Duration = d.toJava
   }
 
   case object ReceiveTimeoutCancelled extends ReceiveTimeoutCancelled
@@ -210,7 +210,7 @@ object Effect {
    * FIXME what about events scheduled through the scheduler?
    */
   final case class Scheduled[U](delay: FiniteDuration, target: ActorRef[U], message: U) extends Effect {
-    def duration(): java.time.Duration = delay.asJava
+    def duration(): java.time.Duration = delay.toJava
   }
 
   final case class TimerScheduled[U](
@@ -220,11 +220,11 @@ object Effect {
       mode: TimerScheduled.TimerMode,
       overriding: Boolean)(val send: () => Unit)
       extends Effect {
-    def duration(): java.time.Duration = delay.asJava
+    def duration(): java.time.Duration = delay.toJava
   }
 
   object TimerScheduled {
-    import pekko.util.JavaDurationConverters._
+    import scala.jdk.DurationConverters._
 
     sealed trait TimerMode
     case object FixedRateMode extends TimerMode
@@ -235,9 +235,9 @@ object Effect {
 
     /*Java API*/
     def fixedRateMode = FixedRateMode
-    def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.asScala)
+    def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.toScala)
     def fixedDelayMode = FixedDelayMode
-    def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.asScala)
+    def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.toScala)
     def singleMode = SingleMode
   }
 
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala
index 8de5d2b9e4..69818c9715 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala
@@ -21,7 +21,7 @@ import org.apache.pekko
 import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.Extension
 import pekko.actor.typed.ExtensionId
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 object TestKitSettings {
@@ -97,5 +97,5 @@ final class TestKitSettings(val config: Config) {
    * Java API: Scale the `duration` with the configured `TestTimeFactor`
    */
   def dilated(duration: java.time.Duration): java.time.Duration =
-    dilated(duration.asScala).asJava
+    dilated(duration.toScala).toJava
 }
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala
index 18e5ad198e..ff7077dcfe 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala
@@ -43,7 +43,7 @@ import pekko.actor.typed.scaladsl.Behaviors
 import pekko.annotation.InternalApi
 import pekko.japi.function.Creator
 import pekko.util.BoxedType
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.PrettyDuration._
 import pekko.util.ccompat.JavaConverters._
 
@@ -102,14 +102,14 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
 
   override def remainingOrDefault: FiniteDuration = remainingOr(settings.SingleExpectDefaultTimeout)
 
-  override def getRemainingOrDefault: JDuration = remainingOrDefault.asJava
+  override def getRemainingOrDefault: JDuration = remainingOrDefault.toJava
 
   override def remaining: FiniteDuration = end match {
     case f: FiniteDuration => f - now
     case _                 => assertFail("`remaining` may not be called outside of `within`")
   }
 
-  override def getRemaining: JDuration = remaining.asJava
+  override def getRemaining: JDuration = remaining.toJava
 
   override def remainingOr(duration: FiniteDuration): FiniteDuration = end match {
     case x if x eq Duration.Undefined => duration
@@ -119,7 +119,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
   }
 
   override def getRemainingOr(duration: JDuration): JDuration =
-    remainingOr(duration.asScala).asJava
+    remainingOr(duration.toScala).toJava
 
   override def within[T](min: FiniteDuration, max: FiniteDuration)(f: => T): T =
     within_internal(min, max.dilated, f)
@@ -128,10 +128,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     within_internal(Duration.Zero, max.dilated, f)
 
   override def within[T](min: JDuration, max: JDuration)(f: Supplier[T]): T =
-    within_internal(min.asScala, max.asScala.dilated, f.get())
+    within_internal(min.toScala, max.toScala.dilated, f.get())
 
   def within[T](max: JDuration)(f: Supplier[T]): T =
-    within_internal(Duration.Zero, max.asScala.dilated, f.get())
+    within_internal(Duration.Zero, max.toScala.dilated, f.get())
 
   private def within_internal[T](min: FiniteDuration, max: FiniteDuration, f: => T): T = {
     val start = now
@@ -162,13 +162,13 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
   override def expectMessage[T <: M](max: FiniteDuration, obj: T): T = expectMessage_internal(max.dilated, obj)
 
   override def expectMessage[T <: M](max: JDuration, obj: T): T =
-    expectMessage(max.asScala, obj)
+    expectMessage(max.toScala, obj)
 
   override def expectMessage[T <: M](max: FiniteDuration, hint: String, obj: T): T =
     expectMessage_internal(max.dilated, obj, Some(hint))
 
   override def expectMessage[T <: M](max: JDuration, hint: String, obj: T): T =
-    expectMessage(max.asScala, hint, obj)
+    expectMessage(max.toScala, hint, obj)
 
   private def expectMessage_internal[T <: M](max: FiniteDuration, obj: T, hint: Option[String] = None): T = {
     if (obj.isInstanceOf[Signal])
@@ -185,7 +185,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
 
   override def receiveMessage(): M = receiveMessage_internal(remainingOrDefault)
 
-  override def receiveMessage(max: JDuration): M = receiveMessage(max.asScala)
+  override def receiveMessage(max: JDuration): M = receiveMessage(max.toScala)
 
   override def receiveMessage(max: FiniteDuration): M = receiveMessage_internal(max.dilated)
 
@@ -212,7 +212,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectNoMessage_internal(max)
 
   override def expectNoMessage(max: JDuration): Unit =
-    expectNoMessage(max.asScala)
+    expectNoMessage(max.toScala)
 
   override def expectNoMessage(): Unit =
     expectNoMessage_internal(settings.ExpectNoMessageDefaultTimeout)
@@ -232,10 +232,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectMessageClass_internal(max.dilated, t.runtimeClass.asInstanceOf[Class[T]])
 
   override def expectMessageClass[T <: M](clazz: Class[T]): T =
-    expectMessageClass_internal(getRemainingOrDefault.asScala, clazz)
+    expectMessageClass_internal(getRemainingOrDefault.toScala, clazz)
 
   override def expectMessageClass[T <: M](clazz: Class[T], max: JDuration): T =
-    expectMessageClass_internal(max.asScala.dilated, clazz)
+    expectMessageClass_internal(max.toScala.dilated, clazz)
 
   private def expectMessageClass_internal[C](max: FiniteDuration, c: Class[C]): C = {
     if (classOf[Signal].isAssignableFrom(c)) {
@@ -258,10 +258,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     receiveMessages_internal(n, max.dilated)
 
   override def receiveSeveralMessages(n: Int): JList[M] =
-    receiveMessages_internal(n, getRemainingOrDefault.asScala).asJava
+    receiveMessages_internal(n, getRemainingOrDefault.toScala).asJava
 
   override def receiveSeveralMessages(n: Int, max: JDuration): JList[M] =
-    receiveMessages_internal(n, max.asScala.dilated).asJava
+    receiveMessages_internal(n, max.toScala.dilated).asJava
 
   private def receiveMessages_internal(n: Int, max: FiniteDuration): immutable.Seq[M] = {
     val stop = max + now
@@ -295,7 +295,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
       max: JDuration,
       hint: String,
       fisher: java.util.function.Function[M, FishingOutcome]): JList[M] =
-    fishForMessage_internal(max.asScala.dilated, hint, fisher.apply).asJava
+    fishForMessage_internal(max.toScala.dilated, hint, fisher.apply).asJava
 
   private def fishForMessage_internal(max: FiniteDuration, hint: String, fisher: M => FishingOutcome): List[M] = {
     @tailrec def loop(timeout: FiniteDuration, seen: List[M]): List[M] = {
@@ -338,7 +338,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     expectTerminated_internal(actorRef, remainingOrDefault)
 
   override def expectTerminated[U](actorRef: ActorRef[U], max: JDuration): Unit =
-    expectTerminated_internal(actorRef, max.asScala.dilated)
+    expectTerminated_internal(actorRef, max.toScala.dilated)
 
   private def expectTerminated_internal[U](actorRef: ActorRef[U], max: FiniteDuration): Unit = {
     testActor.asInstanceOf[ActorRef[AnyRef]] ! WatchActor(actorRef)
@@ -364,7 +364,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_]
     awaitAssert_internal(a, remainingOrDefault, 100.millis)
 
   override def awaitAssert[A](max: JDuration, interval: JDuration, creator: Creator[A]): A =
-    awaitAssert_internal(creator.create(), max.asScala.dilated, interval.asScala)
+    awaitAssert_internal(creator.create(), max.toScala.dilated, interval.toScala)
 
   def awaitAssert[A](max: JDuration, creator: Creator[A]): A =
     awaitAssert(max, JDuration.ofMillis(100), creator)
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala
index 6b06770756..093e95294c 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala
@@ -29,7 +29,7 @@ import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.Behavior
 import pekko.actor.typed.Props
 import pekko.actor.typed.Scheduler
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 object ActorTestKit {
@@ -123,7 +123,7 @@ object ActorTestKit {
    *                             no exception is thrown.
    */
   def shutdown(system: ActorSystem[_], duration: Duration, throwIfShutdownTimesOut: Boolean): Unit = {
-    TestKitUtils.shutdown(system, duration.asScala, throwIfShutdownTimesOut)
+    TestKitUtils.shutdown(system, duration.toScala, throwIfShutdownTimesOut)
   }
 
   /**
@@ -143,7 +143,7 @@ object ActorTestKit {
    */
   def shutdown(system: ActorSystem[_]): Unit = {
     val settings = TestKitSettings.create(system)
-    shutdown(system, settings.DefaultActorSystemShutdownTimeout.asJava, settings.ThrowOnShutdownTimeout)
+    shutdown(system, settings.DefaultActorSystemShutdownTimeout.toJava, settings.ThrowOnShutdownTimeout)
   }
 
   /**
@@ -222,7 +222,7 @@ final class ActorTestKit private[pekko] (delegate: pekko.actor.testkit.typed.sca
    * It can only be used for actors that were spawned by this `ActorTestKit`.
    * Other actors will not be stopped by this method.
    */
-  def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.asScala)
+  def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.toScala)
 
   /**
    * Shortcut for creating a new test probe for the testkit actor system
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala
index e384db1714..5bbedea2ad 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala
@@ -17,7 +17,7 @@ import java.time.Duration
 
 import org.apache.pekko
 import pekko.actor.typed.{ ActorRef, Behavior, Props }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Factories for behavior effects for [[BehaviorTestKit]], each effect has a suitable equals and can be used to compare
@@ -94,14 +94,14 @@ object Effects {
   /**
    * The behavior set a new receive timeout, with `message` as timeout notification
    */
-  def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.asScala, message)
+  def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.toScala, message)
 
   /**
    * The behavior used `context.schedule` to schedule `message` to be sent to `target` after `delay`
    * FIXME what about events scheduled through the scheduler?
    */
   def scheduled[U](delay: Duration, target: ActorRef[U], message: U): Scheduled[U] =
-    Scheduled(delay.asScala, target, message)
+    Scheduled(delay.toScala, target, message)
 
   def timerScheduled[U](
       key: Any,
@@ -110,7 +110,7 @@ object Effects {
       mode: TimerScheduled.TimerMode,
       overriding: Boolean,
       send: pekko.japi.function.Effect): TimerScheduled[U] =
-    TimerScheduled(key, msg, delay.asScala, mode, overriding)(send.apply _)
+    TimerScheduled(key, msg, delay.toScala, mode, overriding)(send.apply _)
 
   /**
    * Used to represent an empty list of effects - in other words, the behavior didn't do anything observable
diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala
index 99d526c869..7d7a7bda7a 100644
--- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala
+++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala
@@ -22,7 +22,7 @@ import com.typesafe.config.Config
 import org.apache.pekko
 import pekko.actor.typed.ActorSystem
 import pekko.actor.typed.internal.adapter.SchedulerAdapter
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Manual time allows you to do async tests while controlling the scheduler of the system.
@@ -70,11 +70,11 @@ final class ManualTime(delegate: pekko.testkit.ExplicitlyTriggeredScheduler) {
    * If you want the amount of time passed to be dilated, apply the dilation before passing the delay to
    * this method.
    */
-  def timePasses(amount: Duration): Unit = delegate.timePasses(amount.asScala)
+  def timePasses(amount: Duration): Unit = delegate.timePasses(amount.toScala)
 
   @varargs
   def expectNoMessageFor(duration: Duration, on: TestProbe[_]*): Unit = {
-    delegate.timePasses(duration.asScala)
+    delegate.timePasses(duration.toScala)
     on.foreach(_.expectNoMessage(Duration.ZERO))
   }
 
diff --git a/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java b/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java
index 028d851575..62d9a74916 100644
--- a/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java
+++ b/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java
@@ -24,11 +24,11 @@ import org.apache.pekko.actor.*;
 import org.apache.pekko.testkit.PekkoJUnitActorSystemResource;
 import org.apache.pekko.testkit.PekkoSpec;
 import org.apache.pekko.util.FutureConverters;
-import org.apache.pekko.util.JavaDurationConverters;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.scalatestplus.junit.JUnitSuite;
 import scala.concurrent.Await;
+import scala.jdk.javaapi.DurationConverters;
 
 public class CircuitBreakerTest extends JUnitSuite {
 
@@ -51,8 +51,7 @@ public class CircuitBreakerTest extends JUnitSuite {
     final CompletionStage<String> res = breaker.callWithCircuitBreakerCS(() -> f);
     assertEquals(
         "hello",
-        Await.result(
-            FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds)));
+        Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds)));
   }
 
   @Test
@@ -71,8 +70,7 @@ public class CircuitBreakerTest extends JUnitSuite {
     final CompletionStage<String> res = breaker.callWithCircuitBreakerCS(() -> f, fn);
     assertEquals(
         "hello",
-        Await.result(
-            FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds)));
+        Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds)));
     assertEquals(1, breaker.currentFailureCount());
   }
 }
diff --git a/actor-tests/src/test/java/org/apache/pekko/util/JavaConverterScala3InlineTest.java b/actor-tests/src/test/java/org/apache/pekko/util/JavaConverterScala3InlineTest.java
index 5af2cd6a6a..fe16fa3c2a 100644
--- a/actor-tests/src/test/java/org/apache/pekko/util/JavaConverterScala3InlineTest.java
+++ b/actor-tests/src/test/java/org/apache/pekko/util/JavaConverterScala3InlineTest.java
@@ -17,7 +17,6 @@
 
 package org.apache.pekko.util;
 
-import java.time.Duration;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import scala.Option;
@@ -25,7 +24,7 @@ import scala.concurrent.Future;
 
 /**
  * These tests are here to ensure that methods from {@link org.apache.pekko.util.FutureConverters},
- * {@link org.apache.pekko.util.JavaDurationConverters} and {@link
+ * {@link org.apache.scala.jdk.DurationConverters} and {@link
  * org.apache.pekko.util.OptionConverters} for use within Java can be compiled from with Java
  * sources. This is because methods marked with the Scala 3 inline keyword cannot be called from
  * within Java (see https://github.com/lampepfl/dotty/issues/19346)
@@ -40,7 +39,5 @@ public class JavaConverterScala3InlineTest {
 
     FutureConverters.asJava(Future.successful(""));
     FutureConverters.asScala(CompletableFuture.completedFuture(""));
-
-    JavaDurationConverters.asFiniteDuration(Duration.ofMillis(0));
   }
 }
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala
index 8cd65236e6..7ec90c850b 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala
@@ -21,7 +21,7 @@ import org.slf4j.event.Level
 import org.apache.pekko
 import pekko.annotation.DoNotInherit
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object SupervisorStrategy {
 
@@ -117,7 +117,7 @@ object SupervisorStrategy {
       minBackoff: java.time.Duration,
       maxBackoff: java.time.Duration,
       randomFactor: Double): BackoffSupervisorStrategy =
-    restartWithBackoff(minBackoff.asScala, maxBackoff.asScala, randomFactor)
+    restartWithBackoff(minBackoff.toScala, maxBackoff.toScala, randomFactor)
 
   /**
    * INTERNAL API
@@ -168,7 +168,7 @@ object SupervisorStrategy {
       copy(maxNrOfRetries, withinTimeRange)
 
     override def withLimit(maxNrOfRetries: Int, withinTimeRange: java.time.Duration): RestartSupervisorStrategy =
-      copy(maxNrOfRetries, withinTimeRange.asScala)
+      copy(maxNrOfRetries, withinTimeRange.toScala)
 
     override def withStopChildren(enabled: Boolean): RestartSupervisorStrategy =
       copy(stopChildren = enabled)
@@ -205,9 +205,9 @@ object SupervisorStrategy {
       copy(resetBackoffAfter = timeout)
 
     override def withResetBackoffAfter(timeout: java.time.Duration): BackoffSupervisorStrategy =
-      withResetBackoffAfter(timeout.asScala)
+      withResetBackoffAfter(timeout.toScala)
 
-    override def getResetBackoffAfter: java.time.Duration = resetBackoffAfter.asJava
+    override def getResetBackoffAfter: java.time.Duration = resetBackoffAfter.toJava
 
     override def withMaxRestarts(maxRestarts: Int): BackoffSupervisorStrategy =
       copy(maxRestarts = maxRestarts)
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala
index 3ff6e20801..5300b96dc8 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala
@@ -33,7 +33,7 @@ import pekko.actor.typed.scaladsl.Behaviors
 import pekko.annotation.ApiMayChange
 import pekko.annotation.DoNotInherit
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * `ConsumerController` and [[ProducerController]] or [[WorkPullingProducerController]] are used
@@ -214,8 +214,8 @@ object ConsumerController {
     def apply(config: Config): Settings = {
       new Settings(
         flowControlWindow = config.getInt("flow-control-window"),
-        resendIntervalMin = config.getDuration("resend-interval-min").asScala,
-        resendIntervalMax = config.getDuration("resend-interval-max").asScala,
+        resendIntervalMin = config.getDuration("resend-interval-min").toScala,
+        resendIntervalMax = config.getDuration("resend-interval-max").toScala,
         onlyFlowControl = config.getBoolean("only-flow-control"))
     }
 
@@ -259,19 +259,19 @@ object ConsumerController {
      * Java API
      */
     def withResendIntervalMin(newResendIntervalMin: JavaDuration): Settings =
-      copy(resendIntervalMin = newResendIntervalMin.asScala)
+      copy(resendIntervalMin = newResendIntervalMin.toScala)
 
     /**
      * Java API
      */
     def withResendIntervalMax(newResendIntervalMax: JavaDuration): Settings =
-      copy(resendIntervalMax = newResendIntervalMax.asScala)
+      copy(resendIntervalMax = newResendIntervalMax.toScala)
 
     /**
      * Java API
      */
     def getResendIntervalMax(): JavaDuration =
-      resendIntervalMax.asJava
+      resendIntervalMax.toJava
 
     def withOnlyFlowControl(newOnlyFlowControl: Boolean): Settings =
       copy(onlyFlowControl = newOnlyFlowControl)
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala
index 65e525d0a1..194ff2100a 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala
@@ -32,7 +32,7 @@ import pekko.annotation.ApiMayChange
 import pekko.annotation.InternalApi
 import pekko.util.Helpers.toRootLowerCase
 import pekko.util.Helpers.Requiring
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 /**
@@ -171,9 +171,9 @@ object ProducerController {
           config.getBytes("chunk-large-messages").requiring(_ <= Int.MaxValue, "Too large chunk-large-messages.").toInt
       }
       new Settings(
-        durableQueueRequestTimeout = config.getDuration("durable-queue.request-timeout").asScala,
+        durableQueueRequestTimeout = config.getDuration("durable-queue.request-timeout").toScala,
         durableQueueRetryAttempts = config.getInt("durable-queue.retry-attempts"),
-        durableQueueResendFirstInterval = config.getDuration("durable-queue.resend-first-interval").asScala,
+        durableQueueResendFirstInterval = config.getDuration("durable-queue.resend-first-interval").toScala,
         chunkLargeMessagesBytes)
     }
 
@@ -217,19 +217,19 @@ object ProducerController {
      * Java API
      */
     def withDurableQueueRequestTimeout(newDurableQueueRequestTimeout: JavaDuration): Settings =
-      copy(durableQueueRequestTimeout = newDurableQueueRequestTimeout.asScala)
+      copy(durableQueueRequestTimeout = newDurableQueueRequestTimeout.toScala)
 
     /**
      * Java API
      */
     def withDurableQueueResendFirstInterval(newDurableQueueResendFirstInterval: JavaDuration): Settings =
-      copy(durableQueueResendFirstInterval = newDurableQueueResendFirstInterval.asScala)
+      copy(durableQueueResendFirstInterval = newDurableQueueResendFirstInterval.toScala)
 
     /**
      * Java API
      */
     def getDurableQueueRequestTimeout(): JavaDuration =
-      durableQueueRequestTimeout.asJava
+      durableQueueRequestTimeout.toJava
 
     def withChunkLargeMessagesBytes(newChunkLargeMessagesBytes: Int): Settings =
       copy(chunkLargeMessagesBytes = newChunkLargeMessagesBytes)
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala
index bbe094f3c2..8583466eed 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala
@@ -29,7 +29,7 @@ import pekko.actor.typed.delivery.internal.WorkPullingProducerControllerImpl
 import pekko.actor.typed.receptionist.ServiceKey
 import pekko.actor.typed.scaladsl.Behaviors
 import pekko.annotation.ApiMayChange
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 /**
@@ -164,7 +164,7 @@ object WorkPullingProducerController {
     def apply(config: Config): Settings = {
       new Settings(
         bufferSize = config.getInt("buffer-size"),
-        config.getDuration("internal-ask-timeout").asScala,
+        config.getDuration("internal-ask-timeout").toScala,
         ProducerController.Settings(config))
     }
 
@@ -198,7 +198,7 @@ object WorkPullingProducerController {
       copy(internalAskTimeout = newInternalAskTimeout)
 
     def withInternalAskTimeout(newInternalAskTimeout: java.time.Duration): Settings =
-      copy(internalAskTimeout = newInternalAskTimeout.asScala)
+      copy(internalAskTimeout = newInternalAskTimeout.toScala)
 
     def withProducerControllerSettings(newProducerControllerSettings: ProducerController.Settings): Settings =
       copy(producerControllerSettings = newProducerControllerSettings)
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala
index ec875b6d2d..69e0b6dd6d 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala
@@ -31,7 +31,7 @@ import pekko.annotation.InternalApi
 import pekko.dispatch.ExecutionContexts
 import pekko.pattern.StatusReply
 import pekko.util.BoxedType
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionVal
 import pekko.util.Timeout
 
@@ -201,10 +201,10 @@ import scala.util.Success
   }
 
   override def setReceiveTimeout(duration: java.time.Duration, msg: T): Unit =
-    setReceiveTimeout(duration.asScala, msg)
+    setReceiveTimeout(duration.toScala, msg)
 
   override def scheduleOnce[U](delay: java.time.Duration, target: ActorRef[U], msg: U): pekko.actor.Cancellable =
-    scheduleOnce(delay.asScala, target, msg)
+    scheduleOnce(delay.toScala, target, msg)
 
   override def spawn[U](behavior: pekko.actor.typed.Behavior[U], name: String): pekko.actor.typed.ActorRef[U] =
     spawn(behavior, name, Props.empty)
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala
index b9b09d7605..690fff6aa7 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala
@@ -64,22 +64,22 @@ import scala.concurrent.duration.FiniteDuration
 @InternalApi private[pekko] trait TimerSchedulerCrossDslSupport[T]
     extends scaladsl.TimerScheduler[T]
     with javadsl.TimerScheduler[T] {
-  import pekko.util.JavaDurationConverters._
+  import scala.jdk.DurationConverters._
 
   override final def startTimerWithFixedDelay(key: Any, msg: T, delay: Duration): Unit =
-    startTimerWithFixedDelay(key, msg, delay.asScala)
+    startTimerWithFixedDelay(key, msg, delay.toScala)
 
   override final def startTimerWithFixedDelay(key: Any, msg: T, initialDelay: Duration, delay: Duration): Unit =
-    startTimerWithFixedDelay(key, msg, initialDelay.asScala, delay.asScala)
+    startTimerWithFixedDelay(key, msg, initialDelay.toScala, delay.toScala)
 
   override final def startTimerAtFixedRate(key: Any, msg: T, interval: Duration): Unit =
-    startTimerAtFixedRate(key, msg, interval.asScala)
+    startTimerAtFixedRate(key, msg, interval.toScala)
 
   override final def startTimerAtFixedRate(key: Any, msg: T, initialDelay: Duration, interval: Duration): Unit =
-    startTimerAtFixedRate(key, msg, initialDelay.asScala, interval.asScala)
+    startTimerAtFixedRate(key, msg, initialDelay.toScala, interval.toScala)
 
   override final def startSingleTimer(key: Any, msg: T, delay: Duration): Unit =
-    startSingleTimer(key, msg, delay.asScala)
+    startSingleTimer(key, msg, delay.toScala)
 }
 
 /**
diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala
index 91ccd4ce76..7d6e3e5476 100644
--- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala
+++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala
@@ -23,7 +23,7 @@ import pekko.actor.typed.scaladsl.AskPattern._
 import pekko.japi.function.{ Function => JFunction }
 import pekko.pattern.StatusReply
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * The ask-pattern implements the initiator side of a request–reply protocol.
@@ -49,7 +49,7 @@ object AskPattern {
       messageFactory: JFunction[ActorRef[Res], Req],
       timeout: Duration,
       scheduler: Scheduler): CompletionStage[Res] =
-    actor.ask(messageFactory.apply)(timeout.asScala, scheduler).asJava
+    actor.ask(messageFactory.apply)(timeout.toScala, scheduler).asJava
 
   /**
    * The same as [[ask]] but only for requests that result in a response of type [[pekko.pattern.StatusReply]].
@@ -62,6 +62,6 @@ object AskPattern {
       messageFactory: JFunction[ActorRef[StatusReply[Res]], Req],
       timeout: Duration,
       scheduler: Scheduler): CompletionStage[Res] =
-    actor.askWithStatus(messageFactory.apply)(timeout.asScala, scheduler).asJava
+    actor.askWithStatus(messageFactory.apply)(timeout.toScala, scheduler).asJava
 
 }
diff --git a/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java b/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java
index 305af00116..423dc80b3b 100644
--- a/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java
+++ b/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java
@@ -13,9 +13,9 @@
 
 package org.apache.pekko.actor;
 
-import org.apache.pekko.util.JavaDurationConverters;
 import scala.concurrent.ExecutionContext;
 import scala.concurrent.duration.FiniteDuration;
+import scala.jdk.javaapi.DurationConverters;
 
 /**
  * An Apache Pekko scheduler service. This one needs one special behavior: if Closeable, it MUST
@@ -45,7 +45,7 @@ public abstract class AbstractScheduler extends AbstractSchedulerBase {
    */
   public Cancellable scheduleOnce(
       final java.time.Duration delay, final Runnable runnable, final ExecutionContext executor) {
-    return scheduleOnce(JavaDurationConverters.asFiniteDuration(delay), runnable, executor);
+    return scheduleOnce(DurationConverters.toScala(delay), runnable, executor);
   }
 
   /**
diff --git a/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes b/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes
index 0cefb38664..b56bae7c01 100644
--- a/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes
+++ b/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes
@@ -20,3 +20,9 @@ ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDu
 ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#JavaDurationOps.asScala")
 ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#ScalaDurationOps.asJava$extension")
 ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#ScalaDurationOps.asJava")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$JavaDurationOps")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$JavaDurationOps$")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$ScalaDurationOps")
+ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$ScalaDurationOps$")
\ No newline at end of file
diff --git a/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala b/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala
deleted file mode 100644
index 5588faa389..0000000000
--- a/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * license agreements; and to You under the Apache License, version 2.0:
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * This file is part of the Apache Pekko project, which was derived from Akka.
- */
-
-/*
- * Copyright (C) 2009-2022 Lightbend Inc. <https://www.lightbend.com>
- */
-
-package org.apache.pekko.util
-import java.time.{ Duration => JDuration }
-
-import scala.concurrent.duration.{ Duration, FiniteDuration }
-
-import org.apache.pekko.annotation.InternalStableApi
-
-/**
- * INTERNAL API
- */
-@InternalStableApi
-private[pekko] object JavaDurationConverters {
-  @inline def asFiniteDuration(duration: JDuration): FiniteDuration = duration.asScala
-
-  final implicit class JavaDurationOps(val self: JDuration) extends AnyVal {
-    @inline def asScala: FiniteDuration = Duration.fromNanos(self.toNanos)
-  }
-
-  final implicit class ScalaDurationOps(val self: Duration) extends AnyVal {
-    @inline def asJava: JDuration = JDuration.ofNanos(self.toNanos)
-  }
-}
diff --git a/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala b/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala
deleted file mode 100644
index 6188286fc7..0000000000
--- a/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * license agreements; and to You under the Apache License, version 2.0:
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * This file is part of the Apache Pekko project, which was derived from Akka.
- */
-
-/*
- * Copyright (C) 2009-2022 Lightbend Inc. <https://www.lightbend.com>
- */
-
-package org.apache.pekko.util
-
-import java.time.{ Duration => JDuration }
-
-import scala.concurrent.duration.{ Duration, FiniteDuration }
-
-import org.apache.pekko.annotation.InternalStableApi
-
-/**
- * INTERNAL API
- */
-@InternalStableApi
-private[pekko] object JavaDurationConverters {
-
-  // Ideally this should have the Scala 3 inline keyword but then Java sources are
-  // unable to call this method, see https://github.com/lampepfl/dotty/issues/19346
-  def asFiniteDuration(duration: JDuration): FiniteDuration = duration.asScala
-
-  final implicit class JavaDurationOps(val self: JDuration) extends AnyVal {
-    inline def asScala: FiniteDuration = Duration.fromNanos(self.toNanos)
-  }
-
-  final implicit class ScalaDurationOps(val self: Duration) extends AnyVal {
-    inline def asJava: JDuration = JDuration.ofNanos(self.toNanos)
-  }
-}
diff --git a/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala b/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala
index 000e387acb..a13d670b29 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala
@@ -17,13 +17,12 @@ import java.util.Optional
 
 import scala.annotation.nowarn
 import scala.concurrent.ExecutionContextExecutor
-import scala.concurrent.duration.Duration
+import scala.concurrent.duration.{ Duration, FiniteDuration }
 import scala.runtime.BoxedUnit
 
 import org.apache.pekko
 import pekko.annotation.DoNotInherit
 import pekko.japi.pf.ReceiveBuilder
-import pekko.util.JavaDurationConverters
 
 /**
  * Java API: compatible with lambda expressions
@@ -165,8 +164,12 @@ object AbstractActor {
      * than the ordinary actor message processing thread, such as [[java.util.concurrent.CompletionStage]] and [[scala.concurrent.Future]] callbacks.
      */
     def getReceiveTimeout(): java.time.Duration = {
-      import JavaDurationConverters._
-      receiveTimeout.asJava
+      if (receiveTimeout.isFinite) {
+        import scala.jdk.DurationConverters._
+        receiveTimeout.asInstanceOf[FiniteDuration].toJava
+      } else {
+        java.time.Duration.ZERO
+      }
     }
 
     /**
@@ -189,8 +192,8 @@ object AbstractActor {
      * than the ordinary actor message processing thread, such as [[java.util.concurrent.CompletionStage]] and [[scala.concurrent.Future]] callbacks.
      */
     def setReceiveTimeout(timeout: java.time.Duration): Unit = {
-      import JavaDurationConverters._
-      setReceiveTimeout(timeout.asScala)
+      import scala.jdk.DurationConverters._
+      setReceiveTimeout(timeout.toScala)
     }
 
     /**
diff --git a/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala b/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala
index 52bdd1331b..b252005c92 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala
@@ -17,7 +17,7 @@ import scala.concurrent.duration.FiniteDuration
 
 import org.apache.pekko
 import org.apache.pekko.japi.function.{ Effect, Function2, Predicate, Predicate2, Procedure, Procedure2, Procedure3 }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Java API: compatible with lambda expressions
@@ -123,7 +123,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
       stateName: S,
       stateTimeout: java.time.Duration,
       stateFunctionBuilder: FSMStateFunctionBuilder[S, D]): Unit = {
-    when(stateName, stateTimeout.asScala, stateFunctionBuilder)
+    when(stateName, stateTimeout.toScala, stateFunctionBuilder)
   }
 
   /**
@@ -159,7 +159,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
    * @param timeout state timeout for the initial state, overriding the default timeout for that state
    */
   final def startWith(stateName: S, stateData: D, timeout: java.time.Duration): Unit = {
-    startWith(stateName, stateData, timeout.asScala)
+    startWith(stateName, stateData, timeout.toScala)
   }
 
   /**
@@ -461,7 +461,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
    * in the mailbox when the new timer was started.
    */
   def startTimerWithFixedDelay(name: String, msg: Any, delay: java.time.Duration): Unit =
-    startTimerWithFixedDelay(name, msg, delay.asScala)
+    startTimerWithFixedDelay(name, msg, delay.toScala)
 
   /**
    * Schedules a message to be sent repeatedly to the `self` actor with a
@@ -489,7 +489,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
    * in the mailbox when the new timer was started.
    */
   def startTimerAtFixedRate(name: String, msg: Any, interval: java.time.Duration): Unit =
-    startTimerAtFixedRate(name, msg, interval.asScala)
+    startTimerAtFixedRate(name, msg, interval.toScala)
 
   /**
    * Start a timer that will send `msg` once to the `self` actor after
@@ -501,7 +501,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
    * in the mailbox when the new timer was started.
    */
   def startSingleTimer(name: String, msg: Any, delay: java.time.Duration): Unit =
-    startSingleTimer(name, msg, delay.asScala)
+    startSingleTimer(name, msg, delay.toScala)
 
   /**
    * Default reason if calling `stop()`.
diff --git a/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala b/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala
index e20602b447..5054922692 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala
@@ -30,7 +30,7 @@ import org.apache.pekko
 import pekko.dispatch.ExecutionContexts
 import pekko.pattern.ask
 import pekko.routing.MurmurHash
-import pekko.util.{ Helpers, JavaDurationConverters, Timeout }
+import pekko.util.{ Helpers, Timeout }
 import pekko.util.FutureConverters
 
 /**
@@ -107,8 +107,8 @@ abstract class ActorSelection extends Serializable {
    */
   def resolveOne(timeout: java.time.Duration): CompletionStage[ActorRef] = {
     import FutureConverters._
-    import JavaDurationConverters._
-    resolveOne(timeout.asScala).asJava
+    import scala.jdk.DurationConverters._
+    resolveOne(timeout.toScala).asJava
   }
 
   override def toString: String = {
diff --git a/actor/src/main/scala/org/apache/pekko/actor/FSM.scala b/actor/src/main/scala/org/apache/pekko/actor/FSM.scala
index 7f8e22ced5..59995474d3 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/FSM.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/FSM.scala
@@ -24,7 +24,7 @@ import language.implicitConversions
 import org.apache.pekko
 import pekko.annotation.InternalApi
 import pekko.routing.{ Deafen, Listen, Listeners }
-import pekko.util.{ unused, JavaDurationConverters }
+import pekko.util.unused
 
 object FSM {
 
@@ -293,8 +293,8 @@ object FSM {
      * Use Duration.Inf to deactivate an existing timeout.
      */
     def forMax(timeout: java.time.Duration): State[S, D] = {
-      import JavaDurationConverters._
-      forMax(timeout.asScala)
+      import scala.jdk.DurationConverters._
+      forMax(timeout.toScala)
     }
 
     /**
diff --git a/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala b/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala
index 5e400981ef..5fa527de8e 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala
@@ -18,7 +18,7 @@ import pekko.annotation.InternalApi
 import pekko.event.Logging
 import pekko.event.Logging.{ Error, LogEvent, LogLevel }
 import pekko.japi.Util.immutableSeq
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 import java.lang.reflect.InvocationTargetException
 import java.lang.{ Iterable => JIterable }
@@ -487,7 +487,7 @@ case class AllForOneStrategy(
       withinTimeRange: java.time.Duration,
       decider: SupervisorStrategy.JDecider,
       loggingEnabled: Boolean) =
-    this(maxNrOfRetries, withinTimeRange.asScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider))
+    this(maxNrOfRetries, withinTimeRange.toScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider))
 
   /**
    * Java API
@@ -499,7 +499,7 @@ case class AllForOneStrategy(
    * Java API
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider) =
-    this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(decider))
+    this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(decider))
 
   /**
    * Java API
@@ -511,7 +511,7 @@ case class AllForOneStrategy(
    * Java API
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, trapExit: JIterable[Class[_ <: Throwable]]) =
-    this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(trapExit))
+    this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(trapExit))
 
   /**
    * Java API: compatible with lambda expressions
@@ -523,7 +523,7 @@ case class AllForOneStrategy(
    * Java API: compatible with lambda expressions
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.Decider) =
-    this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.asScala)(decider)
+    this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.toScala)(decider)
 
   /**
    * Java API: compatible with lambda expressions
@@ -599,7 +599,7 @@ case class OneForOneStrategy(
       withinTimeRange: java.time.Duration,
       decider: SupervisorStrategy.JDecider,
       loggingEnabled: Boolean) =
-    this(maxNrOfRetries, withinTimeRange.asScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider))
+    this(maxNrOfRetries, withinTimeRange.toScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider))
 
   /**
    * Java API
@@ -611,7 +611,7 @@ case class OneForOneStrategy(
    * Java API
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider) =
-    this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(decider))
+    this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(decider))
 
   /**
    * Java API
@@ -623,7 +623,7 @@ case class OneForOneStrategy(
    * Java API
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, trapExit: JIterable[Class[_ <: Throwable]]) =
-    this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(trapExit))
+    this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(trapExit))
 
   /**
    * Java API: compatible with lambda expressions
@@ -635,7 +635,7 @@ case class OneForOneStrategy(
    * Java API: compatible with lambda expressions
    */
   def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.Decider) =
-    this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.asScala)(decider)
+    this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.toScala)(decider)
 
   def this(loggingEnabled: Boolean, decider: SupervisorStrategy.Decider) =
     this(loggingEnabled = loggingEnabled)(decider)
diff --git a/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala b/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala
index 89e44bbc59..c6b36af79d 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala
@@ -23,7 +23,6 @@ import scala.util.control.NoStackTrace
 import org.apache.pekko
 import pekko.actor.Scheduler.AtomicCancellable
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters
 
 /**
  * This exception is thrown by Scheduler.schedule* when scheduling is not
@@ -130,8 +129,8 @@ trait Scheduler {
       delay: java.time.Duration,
       runnable: Runnable,
       executor: ExecutionContext): Cancellable = {
-    import JavaDurationConverters._
-    scheduleWithFixedDelay(initialDelay.asScala, delay.asScala)(runnable)(executor)
+    import scala.jdk.DurationConverters._
+    scheduleWithFixedDelay(initialDelay.toScala, delay.toScala)(runnable)(executor)
   }
 
   /**
@@ -188,8 +187,8 @@ trait Scheduler {
       message: Any,
       executor: ExecutionContext,
       sender: ActorRef): Cancellable = {
-    import JavaDurationConverters._
-    scheduleWithFixedDelay(initialDelay.asScala, delay.asScala, receiver, message)(executor, sender)
+    import scala.jdk.DurationConverters._
+    scheduleWithFixedDelay(initialDelay.toScala, delay.toScala, receiver, message)(executor, sender)
   }
 
   /**
@@ -263,8 +262,8 @@ trait Scheduler {
       interval: java.time.Duration,
       runnable: Runnable,
       executor: ExecutionContext): Cancellable = {
-    import JavaDurationConverters._
-    scheduleAtFixedRate(initialDelay.asScala, interval.asScala)(runnable)(executor)
+    import scala.jdk.DurationConverters._
+    scheduleAtFixedRate(initialDelay.toScala, interval.toScala)(runnable)(executor)
   }
 
   /**
@@ -341,8 +340,8 @@ trait Scheduler {
       message: Any,
       executor: ExecutionContext,
       sender: ActorRef): Cancellable = {
-    import JavaDurationConverters._
-    scheduleAtFixedRate(initialDelay.asScala, interval.asScala, receiver, message)(executor, sender)
+    import scala.jdk.DurationConverters._
+    scheduleAtFixedRate(initialDelay.toScala, interval.toScala, receiver, message)(executor, sender)
   }
 
   protected def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, runnable: Runnable)(
@@ -381,8 +380,8 @@ trait Scheduler {
       message: Any,
       executor: ExecutionContext,
       sender: ActorRef): Cancellable = {
-    import JavaDurationConverters._
-    scheduleOnce(delay.asScala, receiver, message)(executor, sender)
+    import scala.jdk.DurationConverters._
+    scheduleOnce(delay.toScala, receiver, message)(executor, sender)
   }
 
   /**
@@ -420,8 +419,8 @@ trait Scheduler {
    * Note: For scheduling within actors `AbstractActorWithTimers` should be preferred.
    */
   def scheduleOnce(delay: java.time.Duration, runnable: Runnable)(implicit executor: ExecutionContext): Cancellable = {
-    import JavaDurationConverters._
-    scheduleOnce(delay.asScala, runnable)(executor)
+    import scala.jdk.DurationConverters._
+    scheduleOnce(delay.toScala, runnable)(executor)
   }
 
   /**
diff --git a/actor/src/main/scala/org/apache/pekko/actor/Timers.scala b/actor/src/main/scala/org/apache/pekko/actor/Timers.scala
index 6a5eaae2c4..20d92f019d 100644
--- a/actor/src/main/scala/org/apache/pekko/actor/Timers.scala
+++ b/actor/src/main/scala/org/apache/pekko/actor/Timers.scala
@@ -18,7 +18,7 @@ import scala.concurrent.duration.FiniteDuration
 import org.apache.pekko
 import pekko.annotation.DoNotInherit
 import pekko.dispatch.Envelope
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionVal
 
 /**
@@ -165,7 +165,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with
    * in the mailbox when the new timer was started.
    */
   final def startTimerWithFixedDelay(key: Any, msg: Any, delay: java.time.Duration): Unit =
-    startTimerWithFixedDelay(key, msg, delay.asScala)
+    startTimerWithFixedDelay(key, msg, delay.toScala)
 
   /**
    * Java API: Schedules a message to be sent repeatedly to the `self` actor with a
@@ -188,7 +188,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with
       msg: Any,
       initialDelay: java.time.Duration,
       delay: java.time.Duration): Unit =
-    startTimerWithFixedDelay(key, msg, initialDelay.asScala, delay.asScala)
+    startTimerWithFixedDelay(key, msg, initialDelay.toScala, delay.toScala)
 
   /**
    * Scala API: Schedules a message to be sent repeatedly to the `self` actor with a
@@ -270,7 +270,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with
    * in the mailbox when the new timer was started.
    */
   final def startTimerAtFixedRate(key: Any, msg: Any, interval: java.time.Duration): Unit =
-    startTimerAtFixedRate(key, msg, interval.asScala)
+    startTimerAtFixedRate(key, msg, interval.toScala)
 
   /**
    * Java API: Schedules a message to be sent repeatedly to the `self` actor with a
@@ -302,7 +302,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with
       msg: Any,
       initialDelay: java.time.Duration,
       interval: java.time.Duration): Unit =
-    startTimerAtFixedRate(key, msg, initialDelay.asScala, interval.asScala)
+    startTimerAtFixedRate(key, msg, initialDelay.toScala, interval.toScala)
 
   /**
    * Start a timer that will send `msg` once to the `self` actor after
@@ -325,7 +325,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with
    * in the mailbox when the new timer was started.
    */
   final def startSingleTimer(key: Any, msg: Any, timeout: java.time.Duration): Unit =
-    startSingleTimer(key, msg, timeout.asScala)
+    startSingleTimer(key, msg, timeout.toScala)
 
   /**
    * Check if a timer with a given `key` is active.
diff --git a/actor/src/main/scala/org/apache/pekko/io/Tcp.scala b/actor/src/main/scala/org/apache/pekko/io/Tcp.scala
index 2e171972c9..3df6f8609a 100644
--- a/actor/src/main/scala/org/apache/pekko/io/Tcp.scala
+++ b/actor/src/main/scala/org/apache/pekko/io/Tcp.scala
@@ -30,7 +30,7 @@ import pekko.annotation.InternalApi
 import pekko.io.Inet._
 import pekko.util.{ ByteString, Helpers }
 import pekko.util.Helpers.Requiring
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 /**
@@ -731,7 +731,7 @@ object TcpMessage {
       localAddress: InetSocketAddress,
       options: JIterable[SocketOption],
       timeout: java.time.Duration,
-      pullMode: Boolean): Command = connect(remoteAddress, localAddress, options, timeout.asScala, pullMode)
+      pullMode: Boolean): Command = connect(remoteAddress, localAddress, options, timeout.toScala, pullMode)
 
   /**
    * Connect to the given `remoteAddress` without binding to a local address and without
diff --git a/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala b/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala
index dafc1b1c79..ec3dadbfb7 100644
--- a/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala
+++ b/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala
@@ -17,7 +17,7 @@ import scala.concurrent.duration.{ Duration, FiniteDuration, _ }
 
 import org.apache.pekko
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object CachePolicy {
 
@@ -28,8 +28,8 @@ object CachePolicy {
   final class Ttl private (val value: FiniteDuration) extends CachePolicy {
     if (value < Duration.Zero)
       throw new IllegalArgumentException(s"TTL values must be a positive value (zero included).")
-    import pekko.util.JavaDurationConverters._
-    def getValue: java.time.Duration = value.asJava
+    import scala.jdk.DurationConverters._
+    def getValue: java.time.Duration = value.toJava
 
     override def equals(other: Any): Boolean = other match {
       case that: Ttl => value == that.value
@@ -49,7 +49,7 @@ object CachePolicy {
           s"Positive TTL values must be a strictly positive value. Use Ttl.never for zero.")
       new Ttl(value)
     }
-    def fromPositive(value: java.time.Duration): Ttl = fromPositive(value.asScala)
+    def fromPositive(value: java.time.Duration): Ttl = fromPositive(value.toScala)
 
     /**
      * INTERNAL API
diff --git a/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala b/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala
index 6fe0e095ea..abea6eee7f 100644
--- a/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala
+++ b/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala
@@ -48,7 +48,7 @@ import pekko.io.dns.IdGenerator.Policy
 import pekko.io.dns.internal.{ ResolvConf, ResolvConfParser }
 import pekko.util.Helpers
 import pekko.util.Helpers.Requiring
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 /** INTERNAL API */
@@ -77,7 +77,7 @@ private[dns] final class DnsSettings(system: ExtendedActorSystem, c: Config) {
     }
   }
 
-  val ResolveTimeout: FiniteDuration = c.getDuration("resolve-timeout").asScala
+  val ResolveTimeout: FiniteDuration = c.getDuration("resolve-timeout").toScala
 
   val PositiveCachePolicy: CachePolicy = getTtl("positive-ttl")
   val NegativeCachePolicy: CachePolicy = getTtl("negative-ttl")
diff --git a/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala b/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala
index 56f7bcfc9a..1abbd1a7b6 100644
--- a/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala
+++ b/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala
@@ -17,7 +17,7 @@ import org.apache.pekko
 import pekko.actor.{ ActorRef, OneForOneStrategy, Props, SupervisorStrategy }
 import pekko.annotation.{ DoNotInherit, InternalApi }
 import pekko.pattern.internal.{ BackoffOnRestartSupervisor, BackoffOnStopSupervisor }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 import scala.concurrent.duration.{ Duration, FiniteDuration }
 
@@ -132,7 +132,7 @@ object BackoffOpts {
       minBackoff: java.time.Duration,
       maxBackoff: java.time.Duration,
       randomFactor: Double): BackoffOnFailureOptions =
-    onFailure(childProps, childName, minBackoff.asScala, maxBackoff.asScala, randomFactor)
+    onFailure(childProps, childName, minBackoff.toScala, maxBackoff.toScala, randomFactor)
 
   /**
    * Back-off options for creating a back-off supervisor actor that expects a child actor to stop on failure.
@@ -254,7 +254,7 @@ object BackoffOpts {
       minBackoff: java.time.Duration,
       maxBackoff: java.time.Duration,
       randomFactor: Double): BackoffOnStopOptions =
-    onStop(childProps, childName, minBackoff.asScala, maxBackoff.asScala, randomFactor)
+    onStop(childProps, childName, minBackoff.toScala, maxBackoff.toScala, randomFactor)
 
 }
 
diff --git a/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala b/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala
index f9e73f7b7a..78be6af1b9 100644
--- a/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala
+++ b/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala
@@ -32,7 +32,7 @@ import pekko.dispatch.ExecutionContexts.parasitic
 import pekko.pattern.internal.{ CircuitBreakerNoopTelemetry, CircuitBreakerTelemetry }
 import pekko.annotation.InternalApi
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
@@ -84,7 +84,7 @@ object CircuitBreaker {
       maxFailures: Int,
       callTimeout: java.time.Duration,
       resetTimeout: java.time.Duration): CircuitBreaker =
-    apply(scheduler, maxFailures, callTimeout.asScala, resetTimeout.asScala)
+    apply(scheduler, maxFailures, callTimeout.toScala, resetTimeout.toScala)
 
   /**
    * Java API: Lookup a CircuitBreaker in registry.
@@ -172,8 +172,8 @@ class CircuitBreaker(
     this(
       scheduler,
       maxFailures,
-      callTimeout.asScala,
-      resetTimeout.asScala,
+      callTimeout.toScala,
+      resetTimeout.toScala,
       maxResetTimeout = 36500.days,
       exponentialBackoffFactor = 1.0,
       randomFactor = 0.0)(executor)
@@ -232,7 +232,7 @@ class CircuitBreaker(
    * @param maxResetTimeout the upper bound of resetTimeout
    */
   def withExponentialBackoff(maxResetTimeout: java.time.Duration): CircuitBreaker = {
-    withExponentialBackoff(maxResetTimeout.asScala)
+    withExponentialBackoff(maxResetTimeout.toScala)
   }
 
   /**
diff --git a/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala b/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala
index de4dd2fab2..47ffe03c57 100644
--- a/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala
+++ b/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala
@@ -21,7 +21,7 @@ import scala.concurrent.ExecutionContext
 import org.apache.pekko
 import pekko.actor.{ ActorSelection, ClassicActorSystemProvider, Scheduler }
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 import scala.annotation.nowarn
 
@@ -106,7 +106,7 @@ object Patterns {
    * }}}
    */
   def ask(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] =
-    scalaAsk(actor, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
+    scalaAsk(actor, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
 
   /**
    * Use for messages whose response is known to be a [[pekko.pattern.StatusReply]]. When a [[pekko.pattern.StatusReply#success]] response
@@ -114,7 +114,7 @@ object Patterns {
    * failed.
    */
   def askWithStatus(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] =
-    scalaAskWithStatus(actor, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
+    scalaAskWithStatus(actor, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
 
   /**
    * A variation of ask which allows to implement "replyTo" pattern by including
@@ -265,7 +265,7 @@ object Patterns {
    * }}}
    */
   def ask(selection: ActorSelection, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] =
-    scalaAsk(selection, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
+    scalaAsk(selection, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
 
   /**
    * <i>Java API for `org.apache.pekko.pattern.ask`:</i>
@@ -333,7 +333,7 @@ object Patterns {
       selection: ActorSelection,
       messageFactory: japi.function.Function[ActorRef, Any],
       timeout: java.time.Duration): CompletionStage[AnyRef] =
-    extended.ask(selection, messageFactory.apply _)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
+    extended.ask(selection, messageFactory.apply _)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]]
 
   /**
    * Register an onComplete callback on this [[scala.concurrent.Future]] to send
@@ -398,7 +398,7 @@ object Patterns {
    * is completed with failure [[pekko.pattern.AskTimeoutException]].
    */
   def gracefulStop(target: ActorRef, timeout: java.time.Duration): CompletionStage[java.lang.Boolean] =
-    scalaGracefulStop(target, timeout.asScala).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
+    scalaGracefulStop(target, timeout.toScala).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
 
   /**
    * Returns a [[scala.concurrent.Future]] that will be completed with success (value `true`) when
@@ -433,7 +433,7 @@ object Patterns {
       target: ActorRef,
       timeout: java.time.Duration,
       stopMessage: Any): CompletionStage[java.lang.Boolean] =
-    scalaGracefulStop(target, timeout.asScala, stopMessage).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
+    scalaGracefulStop(target, timeout.toScala, stopMessage).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
 
   /**
    * Returns a [[scala.concurrent.Future]] that will be completed with the success or failure of the provided Callable
@@ -627,7 +627,7 @@ object Patterns {
     require(attempt != null, "Parameter attempt should not be null.")
     require(minBackoff != null, "Parameter minBackoff should not be null.")
     require(maxBackoff != null, "Parameter minBackoff should not be null.")
-    scalaRetry(() => attempt.call().asScala, attempts, minBackoff.asScala, maxBackoff.asScala, randomFactor)(
+    scalaRetry(() => attempt.call().asScala, attempts, minBackoff.toScala, maxBackoff.toScala, randomFactor)(
       ec,
       scheduler).asJava
   }
@@ -674,7 +674,7 @@ object Patterns {
     scalaRetry(
       () => attempt.call().asScala,
       (t, e) => shouldRetry.test(t, e),
-      attempts, minBackoff.asScala, maxBackoff.asScala, randomFactor)(
+      attempts, minBackoff.toScala, maxBackoff.toScala, randomFactor)(
       ec,
       scheduler).asJava
   }
@@ -759,7 +759,7 @@ object Patterns {
       scheduler: Scheduler,
       ec: ExecutionContext): CompletionStage[T] = {
     require(attempt != null, "Parameter attempt should not be null.")
-    scalaRetry(() => attempt.call().asScala, attempts, delay.asScala)(ec, scheduler).asJava
+    scalaRetry(() => attempt.call().asScala, attempts, delay.toScala)(ec, scheduler).asJava
   }
 
   /**
@@ -792,7 +792,7 @@ object Patterns {
       scheduler: Scheduler,
       ec: ExecutionContext): CompletionStage[T] = {
     require(attempt != null, "Parameter attempt should not be null.")
-    scalaRetry(() => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), attempts, delay.asScala)(ec,
+    scalaRetry(() => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), attempts, delay.toScala)(ec,
       scheduler).asJava
   }
 
@@ -820,7 +820,7 @@ object Patterns {
     scalaRetry(
       () => attempt.call().asScala,
       attempts,
-      attempted => delayFunction.apply(attempted).toScala.map(_.asScala))(context, scheduler).asJava
+      attempted => delayFunction.apply(attempted).toScala.map(_.toScala))(context, scheduler).asJava
   }
 
   /**
@@ -862,6 +862,6 @@ object Patterns {
       () => attempt.call().asScala,
       (t, e) => shouldRetry.test(t, e),
       attempts,
-      attempted => delayFunction.apply(attempted).toScala.map(_.asScala))(context, scheduler).asJava
+      attempted => delayFunction.apply(attempted).toScala.map(_.toScala))(context, scheduler).asJava
   }
 }
diff --git a/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala b/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala
index 3967d264e3..7df960b1f2 100644
--- a/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala
+++ b/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala
@@ -25,7 +25,7 @@ import com.typesafe.config.Config
 import org.apache.pekko
 import pekko.actor._
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 trait OptimalSizeExploringResizer extends Resizer {
 
@@ -71,8 +71,8 @@ case object OptimalSizeExploringResizer {
       lowerBound = resizerCfg.getInt("lower-bound"),
       upperBound = resizerCfg.getInt("upper-bound"),
       chanceOfScalingDownWhenFull = resizerCfg.getDouble("chance-of-ramping-down-when-full"),
-      actionInterval = resizerCfg.getDuration("action-interval").asScala,
-      downsizeAfterUnderutilizedFor = resizerCfg.getDuration("downsize-after-underutilized-for").asScala,
+      actionInterval = resizerCfg.getDuration("action-interval").toScala,
+      downsizeAfterUnderutilizedFor = resizerCfg.getDuration("downsize-after-underutilized-for").toScala,
       numOfAdjacentSizesToConsiderDuringOptimization = resizerCfg.getInt("optimization-range"),
       exploreStepSize = resizerCfg.getDouble("explore-step-size"),
       explorationProbability = resizerCfg.getDouble("chance-of-exploration"),
@@ -269,7 +269,7 @@ case class DefaultOptimalSizeExploringResizer(
     val now = LocalDateTime.now
     val proposedChange =
       if (record.underutilizationStreak.fold(false)(
-          _.start.isBefore(now.minus(downsizeAfterUnderutilizedFor.asJava)))) {
+          _.start.isBefore(now.minus(downsizeAfterUnderutilizedFor.asInstanceOf[FiniteDuration].toJava)))) {
         val downsizeTo = (record.underutilizationStreak.get.highestUtilization * downsizeRatio).toInt
         Math.min(downsizeTo - currentSize, 0)
       } else if (performanceLog.isEmpty || record.underutilizationStreak.isDefined) {
diff --git a/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala b/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala
index 5a24ae78a0..f4b58e9665 100644
--- a/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala
+++ b/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala
@@ -32,7 +32,7 @@ import pekko.japi.Util.immutableSeq
 import pekko.pattern.ask
 import pekko.pattern.pipe
 import pekko.util.Helpers.ConfigOps
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -142,7 +142,7 @@ final case class ScatterGatherFirstCompletedPool(
    * @param within expecting at least one reply within this duration, otherwise
    *   it will reply with [[pekko.pattern.AskTimeoutException]] in a [[pekko.actor.Status.Failure]]
    */
-  def this(nr: Int, within: java.time.Duration) = this(nr, within.asScala)
+  def this(nr: Int, within: java.time.Duration) = this(nr, within.toScala)
 
   override def createRouter(system: ActorSystem): Router = new Router(ScatterGatherFirstCompletedRoutingLogic(within))
 
@@ -218,7 +218,7 @@ final case class ScatterGatherFirstCompletedGroup(
    *   it will reply with [[pekko.pattern.AskTimeoutException]] in a [[pekko.actor.Status.Failure]]
    */
   def this(routeePaths: java.lang.Iterable[String], within: java.time.Duration) =
-    this(immutableSeq(routeePaths), within.asScala)
+    this(immutableSeq(routeePaths), within.toScala)
 
   override def paths(system: ActorSystem): immutable.Iterable[String] = this.paths
 
diff --git a/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala b/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala
index 5343bdd176..00a47c727b 100644
--- a/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala
+++ b/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala
@@ -28,7 +28,7 @@ import pekko.dispatch.Dispatchers
 import pekko.japi.Util.immutableSeq
 import pekko.pattern.{ ask, pipe, AskTimeoutException }
 import pekko.util.Helpers.ConfigOps
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -197,7 +197,7 @@ final case class TailChoppingPool(
    * @param interval duration after which next routee will be picked
    */
   def this(nr: Int, within: java.time.Duration, interval: java.time.Duration) =
-    this(nr, within.asScala, interval.asScala)
+    this(nr, within.toScala, interval.toScala)
 
   override def createRouter(system: ActorSystem): Router =
     new Router(
@@ -291,7 +291,7 @@ final case class TailChoppingGroup(
    * @param interval duration after which next routee will be picked
    */
   def this(routeePaths: java.lang.Iterable[String], within: java.time.Duration, interval: java.time.Duration) =
-    this(immutableSeq(routeePaths), within.asScala, interval.asScala)
+    this(immutableSeq(routeePaths), within.toScala, interval.toScala)
 
   override def createRouter(system: ActorSystem): Router =
     new Router(
diff --git a/actor/src/main/scala/org/apache/pekko/util/Timeout.scala b/actor/src/main/scala/org/apache/pekko/util/Timeout.scala
index 6adcb4c281..245fdf475b 100644
--- a/actor/src/main/scala/org/apache/pekko/util/Timeout.scala
+++ b/actor/src/main/scala/org/apache/pekko/util/Timeout.scala
@@ -47,8 +47,8 @@ object Timeout {
    * Create a Timeout from java.time.Duration.
    */
   def create(duration: java.time.Duration): Timeout = {
-    import JavaDurationConverters._
-    new Timeout(duration.asScala)
+    import scala.jdk.DurationConverters._
+    new Timeout(duration.toScala)
   }
 
   implicit def durationToTimeout(duration: FiniteDuration): Timeout = new Timeout(duration)
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala
index 3373754f7a..137149bb8a 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala
@@ -20,7 +20,7 @@ import pekko.actor.typed.ActorRef
 import pekko.cluster.sharding.ShardRegion.ClusterShardingStats
 import pekko.cluster.sharding.ShardRegion.CurrentShardRegionState
 import pekko.cluster.sharding.typed.scaladsl.EntityTypeKey
-import pekko.util.JavaDurationConverters
+import scala.jdk.DurationConverters._
 
 /**
  * Protocol for querying sharding state e.g. A ShardRegion's state
@@ -77,5 +77,5 @@ final case class GetClusterShardingStats(
       entityTypeKey: javadsl.EntityTypeKey[_],
       timeout: java.time.Duration,
       replyTo: ActorRef[ClusterShardingStats]) =
-    this(entityTypeKey.asScala, JavaDurationConverters.asFiniteDuration(timeout), replyTo)
+    this(entityTypeKey.asScala, timeout.toScala, replyTo)
 }
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala
index f9658c34d4..a076806088 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala
@@ -28,7 +28,7 @@ import pekko.cluster.typed.Cluster
 import pekko.cluster.typed.ClusterSingletonManagerSettings
 import pekko.coordination.lease.LeaseUsageSettings
 import pekko.japi.Util.immutableSeq
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object ClusterShardingSettings {
 
@@ -315,11 +315,11 @@ object ClusterShardingSettings {
 
       def withTimeout(timeout: FiniteDuration): IdleSettings = copy(timeout = timeout)
 
-      def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.asScala)
+      def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.toScala)
 
       def withInterval(interval: FiniteDuration): IdleSettings = copy(interval = Some(interval))
 
-      def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.asScala)
+      def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.toScala)
 
       private def copy(timeout: FiniteDuration = timeout, interval: Option[FiniteDuration] = interval): IdleSettings =
         new IdleSettings(timeout, interval)
@@ -708,37 +708,37 @@ object ClusterShardingSettings {
     def withBufferSize(value: Int): TuningParameters = copy(bufferSize = value)
     def withCoordinatorFailureBackoff(value: FiniteDuration): TuningParameters = copy(coordinatorFailureBackoff = value)
     def withCoordinatorFailureBackoff(value: java.time.Duration): TuningParameters =
-      withCoordinatorFailureBackoff(value.asScala)
+      withCoordinatorFailureBackoff(value.toScala)
     def withEntityRecoveryConstantRateStrategyFrequency(value: FiniteDuration): TuningParameters =
       copy(entityRecoveryConstantRateStrategyFrequency = value)
     def withEntityRecoveryConstantRateStrategyFrequency(value: java.time.Duration): TuningParameters =
-      withEntityRecoveryConstantRateStrategyFrequency(value.asScala)
+      withEntityRecoveryConstantRateStrategyFrequency(value.toScala)
     def withEntityRecoveryConstantRateStrategyNumberOfEntities(value: Int): TuningParameters =
       copy(entityRecoveryConstantRateStrategyNumberOfEntities = value)
     def withEntityRecoveryStrategy(value: java.lang.String): TuningParameters = copy(entityRecoveryStrategy = value)
     def withEntityRestartBackoff(value: FiniteDuration): TuningParameters = copy(entityRestartBackoff = value)
-    def withEntityRestartBackoff(value: java.time.Duration): TuningParameters = withEntityRestartBackoff(value.asScala)
+    def withEntityRestartBackoff(value: java.time.Duration): TuningParameters = withEntityRestartBackoff(value.toScala)
     def withHandOffTimeout(value: FiniteDuration): TuningParameters = copy(handOffTimeout = value)
-    def withHandOffTimeout(value: java.time.Duration): TuningParameters = withHandOffTimeout(value.asScala)
+    def withHandOffTimeout(value: java.time.Duration): TuningParameters = withHandOffTimeout(value.toScala)
     def withKeepNrOfBatches(value: Int): TuningParameters = copy(keepNrOfBatches = value)
     def withLeastShardAllocationMaxSimultaneousRebalance(value: Int): TuningParameters =
       copy(leastShardAllocationMaxSimultaneousRebalance = value)
     def withLeastShardAllocationRebalanceThreshold(value: Int): TuningParameters =
       copy(leastShardAllocationRebalanceThreshold = value)
     def withRebalanceInterval(value: FiniteDuration): TuningParameters = copy(rebalanceInterval = value)
-    def withRebalanceInterval(value: java.time.Duration): TuningParameters = withRebalanceInterval(value.asScala)
+    def withRebalanceInterval(value: java.time.Duration): TuningParameters = withRebalanceInterval(value.toScala)
     def withRetryInterval(value: FiniteDuration): TuningParameters = copy(retryInterval = value)
-    def withRetryInterval(value: java.time.Duration): TuningParameters = withRetryInterval(value.asScala)
+    def withRetryInterval(value: java.time.Duration): TuningParameters = withRetryInterval(value.toScala)
     def withShardFailureBackoff(value: FiniteDuration): TuningParameters = copy(shardFailureBackoff = value)
-    def withShardFailureBackoff(value: java.time.Duration): TuningParameters = withShardFailureBackoff(value.asScala)
+    def withShardFailureBackoff(value: java.time.Duration): TuningParameters = withShardFailureBackoff(value.toScala)
     def withShardStartTimeout(value: FiniteDuration): TuningParameters = copy(shardStartTimeout = value)
-    def withShardStartTimeout(value: java.time.Duration): TuningParameters = withShardStartTimeout(value.asScala)
+    def withShardStartTimeout(value: java.time.Duration): TuningParameters = withShardStartTimeout(value.toScala)
     def withSnapshotAfter(value: Int): TuningParameters = copy(snapshotAfter = value)
     def withUpdatingStateTimeout(value: FiniteDuration): TuningParameters = copy(updatingStateTimeout = value)
-    def withUpdatingStateTimeout(value: java.time.Duration): TuningParameters = withUpdatingStateTimeout(value.asScala)
+    def withUpdatingStateTimeout(value: java.time.Duration): TuningParameters = withUpdatingStateTimeout(value.toScala)
     def withWaitingForStateTimeout(value: FiniteDuration): TuningParameters = copy(waitingForStateTimeout = value)
     def withWaitingForStateTimeout(value: java.time.Duration): TuningParameters =
-      withWaitingForStateTimeout(value.asScala)
+      withWaitingForStateTimeout(value.toScala)
     def withCoordinatorStateWriteMajorityPlus(value: Int): TuningParameters =
       copy(coordinatorStateWriteMajorityPlus = value)
     def withCoordinatorStateReadMajorityPlus(value: Int): TuningParameters =
@@ -887,7 +887,7 @@ final class ClusterShardingSettings(
     copy(shardRegionQueryTimeout = duration)
 
   def withShardRegionQueryTimeout(duration: java.time.Duration): ClusterShardingSettings =
-    copy(shardRegionQueryTimeout = duration.asScala)
+    copy(shardRegionQueryTimeout = duration.toScala)
 
   def withLeaseSettings(leaseSettings: LeaseUsageSettings) = copy(leaseSettings = Option(leaseSettings))
 
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala
index 40f97680bb..05d27d48f2 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala
@@ -22,7 +22,7 @@ import com.typesafe.config.Config
 import org.apache.pekko
 import pekko.actor.typed.ActorSystem
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object ShardedDaemonProcessSettings {
 
@@ -39,7 +39,7 @@ object ShardedDaemonProcessSettings {
    * Load settings from a specific config location.
    */
   def fromConfig(config: Config): ShardedDaemonProcessSettings = {
-    val keepAliveInterval = config.getDuration("keep-alive-interval").asScala
+    val keepAliveInterval = config.getDuration("keep-alive-interval").toScala
 
     new ShardedDaemonProcessSettings(keepAliveInterval, None, None)
   }
@@ -68,7 +68,7 @@ final class ShardedDaemonProcessSettings @InternalApi private[pekko] (
    * Note: How the sharded set is kept alive may change in the future meaning this setting may go away.
    */
   def withKeepAliveInterval(keepAliveInterval: Duration): ShardedDaemonProcessSettings =
-    copy(keepAliveInterval = keepAliveInterval.asScala)
+    copy(keepAliveInterval = keepAliveInterval.toScala)
 
   /**
    * Specify sharding settings that should be used for the sharded daemon process instead of loading from config.
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala
index d0e22becd2..7e188b22e2 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala
@@ -32,7 +32,7 @@ import pekko.actor.typed.scaladsl.Behaviors
 import pekko.annotation.ApiMayChange
 import pekko.cluster.sharding.typed.ShardingEnvelope
 import pekko.cluster.sharding.typed.delivery.internal.ShardingProducerControllerImpl
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 /**
@@ -185,9 +185,9 @@ object ShardingProducerController {
     def apply(config: Config): Settings = {
       new Settings(
         bufferSize = config.getInt("buffer-size"),
-        config.getDuration("internal-ask-timeout").asScala,
-        config.getDuration("cleanup-unused-after").asScala,
-        config.getDuration("resend-first-unconfirmed-idle-timeout").asScala,
+        config.getDuration("internal-ask-timeout").toScala,
+        config.getDuration("cleanup-unused-after").toScala,
+        config.getDuration("resend-first-unconfirmed-idle-timeout").toScala,
         ProducerController.Settings(config))
     }
 
@@ -223,19 +223,19 @@ object ShardingProducerController {
       copy(internalAskTimeout = newInternalAskTimeout)
 
     def withInternalAskTimeout(newInternalAskTimeout: java.time.Duration): Settings =
-      copy(internalAskTimeout = newInternalAskTimeout.asScala)
+      copy(internalAskTimeout = newInternalAskTimeout.toScala)
 
     def withCleanupUnusedAfter(newCleanupUnusedAfter: FiniteDuration): Settings =
       copy(cleanupUnusedAfter = newCleanupUnusedAfter)
 
     def withCleanupUnusedAfter(newCleanupUnusedAfter: java.time.Duration): Settings =
-      copy(cleanupUnusedAfter = newCleanupUnusedAfter.asScala)
+      copy(cleanupUnusedAfter = newCleanupUnusedAfter.toScala)
 
     def withResendFirstUnconfirmedIdleTimeout(newResendFirstUnconfirmedIdleTimeout: FiniteDuration): Settings =
       copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout)
 
     def withResendFirstUnconfirmedIdleTimeout(newResendFirstUnconfirmedIdleTimeout: java.time.Duration): Settings =
-      copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout.asScala)
+      copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout.toScala)
 
     def withProducerControllerSettings(newProducerControllerSettings: ProducerController.Settings): Settings =
       copy(producerControllerSettings = newProducerControllerSettings)
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala
index 6ae172ec00..9ac9c58eb3 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala
@@ -51,7 +51,7 @@ import pekko.pattern.PromiseActorRef
 import pekko.pattern.StatusReply
 import pekko.util.{ unused, ByteString, Timeout }
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * INTERNAL API
@@ -346,13 +346,13 @@ import pekko.util.JavaDurationConverters._
   }
 
   override def ask[U](message: JFunction[ActorRef[U], M], timeout: Duration): CompletionStage[U] =
-    ask[U](replyTo => message.apply(replyTo))(timeout.asScala).asJava
+    ask[U](replyTo => message.apply(replyTo))(timeout.toScala).asJava
 
   override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M)(implicit timeout: Timeout): Future[Res] =
     StatusReply.flattenStatusFuture(ask[StatusReply[Res]](f))
 
   override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M, timeout: Duration): CompletionStage[Res] =
-    askWithStatus(f.apply)(timeout.asScala).asJava
+    askWithStatus(f.apply)(timeout.toScala).asJava
 
   /** Similar to [[pekko.actor.typed.scaladsl.AskPattern.PromiseRef]] but for an `EntityRef` target. */
   @InternalApi
diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala
index 06d4b36fba..394ecc844f 100644
--- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala
+++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala
@@ -29,7 +29,7 @@ import pekko.cluster.sharding.typed.scaladsl
 import pekko.japi.function.{ Function => JFunction }
 import pekko.pattern.StatusReply
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -57,10 +57,10 @@ import pekko.util.Timeout
   }
 
   def ask[U](message: JFunction[ActorRef[U], M], timeout: Duration): CompletionStage[U] =
-    ask[U](replyTo => message.apply(replyTo))(timeout.asScala).asJava
+    ask[U](replyTo => message.apply(replyTo))(timeout.toScala).asJava
 
   override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M, timeout: Duration): CompletionStage[Res] =
-    askWithStatus(f)(timeout.asScala).asJava
+    askWithStatus(f)(timeout.toScala).asJava
 
   override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M)(implicit timeout: Timeout): Future[Res] =
     StatusReply.flattenStatusFuture(ask(f))
diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala
index cf11c08ae2..cd1e7e3a18 100644
--- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala
+++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala
@@ -23,7 +23,7 @@ import pekko.util.Timeout
 import pekko.annotation.InternalApi
 import pekko.pattern.AskTimeoutException
 import pekko.util.ccompat.JavaConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
@@ -38,7 +38,7 @@ private[pekko] object ClusterShardingHealthCheckSettings {
   def apply(config: Config): ClusterShardingHealthCheckSettings =
     new ClusterShardingHealthCheckSettings(
       config.getStringList("names").asScala.toSet,
-      config.getDuration("timeout").asScala)
+      config.getDuration("timeout").toScala)
 }
 
 @ApiMayChange
diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala
index 114b04350d..14431679e2 100644
--- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala
+++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala
@@ -22,7 +22,7 @@ import pekko.cluster.singleton.ClusterSingletonManagerSettings
 import pekko.coordination.lease.LeaseUsageSettings
 import pekko.japi.Util.immutableSeq
 import pekko.util.Helpers.toRootLowerCase
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import com.typesafe.config.Config
 
 import scala.collection.immutable
@@ -104,7 +104,7 @@ object ClusterShardingSettings {
 
     val lease = config.getString("use-lease") match {
       case s if s.isEmpty => None
-      case other          => Some(new LeaseUsageSettings(other, config.getDuration("lease-retry-interval").asScala))
+      case other          => Some(new LeaseUsageSettings(other, config.getDuration("lease-retry-interval").toScala))
     }
 
     new ClusterShardingSettings(
@@ -271,11 +271,11 @@ object ClusterShardingSettings {
 
       def withTimeout(timeout: FiniteDuration): IdleSettings = copy(timeout = timeout)
 
-      def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.asScala)
+      def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.toScala)
 
       def withInterval(interval: FiniteDuration): IdleSettings = copy(interval = Some(interval))
 
-      def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.asScala)
+      def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.toScala)
 
       private def copy(timeout: FiniteDuration = timeout, interval: Option[FiniteDuration] = interval): IdleSettings =
         new IdleSettings(timeout, interval)
@@ -1019,7 +1019,7 @@ final class ClusterShardingSettings(
     copy(shardRegionQueryTimeout = duration)
 
   def withShardRegionQueryTimeout(duration: java.time.Duration): ClusterShardingSettings =
-    copy(shardRegionQueryTimeout = duration.asScala)
+    copy(shardRegionQueryTimeout = duration.toScala)
 
   def withLeaseSettings(leaseSettings: LeaseUsageSettings): ClusterShardingSettings =
     copy(leaseSettings = Some(leaseSettings))
diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala
index bf2fb5a78b..dab9fe9b15 100644
--- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala
+++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala
@@ -39,7 +39,7 @@ import pekko.cluster.sharding.ShardRegion.ShardId
 import pekko.event.Logging
 import pekko.pattern.AskTimeoutException
 import pekko.util.Timeout
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object ExternalShardAllocationStrategy {
 
@@ -66,7 +66,7 @@ object ExternalShardAllocationStrategy {
    */
   def create(systemProvider: ClassicActorSystemProvider, typeName: String, timeout: java.time.Duration)
       : ExternalShardAllocationStrategy =
-    this.apply(systemProvider, typeName, timeout.asScala)
+    this.apply(systemProvider, typeName, timeout.toScala)
 
   // local only messages
   private[pekko] final case class GetShardLocation(shard: ShardId)
diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala
index 8b9dd5291c..d795db5eca 100644
--- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala
+++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala
@@ -45,7 +45,7 @@ import pekko.dispatch.MessageDispatcher
 import pekko.event.Logging
 import pekko.pattern.ask
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.PrettyDuration._
 import pekko.util.Timeout
 import pekko.util.ccompat.JavaConverters._
@@ -66,7 +66,7 @@ final private[external] class ExternalShardAllocationClientImpl(system: ActorSys
   private val timeout =
     system.settings.config
       .getDuration("pekko.cluster.sharding.external-shard-allocation-strategy.client-timeout")
-      .asScala
+      .toScala
   private implicit val askTimeout: Timeout = Timeout(timeout * 2)
   private implicit val ec: MessageDispatcher = system.dispatchers.internalDispatcher
 
diff --git a/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala b/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala
index 62e86945ca..f60ae4fc49 100644
--- a/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala
+++ b/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala
@@ -47,7 +47,7 @@ import pekko.event.Logging
 import pekko.event.MarkerLoggingAdapter
 import pekko.pattern.ask
 import pekko.pattern.pipe
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 object ClusterSingletonManagerSettings {
@@ -70,7 +70,7 @@ object ClusterSingletonManagerSettings {
     val lease = config.getString("use-lease") match {
       case s if s.isEmpty  => None
       case leaseConfigPath =>
-        Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala))
+        Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").toScala))
     }
     new ClusterSingletonManagerSettings(
       singletonName = config.getString("singleton-name"),
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala
index b8e25201d3..8292b3994a 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala
@@ -25,7 +25,7 @@ import pekko.annotation.InternalApi
 import pekko.cluster.{ ddata => dd }
 import pekko.cluster.ddata.ReplicatedData
 import pekko.pattern.ask
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -84,7 +84,7 @@ import pekko.util.Timeout
               case cmd: JReplicator.Get[d] =>
                 implicit val timeout: Timeout = Timeout(cmd.consistency.timeout match {
                   case java.time.Duration.ZERO => localAskTimeout
-                  case t                       => t.asScala + additionalAskTimeout
+                  case t                       => t.toScala + additionalAskTimeout
                 })
                 import ctx.executionContext
                 val reply =
@@ -112,7 +112,7 @@ import pekko.util.Timeout
               case cmd: JReplicator.Update[d] =>
                 implicit val timeout: Timeout = Timeout(cmd.writeConsistency.timeout match {
                   case java.time.Duration.ZERO => localAskTimeout
-                  case t                       => t.asScala + additionalAskTimeout
+                  case t                       => t.toScala + additionalAskTimeout
                 })
                 import ctx.executionContext
                 val reply =
@@ -179,7 +179,7 @@ import pekko.util.Timeout
               case cmd: JReplicator.Delete[d] =>
                 implicit val timeout: Timeout = Timeout(cmd.consistency.timeout match {
                   case java.time.Duration.ZERO => localAskTimeout
-                  case t                       => t.asScala + additionalAskTimeout
+                  case t                       => t.toScala + additionalAskTimeout
                 })
                 import ctx.executionContext
                 val reply =
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala
index 7c8ce8400a..097dc36222 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala
@@ -27,7 +27,7 @@ import pekko.annotation.DoNotInherit
 import pekko.annotation.InternalApi
 import pekko.cluster.ddata.ReplicatedData
 import pekko.cluster.ddata.SelfUniqueAddress
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object DistributedData extends ExtensionId[DistributedData] {
   def get(system: ActorSystem[_]): DistributedData = apply(system)
@@ -62,7 +62,7 @@ object DistributedData extends ExtensionId[DistributedData] {
         new ReplicatorMessageAdapter[A, B](
           context,
           distributedData.replicator,
-          distributedData.unexpectedAskTimeout.asJava)
+          distributedData.unexpectedAskTimeout.toJava)
       factory(replicatorAdapter)
     }
   }
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala
index 014f74457c..6f8fa07079 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala
@@ -27,7 +27,7 @@ import pekko.cluster.{ ddata => dd }
 import pekko.cluster.ddata.Key
 import pekko.cluster.ddata.ReplicatedData
 import pekko.cluster.ddata.typed.internal.ReplicatorBehavior
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * @see [[pekko.cluster.ddata.Replicator]].
@@ -66,18 +66,18 @@ object Replicator {
     require(n >= 2, "ReadFrom n must be >= 2, use ReadLocal for n=1")
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadFrom(n, timeout.asScala)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadFrom(n, timeout.toScala)
   }
   final case class ReadMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency {
     def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap)
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadMajority(timeout.asScala, minCap)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadMajority(timeout.toScala, minCap)
   }
   final case class ReadAll(timeout: Duration) extends ReadConsistency {
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadAll(timeout.asScala)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadAll(timeout.toScala)
   }
 
   sealed trait WriteConsistency {
@@ -96,18 +96,18 @@ object Replicator {
     require(n >= 2, "WriteTo n must be >= 2, use WriteLocal for n=1")
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteTo(n, timeout.asScala)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteTo(n, timeout.toScala)
   }
   final case class WriteMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends WriteConsistency {
     def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap)
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteMajority(timeout.asScala, minCap)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteMajority(timeout.toScala, minCap)
   }
   final case class WriteAll(timeout: Duration) extends WriteConsistency {
 
     /** INTERNAL API */
-    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteAll(timeout.asScala)
+    @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteAll(timeout.toScala)
   }
 
   /**
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala
index d6cf1e39d7..fffe6a91d0 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala
@@ -26,7 +26,7 @@ import pekko.actor.typed.ActorRef
 import pekko.actor.typed.javadsl.ActorContext
 import pekko.cluster.ddata.Key
 import pekko.cluster.ddata.ReplicatedData
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -66,7 +66,7 @@ class ReplicatorMessageAdapter[A, B <: ReplicatedData](
     replicator: ActorRef[Replicator.Command],
     unexpectedAskTimeout: Duration) {
 
-  private implicit val askTimeout: Timeout = Timeout(unexpectedAskTimeout.asScala)
+  private implicit val askTimeout: Timeout = Timeout(unexpectedAskTimeout.toScala)
 
   private var changedMessageAdapters: Map[Key[B], ActorRef[Replicator.SubscribeResponse[B]]] = Map.empty
 
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala
index b3ef6aaf69..cf8df3870d 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala
@@ -28,7 +28,7 @@ import pekko.cluster.{ ddata => dd }
 import pekko.cluster.Cluster
 import pekko.cluster.ddata.ReplicatedData
 import pekko.cluster.ddata.SelfUniqueAddress
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object DistributedData extends ExtensionId[DistributedData] {
   def get(system: ActorSystem[_]): DistributedData = apply(system)
@@ -85,7 +85,7 @@ class DistributedData(system: ActorSystem[_]) extends Extension {
   @InternalApi private[pekko] val unexpectedAskTimeout: FiniteDuration =
     system.settings.config
       .getDuration("pekko.cluster.ddata.typed.replicator-message-adapter-unexpected-ask-timeout")
-      .asScala
+      .toScala
 
   private val classicSystem = system.toClassic.asInstanceOf[ExtendedActorSystem]
 
diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala
index c8ad70ce8b..2ca2a039f9 100644
--- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala
+++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala
@@ -25,7 +25,7 @@ import pekko.cluster.singleton.{
 }
 import pekko.cluster.typed.internal.AdaptedClusterSingletonImpl
 import pekko.coordination.lease.LeaseUsageSettings
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import com.typesafe.config.Config
 
 object ClusterSingletonSettings {
@@ -73,13 +73,13 @@ final class ClusterSingletonSettings(
   def withRemovalMargin(removalMargin: FiniteDuration): ClusterSingletonSettings = copy(removalMargin = removalMargin)
 
   def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonSettings =
-    withRemovalMargin(removalMargin.asScala)
+    withRemovalMargin(removalMargin.toScala)
 
   def withHandoverRetryInterval(handOverRetryInterval: FiniteDuration): ClusterSingletonSettings =
     copy(handOverRetryInterval = handOverRetryInterval)
 
   def withHandoverRetryInterval(handOverRetryInterval: java.time.Duration): ClusterSingletonSettings =
-    withHandoverRetryInterval(handOverRetryInterval.asScala)
+    withHandoverRetryInterval(handOverRetryInterval.toScala)
 
   def withBufferSize(bufferSize: Int): ClusterSingletonSettings = copy(bufferSize = bufferSize)
 
@@ -237,7 +237,7 @@ object ClusterSingletonManagerSettings {
     val lease = config.getString("use-lease") match {
       case s if s.isEmpty  => None
       case leaseConfigPath =>
-        Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala))
+        Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").toScala))
     }
     new ClusterSingletonManagerSettings(
       singletonName = config.getString("singleton-name"),
@@ -303,13 +303,13 @@ final class ClusterSingletonManagerSettings(
     copy(removalMargin = removalMargin)
 
   def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonManagerSettings =
-    withRemovalMargin(removalMargin.asScala)
+    withRemovalMargin(removalMargin.toScala)
 
   def withHandOverRetryInterval(retryInterval: FiniteDuration): ClusterSingletonManagerSettings =
     copy(handOverRetryInterval = retryInterval)
 
   def withHandOverRetryInterval(retryInterval: java.time.Duration): ClusterSingletonManagerSettings =
-    withHandOverRetryInterval(retryInterval.asScala)
+    withHandOverRetryInterval(retryInterval.toScala)
 
   def withLeaseSettings(leaseSettings: LeaseUsageSettings) = copy(leaseSettings = Option(leaseSettings))
 
diff --git a/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala b/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala
index f5271a4c4c..16cc22838f 100644
--- a/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala
+++ b/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala
@@ -37,7 +37,7 @@ import pekko.stream.scaladsl.StreamRefs
 import pekko.stream.testkit.TestSubscriber
 import pekko.stream.testkit.scaladsl.TestSink
 import pekko.testkit._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object StreamRefSpec extends MultiNodeConfig {
   val first = role("first")
diff --git a/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala b/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala
index 19f617d4b1..db3f3b7df0 100644
--- a/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala
+++ b/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala
@@ -16,12 +16,12 @@ package org.apache.pekko.coordination.lease
 import scala.concurrent.duration.FiniteDuration
 
 import org.apache.pekko
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.PrettyDuration._
 
 final class LeaseUsageSettings private[pekko] (val leaseImplementation: String,
     val leaseRetryInterval: FiniteDuration) {
-  def getLeaseRetryInterval(): java.time.Duration = leaseRetryInterval.asJava
+  def getLeaseRetryInterval(): java.time.Duration = leaseRetryInterval.toJava
 
   override def toString = s"LeaseUsageSettings($leaseImplementation, ${leaseRetryInterval.pretty})"
 }
diff --git a/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala b/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala
index fe21bb6a5d..d3e0bb1195 100644
--- a/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala
+++ b/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala
@@ -17,18 +17,18 @@ import scala.concurrent.duration._
 
 import com.typesafe.config.{ Config, ConfigValueType }
 
-import org.apache.pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object TimeoutSettings {
   def apply(config: Config): TimeoutSettings = {
-    val heartBeatTimeout = config.getDuration("heartbeat-timeout").asScala
+    val heartBeatTimeout = config.getDuration("heartbeat-timeout").toScala
     val heartBeatInterval = config.getValue("heartbeat-interval").valueType() match {
       case ConfigValueType.STRING if config.getString("heartbeat-interval").isEmpty =>
         (heartBeatTimeout / 10).max(5.seconds)
-      case _ => config.getDuration("heartbeat-interval").asScala
+      case _ => config.getDuration("heartbeat-interval").toScala
     }
     require(heartBeatInterval < (heartBeatTimeout / 2), "heartbeat-interval must be less than half heartbeat-timeout")
-    new TimeoutSettings(heartBeatInterval, heartBeatTimeout, config.getDuration("lease-operation-timeout").asScala)
+    new TimeoutSettings(heartBeatInterval, heartBeatTimeout, config.getDuration("lease-operation-timeout").toScala)
   }
 
 }
@@ -41,37 +41,37 @@ final class TimeoutSettings(
   /**
    * Java API
    */
-  def getHeartbeatInterval(): java.time.Duration = heartbeatInterval.asJava
+  def getHeartbeatInterval(): java.time.Duration = heartbeatInterval.toJava
 
   /**
    * Java API
    */
-  def getHeartbeatTimeout(): java.time.Duration = heartbeatTimeout.asJava
+  def getHeartbeatTimeout(): java.time.Duration = heartbeatTimeout.toJava
 
   /**
    * Java API
    */
-  def getOperationTimeout(): java.time.Duration = operationTimeout.asJava
+  def getOperationTimeout(): java.time.Duration = operationTimeout.toJava
 
   /**
    * Java API
    */
   def withHeartbeatInterval(heartbeatInterval: java.time.Duration): TimeoutSettings = {
-    copy(heartbeatInterval = heartbeatInterval.asScala)
+    copy(heartbeatInterval = heartbeatInterval.toScala)
   }
 
   /**
    * Java API
    */
   def withHeartbeatTimeout(heartbeatTimeout: java.time.Duration): TimeoutSettings = {
-    copy(heartbeatTimeout = heartbeatTimeout.asScala)
+    copy(heartbeatTimeout = heartbeatTimeout.toScala)
   }
 
   /**
    * Java API
    */
   def withOperationTimeout(operationTimeout: java.time.Duration): TimeoutSettings = {
-    copy(operationTimeout = operationTimeout.asScala)
+    copy(operationTimeout = operationTimeout.toScala)
   }
 
   def withHeartbeatInterval(heartbeatInterval: FiniteDuration): TimeoutSettings = {
diff --git a/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala b/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala
index df9a774291..2e0ada8caf 100644
--- a/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala
+++ b/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala
@@ -68,7 +68,7 @@ import pekko.remote.RARP
 import pekko.serialization.SerializationExtension
 import pekko.util.ByteString
 import pekko.util.Helpers.toRootLowerCase
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 object ReplicatorSettings {
 
@@ -307,7 +307,7 @@ object Replicator {
     /**
      * Java API
      */
-    def this(n: Int, timeout: java.time.Duration) = this(n, timeout.asScala)
+    def this(n: Int, timeout: java.time.Duration) = this(n, timeout.toScala)
   }
   final case class ReadMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency {
     def this(timeout: FiniteDuration) = this(timeout, DefaultMajorityMinCap)
@@ -315,7 +315,7 @@ object Replicator {
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration) = this(timeout.asScala, DefaultMajorityMinCap)
+    def this(timeout: java.time.Duration) = this(timeout.toScala, DefaultMajorityMinCap)
   }
 
   /**
@@ -329,14 +329,14 @@ object Replicator {
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration, additional: Int) = this(timeout.asScala, additional, DefaultMajorityMinCap)
+    def this(timeout: java.time.Duration, additional: Int) = this(timeout.toScala, additional, DefaultMajorityMinCap)
   }
   final case class ReadAll(timeout: FiniteDuration) extends ReadConsistency {
 
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration) = this(timeout.asScala)
+    def this(timeout: java.time.Duration) = this(timeout.toScala)
   }
 
   sealed trait WriteConsistency {
@@ -351,7 +351,7 @@ object Replicator {
     /**
      * Java API
      */
-    def this(n: Int, timeout: java.time.Duration) = this(n, timeout.asScala)
+    def this(n: Int, timeout: java.time.Duration) = this(n, timeout.toScala)
   }
   final case class WriteMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap)
       extends WriteConsistency {
@@ -360,7 +360,7 @@ object Replicator {
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration) = this(timeout.asScala, DefaultMajorityMinCap)
+    def this(timeout: java.time.Duration) = this(timeout.toScala, DefaultMajorityMinCap)
   }
 
   /**
@@ -374,14 +374,14 @@ object Replicator {
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration, additional: Int) = this(timeout.asScala, additional, DefaultMajorityMinCap)
+    def this(timeout: java.time.Duration, additional: Int) = this(timeout.toScala, additional, DefaultMajorityMinCap)
   }
   final case class WriteAll(timeout: FiniteDuration) extends WriteConsistency {
 
     /**
      * Java API
      */
-    def this(timeout: java.time.Duration) = this(timeout.asScala)
+    def this(timeout: java.time.Duration) = this(timeout.toScala)
   }
 
   /**
diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala
index a10b925760..520f598cbd 100644
--- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala
+++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala
@@ -21,7 +21,7 @@ import pekko.Done
 import pekko.actor.ClassicActorSystemProvider
 import pekko.persistence.testkit.scaladsl
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Test utility to initialize persistence plugins. Useful when initialization order or coordination
@@ -49,6 +49,6 @@ object PersistenceInit {
       journalPluginId: String,
       snapshotPluginId: String,
       timeout: Duration): CompletionStage[Done] =
-    scaladsl.PersistenceInit.initializePlugins(system, journalPluginId, snapshotPluginId, timeout.asScala).asJava
+    scaladsl.PersistenceInit.initializePlugins(system, journalPluginId, snapshotPluginId, timeout.toScala).asJava
 
 }
diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala
index aaf7fcca5f..ccafc9cbbe 100644
--- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala
+++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala
@@ -22,7 +22,7 @@ import pekko.actor.ActorSystem
 import pekko.annotation.ApiMayChange
 import pekko.persistence.testkit.{ EventStorage, ExpectedFailure, ExpectedRejection, JournalOperation }
 import pekko.persistence.testkit.scaladsl.{ PersistenceTestKit => ScalaTestKit }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 /**
@@ -42,7 +42,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that nothing has been saved in the storage.
    */
   def expectNothingPersisted(persistenceId: String, max: Duration): Unit =
-    scalaTestkit.expectNothingPersisted(persistenceId, max.asScala)
+    scalaTestkit.expectNothingPersisted(persistenceId, max.toScala)
 
   /**
    * Check that `event` has been saved in the storage.
@@ -54,7 +54,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that `event` has been saved in the storage.
    */
   def expectNextPersisted[A](persistenceId: String, event: A, max: Duration): A =
-    scalaTestkit.expectNextPersisted(persistenceId, event, max.asScala)
+    scalaTestkit.expectNextPersisted(persistenceId, event, max.toScala)
 
   /**
    * Check that next persisted in storage for particular persistence id event has expected type.
@@ -66,7 +66,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that next persisted in storage for particular persistence id event has expected type.
    */
   def expectNextPersistedClass[A](persistenceId: String, cla: Class[A], max: Duration): A =
-    scalaTestkit.expectNextPersistedClass(persistenceId, cla, max.asScala)
+    scalaTestkit.expectNextPersistedClass(persistenceId, cla, max.toScala)
 
   /**
    * Fail next `n` write operations with the `cause` exception for particular persistence id.
@@ -201,7 +201,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) {
    * Receive for `max` time next n events from the storage.
    */
   def receivePersisted[A](persistenceId: String, n: Int, cla: Class[A], max: Duration): JList[A] =
-    scalaTestkit.receivePersisted(persistenceId, n, cla, max.asScala).asJava
+    scalaTestkit.receivePersisted(persistenceId, n, cla, max.toScala).asJava
 
   /**
    * Reject next n save in storage operations for particular persistence id with `cause` exception.
diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala
index 96c70dd6cb..8d31282d9d 100644
--- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala
+++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala
@@ -23,7 +23,7 @@ import pekko.annotation.ApiMayChange
 import pekko.japi.Pair
 import pekko.persistence.testkit.{ ExpectedFailure, SnapshotMeta, SnapshotOperation, SnapshotStorage }
 import pekko.persistence.testkit.scaladsl.{ SnapshotTestKit => ScalaTestKit }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 /**
@@ -43,7 +43,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that nothing has been saved in the storage.
    */
   def expectNothingPersisted(persistenceId: String, max: Duration): Unit =
-    scalaTestkit.expectNothingPersisted(persistenceId, max.asScala)
+    scalaTestkit.expectNothingPersisted(persistenceId, max.toScala)
 
   /**
    * Check that `snapshot` has been saved in the storage.
@@ -55,7 +55,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that `snapshot` has been saved in the storage.
    */
   def expectNextPersisted[A](persistenceId: String, snapshot: A, max: Duration): A =
-    scalaTestkit.expectNextPersisted(persistenceId, snapshot, max.asScala)
+    scalaTestkit.expectNextPersisted(persistenceId, snapshot, max.toScala)
 
   /**
    * Check that next persisted in storage for particular persistence id snapshot has expected type.
@@ -67,7 +67,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) {
    * Check for `max` time that next persisted in storage for particular persistence id snapshot has expected type.
    */
   def expectNextPersistedClass[A](persistenceId: String, cla: Class[A], max: Duration): A =
-    scalaTestkit.expectNextPersistedClass[A](persistenceId, cla, max.asScala)
+    scalaTestkit.expectNextPersistedClass[A](persistenceId, cla, max.toScala)
 
   /**
    * Fail next `n` write operations with the `cause` exception for particular persistence id.
@@ -202,7 +202,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) {
    * Receive for `max` time next `n` snapshots that have been persisted in the storage.
    */
   def receivePersisted[A](persistenceId: String, n: Int, cla: Class[A], max: Duration): JList[A] =
-    scalaTestkit.receivePersisted[A](persistenceId, n, cla, max.asScala).asJava
+    scalaTestkit.receivePersisted[A](persistenceId, n, cla, max.toScala).asJava
 
   /**
    * Persist `snapshots` with metadata into storage in order.
diff --git a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala
index 8af725db33..5d406e8a9d 100644
--- a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala
+++ b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala
@@ -32,7 +32,7 @@ import pekko.persistence.typed.delivery.EventSourcedProducerQueue.CleanupTick
 import pekko.persistence.typed.scaladsl.Effect
 import pekko.persistence.typed.scaladsl.EventSourcedBehavior
 import pekko.persistence.typed.scaladsl.RetentionCriteria
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * [[pekko.actor.typed.delivery.DurableProducerQueue]] that can be used with [[pekko.actor.typed.delivery.ProducerController]]
@@ -61,11 +61,11 @@ object EventSourcedProducerQueue {
      */
     def apply(config: Config): Settings = {
       new Settings(
-        restartMaxBackoff = config.getDuration("restart-max-backoff").asScala,
+        restartMaxBackoff = config.getDuration("restart-max-backoff").toScala,
         snapshotEvery = config.getInt("snapshot-every"),
         keepNSnapshots = config.getInt("keep-n-snapshots"),
         deleteEvents = config.getBoolean("delete-events"),
-        cleanupUnusedAfter = config.getDuration("cleanup-unused-after").asScala,
+        cleanupUnusedAfter = config.getDuration("cleanup-unused-after").toScala,
         journalPluginId = config.getString("journal-plugin-id"),
         snapshotPluginId = config.getString("snapshot-plugin-id"))
     }
@@ -113,13 +113,13 @@ object EventSourcedProducerQueue {
      * Java API
      */
     def withRestartMaxBackoff(newRestartMaxBackoff: JavaDuration): Settings =
-      copy(restartMaxBackoff = newRestartMaxBackoff.asScala)
+      copy(restartMaxBackoff = newRestartMaxBackoff.toScala)
 
     /**
      * Java API
      */
     def getRestartMaxBackoff(): JavaDuration =
-      restartMaxBackoff.asJava
+      restartMaxBackoff.toJava
 
     /**
      * Scala API
@@ -131,13 +131,13 @@ object EventSourcedProducerQueue {
      * Java API
      */
     def withCleanupUnusedAfter(newCleanupUnusedAfter: JavaDuration): Settings =
-      copy(cleanupUnusedAfter = newCleanupUnusedAfter.asScala)
+      copy(cleanupUnusedAfter = newCleanupUnusedAfter.toScala)
 
     /**
      * Java API
      */
     def getCleanupUnusedAfter(): JavaDuration =
-      cleanupUnusedAfter.asJava
+      cleanupUnusedAfter.toJava
 
     def withJournalPluginId(id: String): Settings =
       copy(journalPluginId = id)
diff --git a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala
index ddc23cef96..f8abdfd08c 100644
--- a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala
+++ b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala
@@ -19,7 +19,7 @@ import java.util.Optional
 import org.apache.pekko
 import pekko.japi.function.Function3
 import pekko.persistence.typed.SnapshotAdapter
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 /**
@@ -37,5 +37,5 @@ object PersistentFSMMigration {
    */
   def snapshotAdapter[State](adapt: Function3[String, Any, Optional[Duration], State]): SnapshotAdapter[State] =
     pekko.persistence.typed.scaladsl.PersistentFSMMigration.snapshotAdapter((stateId, snapshot, timer) =>
-      adapt.apply(stateId, snapshot, timer.map(_.asJava).toJava))
+      adapt.apply(stateId, snapshot, timer.map(_.toJava).toJava))
 }
diff --git a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala
index f0af99c83d..223c5fba13 100644
--- a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala
+++ b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala
@@ -28,7 +28,6 @@ import pekko.annotation.InternalApi
 import pekko.persistence.{ PersistentActor, RecoveryCompleted, SnapshotOffer }
 import pekko.persistence.fsm.PersistentFSM.FSMState
 import pekko.persistence.serialization.Message
-import pekko.util.JavaDurationConverters
 
 /**
  * SnapshotAfter Extension Id and factory for creating SnapshotAfter extension
@@ -430,8 +429,8 @@ object PersistentFSM {
      * Use Duration.Inf to deactivate an existing timeout.
      */
     def forMax(timeout: java.time.Duration): State[S, D, E] = {
-      import JavaDurationConverters._
-      forMax(timeout.asScala)
+      import scala.jdk.DurationConverters._
+      forMax(timeout.toScala)
     }
 
     /**
diff --git a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala
index 3fcae3717d..be7867c6c6 100644
--- a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala
+++ b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala
@@ -23,7 +23,7 @@ import pekko.japi.function.{ Effect, Function2, Predicate, Predicate2, Procedure
 import pekko.actor._
 import pekko.japi.pf.{ FSMTransitionHandlerBuilder, UnitMatch, UnitPFBuilder }
 import pekko.routing.{ Deafen, Listen, Listeners }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.unused
 
 /**
@@ -1118,7 +1118,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D
    * in the mailbox when the new timer was started.
    */
   def startTimerWithFixedDelay(name: String, msg: Any, delay: java.time.Duration): Unit =
-    startTimerWithFixedDelay(name, msg, delay.asScala)
+    startTimerWithFixedDelay(name, msg, delay.toScala)
 
   /**
    * Schedules a message to be sent repeatedly to the `self` actor with a
@@ -1146,7 +1146,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D
    * in the mailbox when the new timer was started.
    */
   def startTimerAtFixedRate(name: String, msg: Any, interval: java.time.Duration): Unit =
-    startTimerAtFixedRate(name, msg, interval.asScala)
+    startTimerAtFixedRate(name, msg, interval.toScala)
 
   /**
    * Start a timer that will send `msg` once to the `self` actor after
@@ -1158,7 +1158,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D
    * in the mailbox when the new timer was started.
    */
   def startSingleTimer(name: String, msg: Any, delay: java.time.Duration): Unit =
-    startSingleTimer(name, msg, delay.asScala)
+    startSingleTimer(name, msg, delay.toScala)
 
   /**
    * Schedule named timer to deliver message after given delay, possibly repeating.
diff --git a/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala b/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala
index 50fe97ae20..bf5f2b0cfe 100644
--- a/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala
+++ b/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala
@@ -26,7 +26,7 @@ import com.fasterxml.jackson.datatype.jsr310.ser.DurationSerializer
 
 import org.apache.pekko
 import pekko.annotation.InternalApi
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * INTERNAL API: Adds support for serializing and deserializing [[FiniteDuration]].
@@ -51,7 +51,7 @@ import pekko.util.JavaDurationConverters._
 @InternalApi private[pekko] class FiniteDurationSerializer
     extends StdScalarSerializer[FiniteDuration](classOf[FiniteDuration]) {
   override def serialize(value: FiniteDuration, jgen: JsonGenerator, provider: SerializerProvider): Unit = {
-    DurationSerializer.INSTANCE.serialize(value.asJava, jgen, provider)
+    DurationSerializer.INSTANCE.serialize(value.toJava, jgen, provider)
   }
 }
 
@@ -69,6 +69,6 @@ import pekko.util.JavaDurationConverters._
     extends StdScalarDeserializer[FiniteDuration](classOf[FiniteDuration]) {
 
   def deserialize(jp: JsonParser, ctxt: DeserializationContext): FiniteDuration = {
-    DurationDeserializer.INSTANCE.deserialize(jp, ctxt).asScala
+    DurationDeserializer.INSTANCE.deserialize(jp, ctxt).toScala
   }
 }
diff --git a/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala b/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala
index 141e759792..8b8772d5fa 100644
--- a/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala
+++ b/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala
@@ -34,7 +34,7 @@ import pekko.stream._
 import pekko.stream.impl._
 import pekko.testkit.{ TestActor, TestProbe }
 import pekko.testkit.TestActor.AutoPilot
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 import org.reactivestreams.{ Publisher, Subscriber, Subscription }
@@ -196,7 +196,7 @@ object TestPublisher {
      * Expect no messages for a given duration.
      * @since 1.1.0
      */
-    def expectNoMessage(max: java.time.Duration): Self = expectNoMessage(max.asScala)
+    def expectNoMessage(max: java.time.Duration): Self = expectNoMessage(max.toScala)
 
     /**
      * Receive messages for a given duration or until one does not match a given partial function.
@@ -218,7 +218,7 @@ object TestPublisher {
         idle: java.time.Duration,
         messages: Int,
         f: PartialFunction[PublisherEvent, T]): java.util.List[T] =
-      receiveWhile(max.asScala, idle.asScala, messages)(f).asJava
+      receiveWhile(max.toScala, idle.toScala, messages)(f).asJava
 
     def expectEventPF[T](f: PartialFunction[PublisherEvent, T]): T =
       executeAfterSubscription {
@@ -270,7 +270,7 @@ object TestPublisher {
     def within[T](min: java.time.Duration,
         max: java.time.Duration,
         creator: function.Creator[T]): T =
-      within(min.asScala, max.asScala)(creator.create())
+      within(min.toScala, max.toScala)(creator.create())
 
     /**
      * Same as calling `within(0 seconds, max)(f)`.
@@ -286,7 +286,7 @@ object TestPublisher {
      * @since 1.1.0
      */
     def within[T](max: java.time.Duration,
-        creator: function.Creator[T]): T = within(max.asScala)(creator.create())
+        creator: function.Creator[T]): T = within(max.toScala)(creator.create())
   }
 
   object Probe {
@@ -453,7 +453,7 @@ object TestSubscriber {
      * Expect and return [[SubscriberEvent]] (any of: `OnSubscribe`, `OnNext`, `OnError` or `OnComplete`).
      * @since 1.1.0
      */
-    def expectEvent(max: java.time.Duration): SubscriberEvent = expectEvent(max.asScala)
+    def expectEvent(max: java.time.Duration): SubscriberEvent = expectEvent(max.toScala)
 
     /**
      * Fluent DSL
@@ -490,7 +490,7 @@ object TestSubscriber {
      * Expect and return a stream element during specified time or timeout.
      * @since 1.1.0
      */
-    def expectNext(d: java.time.Duration): I = expectNext(d.asScala)
+    def expectNext(d: java.time.Duration): I = expectNext(d.toScala)
 
     /**
      * Fluent DSL
@@ -520,7 +520,7 @@ object TestSubscriber {
      * Expect a stream element during specified time or timeout.
      * @since 1.1.0
      */
-    def expectNext(d: java.time.Duration, element: I): Self = expectNext(d.asScala, element)
+    def expectNext(d: java.time.Duration, element: I): Self = expectNext(d.toScala, element)
 
     /**
      * Fluent DSL
@@ -790,7 +790,7 @@ object TestSubscriber {
      * Java API: Assert that no message is received for the specified time.
      */
     def expectNoMessage(remaining: java.time.Duration): Self = {
-      probe.expectNoMessage(remaining.asScala)
+      probe.expectNoMessage(remaining.toScala)
       self
     }
 
@@ -821,7 +821,7 @@ object TestSubscriber {
      * @since 1.1.0
      */
     def expectNextWithTimeoutPF[T](max: java.time.Duration, f: PartialFunction[Any, T]): T =
-      expectEventWithTimeoutPF(max.asScala, f)
+      expectEventWithTimeoutPF(max.toScala, f)
 
     /**
      * Expect a stream element during specified time or timeout and test it with partial function.
@@ -844,7 +844,7 @@ object TestSubscriber {
      * @since 1.1.0
      */
     def expectNextChainingPF(max: java.time.Duration, f: PartialFunction[Any, Any]): Self =
-      expectNextChainingPF(max.asScala, f)
+      expectNextChainingPF(max.toScala, f)
 
     /**
      * Expect a stream element during specified time or timeout and test it with partial function.
@@ -862,7 +862,7 @@ object TestSubscriber {
      * @since 1.1.0
      */
     def expectEventWithTimeoutPF[T](max: java.time.Duration, f: PartialFunction[SubscriberEvent, T]): T =
-      expectEventWithTimeoutPF(max.asScala, f)
+      expectEventWithTimeoutPF(max.toScala, f)
 
     def expectEventPF[T](f: PartialFunction[SubscriberEvent, T]): T =
       expectEventWithTimeoutPF(Duration.Undefined, f)
@@ -887,7 +887,7 @@ object TestSubscriber {
         idle: java.time.Duration,
         messages: Int,
         f: PartialFunction[SubscriberEvent, T]): java.util.List[T] =
-      receiveWhile(max.asScala, idle.asScala, messages)(f).asJava
+      receiveWhile(max.toScala, idle.toScala, messages)(f).asJava
 
     /**
      * Drains a given number of messages
@@ -907,7 +907,7 @@ object TestSubscriber {
      * @since 1.1.0
      */
     def receiveWithin(max: java.time.Duration, messages: Int): java.util.List[I] =
-      receiveWithin(max.asScala, messages).asJava
+      receiveWithin(max.toScala, messages).asJava
 
     /**
      * Attempt to drain the stream into a strict collection (by requesting `Long.MaxValue` elements).
@@ -948,7 +948,7 @@ object TestSubscriber {
      * @since 1.1.0
      */
     def toStrict(atMost: java.time.Duration): java.util.List[I] =
-      toStrict(atMost.asScala).asJava
+      toStrict(atMost.toScala).asJava
 
     /**
      * Execute code block while bounding its execution time between `min` and
@@ -990,7 +990,7 @@ object TestSubscriber {
      */
     def within[T](min: java.time.Duration,
         max: java.time.Duration,
-        creator: function.Creator[T]): T = within(min.asScala, max.asScala)(creator.create())
+        creator: function.Creator[T]): T = within(min.toScala, max.toScala)(creator.create())
 
     /**
      * Same as calling `within(0 seconds, max)(f)`.
@@ -1003,7 +1003,7 @@ object TestSubscriber {
      * Same as calling `within(Duration.ofSeconds(0), max)(f)`.
      * @since 1.1.0
      */
-    def within[T](max: java.time.Duration)(creator: function.Creator[T]): T = within(max.asScala)(creator.create())
+    def within[T](max: java.time.Duration)(creator: function.Creator[T]): T = within(max.toScala)(creator.create())
 
     def onSubscribe(subscription: Subscription): Unit = probe.ref ! OnSubscribe(subscription)
     def onNext(element: I): Unit = probe.ref ! OnNext(element)
@@ -1087,7 +1087,7 @@ object TestSubscriber {
      * Request and expect a stream element during the specified time or timeout.
      * @since 1.1.0
      */
-    def requestNext(d: java.time.Duration): T = requestNext(d.asScala)
+    def requestNext(d: java.time.Duration): T = requestNext(d.toScala)
   }
 }
 
diff --git a/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala b/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala
index 8873facb45..a2f018e5a8 100644
--- a/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala
+++ b/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala
@@ -21,7 +21,8 @@ import pekko.japi.Pair
 import pekko.japi.function
 import pekko.pattern.StatusReply
 import pekko.stream.javadsl.Flow
-import pekko.util.JavaDurationConverters
+
+import scala.jdk.DurationConverters.JavaDurationOps
 
 /**
  * Collection of Flows aimed at integrating with typed Actors.
@@ -71,7 +72,7 @@ object ActorFlow {
       makeMessage: function.Function2[I, ActorRef[A], Q]): Flow[I, A, NotUsed] =
     org.apache.pekko.stream.typed.scaladsl.ActorFlow
       .ask[I, Q, A](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))(
-        JavaDurationConverters.asFiniteDuration(timeout))
+        timeout.toScala)
       .asJava
 
   /**
@@ -85,7 +86,7 @@ object ActorFlow {
       makeMessage: function.Function2[I, ActorRef[StatusReply[A]], Q]): Flow[I, A, NotUsed] =
     org.apache.pekko.stream.typed.scaladsl.ActorFlow
       .askWithStatus[I, Q, A](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))(
-        JavaDurationConverters.asFiniteDuration(timeout))
+        timeout.toScala)
       .asJava
 
   /**
@@ -157,7 +158,7 @@ object ActorFlow {
       .via(
         org.apache.pekko.stream.typed.scaladsl.ActorFlow
           .askWithContext[I, Q, A, Ctx](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))(
-            JavaDurationConverters.asFiniteDuration(timeout))
+            timeout.toScala)
           .map { case (a, ctx) => Pair(a, ctx) })
       .asJava
 
@@ -176,7 +177,7 @@ object ActorFlow {
       .via(
         org.apache.pekko.stream.typed.scaladsl.ActorFlow
           .askWithStatusAndContext[I, Q, A, Ctx](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))(
-            JavaDurationConverters.asFiniteDuration(timeout))
+            timeout.toScala)
           .map { case (a, ctx) => Pair(a, ctx) })
       .asJava
 
@@ -194,7 +195,7 @@ object ActorFlow {
       .via(
         org.apache.pekko.stream.typed.scaladsl.ActorFlow
           .askWithContext[I, Q, A, Ctx](parallelism)(ref)((i, ref) => makeMessage(i, ref))(
-            JavaDurationConverters.asFiniteDuration(timeout))
+            timeout.toScala)
           .map { case (a, ctx) => Pair(a, ctx) })
       .asJava
   }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala b/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala
index 5b4751bcf6..0d016fde4f 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala
@@ -30,7 +30,7 @@ import pekko.event.Logging
 import pekko.japi.function
 import pekko.stream.impl.TraversalBuilder
 import pekko.util.{ ByteString, OptionVal }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.LineNumbers
 import pekko.util.OptionConverters._
 
@@ -483,7 +483,7 @@ object Attributes {
      * but you might still be able observe a long delay at the ultimate source.
      */
     @ApiMayChange
-    def afterDelay(delay: java.time.Duration, strategy: Strategy): Strategy = AfterDelay(delay.asScala, strategy)
+    def afterDelay(delay: java.time.Duration, strategy: Strategy): Strategy = AfterDelay(delay.toScala, strategy)
   }
 
   /**
@@ -834,7 +834,7 @@ object ActorAttributes {
    * Java API: Defines a timeout for stream subscription and what action to take when that hits.
    */
   def streamSubscriptionTimeout(timeout: Duration, mode: StreamSubscriptionTimeoutTerminationMode): Attributes =
-    streamSubscriptionTimeout(timeout.asScala, mode)
+    streamSubscriptionTimeout(timeout.toScala, mode)
 
   /**
    * Maximum number of elements emitted in batch if downstream signals large demand.
@@ -926,7 +926,7 @@ object StreamRefAttributes {
   /**
    * Java API: Specifies the subscription timeout within which the remote side MUST subscribe to the handed out stream reference.
    */
-  def subscriptionTimeout(timeout: Duration): Attributes = subscriptionTimeout(timeout.asScala)
+  def subscriptionTimeout(timeout: Duration): Attributes = subscriptionTimeout(timeout.toScala)
 
   /**
    * Specifies the size of the buffer on the receiving side that is eagerly filled even without demand.
@@ -943,7 +943,7 @@ object StreamRefAttributes {
    *  Java API: If no new elements arrive within this timeout, demand is redelivered.
    */
   def demandRedeliveryInterval(timeout: Duration): Attributes =
-    demandRedeliveryInterval(timeout.asScala)
+    demandRedeliveryInterval(timeout.toScala)
 
   /**
    * Scala API: The time between the Terminated signal being received and when the local SourceRef determines to fail itself
@@ -955,6 +955,6 @@ object StreamRefAttributes {
    * Java API: The time between the Terminated signal being received and when the local SourceRef determines to fail itself
    */
   def finalTerminationSignalDeadline(timeout: Duration): Attributes =
-    finalTerminationSignalDeadline(timeout.asScala)
+    finalTerminationSignalDeadline(timeout.toScala)
 
 }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala b/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala
index 8fda40de43..e148b0eff9 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala
@@ -20,7 +20,7 @@ import pekko.japi.function
 import pekko.event.Logging
 import pekko.event.Logging.LogLevel
 import pekko.util.ConstantFun
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 final class RestartSettings private (
     val minBackoff: FiniteDuration,
@@ -35,13 +35,13 @@ final class RestartSettings private (
   def withMinBackoff(value: FiniteDuration): RestartSettings = copy(minBackoff = value)
 
   /** Java API: minimum (initial) duration until the child actor will started again, if it is terminated */
-  def withMinBackoff(value: java.time.Duration): RestartSettings = copy(minBackoff = value.asScala)
+  def withMinBackoff(value: java.time.Duration): RestartSettings = copy(minBackoff = value.toScala)
 
   /** Scala API: the exponential back-off is capped to this duration */
   def withMaxBackoff(value: FiniteDuration): RestartSettings = copy(maxBackoff = value)
 
   /** Java API: the exponential back-off is capped to this duration */
-  def withMaxBackoff(value: java.time.Duration): RestartSettings = copy(maxBackoff = value.asScala)
+  def withMaxBackoff(value: java.time.Duration): RestartSettings = copy(maxBackoff = value.toScala)
 
   /**
    * After calculation of the exponential back-off an additional random delay based on this factor is added
@@ -55,7 +55,7 @@ final class RestartSettings private (
 
   /** Java API: The amount of restarts is capped to `count` within a timeframe of `within` */
   def withMaxRestarts(count: Int, within: java.time.Duration): RestartSettings =
-    copy(maxRestarts = count, maxRestartsWithin = within.asScala)
+    copy(maxRestarts = count, maxRestartsWithin = within.toScala)
 
   /** Decides whether the failure should restart the stream or make the surrounding stream fail */
   def withRestartOn(restartOn: function.Predicate[Throwable]): RestartSettings =
@@ -100,11 +100,11 @@ object RestartSettings {
   /** Java API */
   def create(minBackoff: java.time.Duration, maxBackoff: java.time.Duration, randomFactor: Double): RestartSettings =
     new RestartSettings(
-      minBackoff = minBackoff.asScala,
-      maxBackoff = maxBackoff.asScala,
+      minBackoff = minBackoff.toScala,
+      maxBackoff = maxBackoff.toScala,
       randomFactor = randomFactor,
       maxRestarts = Int.MaxValue,
-      maxRestartsWithin = minBackoff.asScala,
+      maxRestartsWithin = minBackoff.toScala,
       logSettings = LogSettings.defaultSettings,
       restartOn = ConstantFun.anyToTrue)
 
diff --git a/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala b/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala
index 05e18d97e4..969c64aab1 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala
@@ -29,7 +29,7 @@ import pekko.annotation.InternalApi
 import pekko.dispatch.Dispatchers
 import pekko.pattern.ask
 import pekko.stream.impl.MaterializerGuardian
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.Timeout
 
 /**
@@ -59,7 +59,7 @@ final class SystemMaterializer(system: ExtendedActorSystem) extends Extension {
   private[pekko] val materializerSettings = ActorMaterializerSettings(system)
 
   private implicit val materializerTimeout: Timeout =
-    system.settings.config.getDuration("pekko.stream.materializer.creation-timeout").asScala
+    system.settings.config.getDuration("pekko.stream.materializer.creation-timeout").toScala
 
   @InternalApi @nowarn("msg=deprecated")
   private val materializerGuardian = system.systemActorOf(
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala
index f7bece9f45..cc9931759e 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala
@@ -101,8 +101,8 @@ object BidiFlow {
    * the *joint* frequencies of the elements in both directions.
    */
   def bidirectionalIdleTimeout[I, O](timeout: java.time.Duration): BidiFlow[I, I, O, O, NotUsed] = {
-    import pekko.util.JavaDurationConverters._
-    new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout.asScala))
+    import scala.jdk.DurationConverters._
+    new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout.toScala))
   }
 }
 
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala
index 2e1f5374d6..8eb32d5be8 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala
@@ -18,7 +18,7 @@ import scala.concurrent.duration.FiniteDuration
 import org.apache.pekko
 import pekko.annotation.InternalApi
 import pekko.stream.scaladsl
-import pekko.util.JavaDurationConverters.JavaDurationOps
+import scala.jdk.DurationConverters._
 
 /**
  * Allows to manage delay and can be stateful to compute delay for any sequence of elements,
@@ -38,7 +38,7 @@ object DelayStrategy {
   /** INTERNAL API */
   @InternalApi
   private[javadsl] def asScala[T](delayStrategy: DelayStrategy[T]) = new scaladsl.DelayStrategy[T] {
-    override def nextDelay(elem: T): FiniteDuration = delayStrategy.nextDelay(elem).asScala
+    override def nextDelay(elem: T): FiniteDuration = delayStrategy.nextDelay(elem).toScala
   }
 
   /**
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala
index 197223a46b..423268fe1a 100755
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala
@@ -36,7 +36,7 @@ import pekko.stream.{ javadsl, _ }
 import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava }
 import pekko.util.ConstantFun
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.Timeout
 import pekko.util.unused
@@ -1628,7 +1628,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * IllegalArgumentException is thrown.
    */
   def groupedWithin(maxNumber: Int, duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] =
-    new Flow(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step
+    new Flow(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1652,7 +1652,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
       maxWeight: Long,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] =
-    new Flow(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava))
+    new Flow(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1678,7 +1678,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
       maxNumber: Int,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] =
-    new Flow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava))
+    new Flow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Shifts elements emission in time by a specified amount. It allows to store elements
@@ -1706,7 +1706,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
    */
   def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): Flow[In, Out, Mat] =
-    new Flow(delegate.delay(of.asScala, strategy))
+    new Flow(delegate.delay(of.toScala, strategy))
 
   /**
    * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount.
@@ -1771,7 +1771,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def dropWithin(duration: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.dropWithin(duration.asScala))
+    new Flow(delegate.dropWithin(duration.toScala))
 
   /**
    * Terminate processing (and cancel the upstream publisher) after predicate
@@ -2222,7 +2222,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * See also [[Flow.limit]], [[Flow.limitWeighted]]
    */
   def takeWithin(duration: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.takeWithin(duration.asScala))
+    new Flow(delegate.takeWithin(duration.toScala))
 
   /**
    * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary
@@ -3750,7 +3750,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def initialTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.initialTimeout(timeout.asScala))
+    new Flow(delegate.initialTimeout(timeout.toScala))
 
   /**
    * If the completion of the stream does not happen until the provided timeout, the stream is failed
@@ -3765,7 +3765,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def completionTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.completionTimeout(timeout.asScala))
+    new Flow(delegate.completionTimeout(timeout.toScala))
 
   /**
    * If the time between two processed elements exceeds the provided timeout, the stream is failed
@@ -3781,7 +3781,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def idleTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.idleTimeout(timeout.asScala))
+    new Flow(delegate.idleTimeout(timeout.toScala))
 
   /**
    * If the time between the emission of an element and the following downstream demand exceeds the provided timeout,
@@ -3797,7 +3797,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def backpressureTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.backpressureTimeout(timeout.asScala))
+    new Flow(delegate.backpressureTimeout(timeout.toScala))
 
   /**
    * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this
@@ -3817,7 +3817,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create()))
+    new Flow(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create()))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -3849,7 +3849,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def throttle(elements: Int, per: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.throttle(elements, per.asScala))
+    new Flow(delegate.throttle(elements, per.toScala))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -3891,7 +3891,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.throttle(elements, per.asScala, maximumBurst, mode))
+    new Flow(delegate.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -3928,7 +3928,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.throttle(cost, per.asScala, costCalculation.apply))
+    new Flow(delegate.throttle(cost, per.toScala, costCalculation.apply))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -3974,7 +3974,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode))
+    new Flow(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode))
 
   /**
    * Detaches upstream demand from downstream demand without detaching the
@@ -4034,7 +4034,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
    * '''Cancels when''' downstream cancels
    */
   def initialDelay(delay: java.time.Duration): javadsl.Flow[In, Out, Mat] =
-    new Flow(delegate.initialDelay(delay.asScala))
+    new Flow(delegate.initialDelay(delay.toScala))
 
   /**
    * Replace the attributes of this [[Flow]] with the given ones. If this Flow is a composite
@@ -4314,7 +4314,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = Option(emitOnTimer).map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         })
       .asJava
   }
@@ -4348,7 +4348,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = emitOnTimer.toScala.map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         })
       .asJava
   }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala
index 998e303391..81be98a427 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala
@@ -25,7 +25,7 @@ import pekko.japi.{ function, Pair }
 import pekko.stream._
 import pekko.util.ConstantFun
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.ccompat.JavaConverters._
 
@@ -381,7 +381,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat](
    * @see [[pekko.stream.javadsl.Flow.throttle]]
    */
   def throttle(elements: Int, per: java.time.Duration): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] =
-    viaScala(_.throttle(elements, per.asScala))
+    viaScala(_.throttle(elements, per.toScala))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]].
@@ -393,7 +393,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat](
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] =
-    viaScala(_.throttle(elements, per.asScala, maximumBurst, mode))
+    viaScala(_.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]].
@@ -404,7 +404,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat](
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] =
-    viaScala(_.throttle(cost, per.asScala, costCalculation.apply))
+    viaScala(_.throttle(cost, per.toScala, costCalculation.apply))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]].
@@ -417,7 +417,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat](
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] =
-    viaScala(_.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode))
+    viaScala(_.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode))
 
   def asScala: scaladsl.FlowWithContext[In, CtxIn, Out, CtxOut, Mat] =
     scaladsl.FlowWithContext.fromTuples(
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala
index e49d023ffd..c5ea0d7224 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala
@@ -19,7 +19,7 @@ import org.apache.pekko
 import pekko.annotation.ApiMayChange
 import pekko.japi.Pair
 import pekko.stream.scaladsl
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 object RetryFlow {
@@ -54,7 +54,7 @@ object RetryFlow {
       flow: Flow[In, Out, Mat],
       decideRetry: pekko.japi.function.Function2[In, Out, Optional[In]]): Flow[In, Out, Mat] =
     scaladsl.RetryFlow
-      .withBackoff[In, Out, Mat](minBackoff.asScala, maxBackoff.asScala, randomFactor, maxRetries, flow.asScala) {
+      .withBackoff[In, Out, Mat](minBackoff.toScala, maxBackoff.toScala, randomFactor, maxRetries, flow.asScala) {
         (in, out) =>
           decideRetry.apply(in, out).toScala
       }
@@ -95,8 +95,8 @@ object RetryFlow {
       : FlowWithContext[In, InCtx, Out, OutCtx, Mat] =
     scaladsl.RetryFlow
       .withBackoffAndContext[In, InCtx, Out, OutCtx, Mat](
-        minBackoff.asScala,
-        maxBackoff.asScala,
+        minBackoff.toScala,
+        maxBackoff.toScala,
         randomFactor,
         maxRetries,
         flow.asScala) { (in, out) =>
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala
index 1f14162908..3980492d3d 100755
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala
@@ -35,7 +35,7 @@ import pekko.stream.impl.{ LinearTraversalBuilder, UnfoldAsyncJava, UnfoldJava }
 import pekko.stream.impl.fusing.{ ArraySource, StatefulMapConcat, ZipWithIndexJava }
 import pekko.util.{ unused, _ }
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.ccompat.JavaConverters._
 
@@ -229,7 +229,7 @@ object Source {
    * receive new tick elements as soon as it has requested more elements.
    */
   def tick[O](initialDelay: java.time.Duration, interval: java.time.Duration, tick: O): javadsl.Source[O, Cancellable] =
-    new Source(scaladsl.Source.tick(initialDelay.asScala, interval.asScala, tick))
+    new Source(scaladsl.Source.tick(initialDelay.toScala, interval.toScala, tick))
 
   /**
    * Create a `Source` with one element.
@@ -3333,7 +3333,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
   def groupedWithin(
       maxNumber: Int,
       duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] =
-    new Source(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step
+    new Source(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -3357,7 +3357,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
       maxWeight: Long,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] =
-    new Source(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava))
+    new Source(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -3383,7 +3383,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
       maxNumber: Int,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] =
-    new Source(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava))
+    new Source(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Shifts elements emission in time by a specified amount. It allows to store elements
@@ -3411,7 +3411,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
    */
   def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): Source[Out, Mat] =
-    new Source(delegate.delay(of.asScala, strategy))
+    new Source(delegate.delay(of.toScala, strategy))
 
   /**
    * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount.
@@ -3476,7 +3476,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def dropWithin(duration: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.dropWithin(duration.asScala))
+    new Source(delegate.dropWithin(duration.toScala))
 
   /**
    * Terminate processing (and cancel the upstream publisher) after predicate
@@ -3598,7 +3598,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels or timer fires
    */
   def takeWithin(duration: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.takeWithin(duration.asScala))
+    new Source(delegate.takeWithin(duration.toScala))
 
   /**
    * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary
@@ -4212,7 +4212,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def initialTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.initialTimeout(timeout.asScala))
+    new Source(delegate.initialTimeout(timeout.toScala))
 
   /**
    * If the completion of the stream does not happen until the provided timeout, the stream is failed
@@ -4227,7 +4227,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def completionTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.completionTimeout(timeout.asScala))
+    new Source(delegate.completionTimeout(timeout.toScala))
 
   /**
    * If the time between two processed elements exceeds the provided timeout, the stream is failed
@@ -4243,7 +4243,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def idleTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.idleTimeout(timeout.asScala))
+    new Source(delegate.idleTimeout(timeout.toScala))
 
   /**
    * If the time between the emission of an element and the following downstream demand exceeds the provided timeout,
@@ -4259,7 +4259,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def backpressureTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.backpressureTimeout(timeout.asScala))
+    new Source(delegate.backpressureTimeout(timeout.toScala))
 
   /**
    * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this
@@ -4279,7 +4279,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): javadsl.Source[Out, Mat] =
-    new Source(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create()))
+    new Source(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create()))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -4311,7 +4311,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def throttle(elements: Int, per: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.throttle(elements, per.asScala))
+    new Source(delegate.throttle(elements, per.toScala))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -4353,7 +4353,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): javadsl.Source[Out, Mat] =
-    new Source(delegate.throttle(elements, per.asScala, maximumBurst, mode))
+    new Source(delegate.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -4390,7 +4390,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): javadsl.Source[Out, Mat] =
-    new Source(delegate.throttle(cost, per.asScala, costCalculation.apply _))
+    new Source(delegate.throttle(cost, per.toScala, costCalculation.apply _))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -4436,7 +4436,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): javadsl.Source[Out, Mat] =
-    new Source(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply _, mode))
+    new Source(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply _, mode))
 
   /**
    * Detaches upstream demand from downstream demand without detaching the
@@ -4495,7 +4495,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
    * '''Cancels when''' downstream cancels
    */
   def initialDelay(delay: java.time.Duration): javadsl.Source[Out, Mat] =
-    new Source(delegate.initialDelay(delay.asScala))
+    new Source(delegate.initialDelay(delay.toScala))
 
   /**
    * Replace the attributes of this [[Source]] with the given ones. If this Source is a composite
@@ -4755,7 +4755,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = Option(emitOnTimer).map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         })
       .asJava
   }
@@ -4788,7 +4788,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = emitOnTimer.toScala.map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         })
       .asJava
   }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala
index 53d1449883..70c75d087a 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala
@@ -27,7 +27,7 @@ import pekko.japi.function
 import pekko.stream._
 import pekko.util.ConstantFun
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.ccompat.JavaConverters._
 
@@ -365,7 +365,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon
    * @see [[pekko.stream.javadsl.Source.throttle]]
    */
   def throttle(elements: Int, per: java.time.Duration): SourceWithContext[Out, Ctx, Mat] =
-    viaScala(_.throttle(elements, per.asScala))
+    viaScala(_.throttle(elements, per.toScala))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]].
@@ -377,7 +377,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): SourceWithContext[Out, Ctx, Mat] =
-    viaScala(_.throttle(elements, per.asScala, maximumBurst, mode))
+    viaScala(_.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]].
@@ -388,7 +388,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): SourceWithContext[Out, Ctx, Mat] =
-    viaScala(_.throttle(cost, per.asScala, costCalculation.apply))
+    viaScala(_.throttle(cost, per.toScala, costCalculation.apply))
 
   /**
    * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]].
@@ -401,7 +401,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): SourceWithContext[Out, Ctx, Mat] =
-    viaScala(_.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode))
+    viaScala(_.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode))
 
   /**
    * Connect this [[pekko.stream.javadsl.SourceWithContext]] to a [[pekko.stream.javadsl.Sink]],
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala
index 6a51f9cd60..189e27f627 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala
@@ -25,7 +25,7 @@ import pekko.stream.IOResult
 import pekko.stream.scaladsl.SinkToCompletionStage
 import pekko.stream.scaladsl.SourceToCompletionStage
 import pekko.util.ByteString
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 
 /**
  * Converters for interacting with the blocking `java.io` streams APIs and Java 8 Streams
@@ -101,7 +101,7 @@ object StreamConverters {
    * @param readTimeout the max time the read operation on the materialized InputStream should block
    */
   def asInputStream(readTimeout: java.time.Duration): Sink[ByteString, InputStream] =
-    new Sink(scaladsl.StreamConverters.asInputStream(readTimeout.asScala))
+    new Sink(scaladsl.StreamConverters.asInputStream(readTimeout.toScala))
 
   /**
    * Creates a Source from an [[java.io.InputStream]] created by the given function.
@@ -157,7 +157,7 @@ object StreamConverters {
    * @param writeTimeout the max time the write operation on the materialized OutputStream should block
    */
   def asOutputStream(writeTimeout: java.time.Duration): javadsl.Source[ByteString, OutputStream] =
-    new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout.asScala))
+    new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout.toScala))
 
   /**
    * Creates a Source which when materialized will return an [[java.io.OutputStream]] which it is possible
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala
index f55a58caa3..ad4549f1bb 100755
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala
@@ -29,7 +29,7 @@ import pekko.stream._
 import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava }
 import pekko.util.ConstantFun
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.ccompat.JavaConverters._
 
@@ -1023,7 +1023,7 @@ final class SubFlow[In, Out, Mat](
   def groupedWithin(
       maxNumber: Int,
       duration: java.time.Duration): SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] =
-    new SubFlow(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step
+    new SubFlow(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1047,7 +1047,7 @@ final class SubFlow[In, Out, Mat](
       maxWeight: Long,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] =
-    new SubFlow(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava))
+    new SubFlow(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1073,7 +1073,7 @@ final class SubFlow[In, Out, Mat](
       maxNumber: Int,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] =
-    new SubFlow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava))
+    new SubFlow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Shifts elements emission in time by a specified amount. It allows to store elements
@@ -1101,7 +1101,7 @@ final class SubFlow[In, Out, Mat](
    * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
    */
   def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.delay(of.asScala, strategy))
+    new SubFlow(delegate.delay(of.toScala, strategy))
 
   /**
    * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount.
@@ -1166,7 +1166,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def dropWithin(duration: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.dropWithin(duration.asScala))
+    new SubFlow(delegate.dropWithin(duration.toScala))
 
   /**
    * Terminate processing (and cancel the upstream publisher) after predicate
@@ -1453,7 +1453,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels or timer fires
    */
   def takeWithin(duration: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.takeWithin(duration.asScala))
+    new SubFlow(delegate.takeWithin(duration.toScala))
 
   /**
    * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary
@@ -2305,7 +2305,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def initialTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.initialTimeout(timeout.asScala))
+    new SubFlow(delegate.initialTimeout(timeout.toScala))
 
   /**
    * If the completion of the stream does not happen until the provided timeout, the stream is failed
@@ -2320,7 +2320,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def completionTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.completionTimeout(timeout.asScala))
+    new SubFlow(delegate.completionTimeout(timeout.toScala))
 
   /**
    * If the time between two processed elements exceeds the provided timeout, the stream is failed
@@ -2336,7 +2336,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def idleTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.idleTimeout(timeout.asScala))
+    new SubFlow(delegate.idleTimeout(timeout.toScala))
 
   /**
    * If the time between the emission of an element and the following downstream demand exceeds the provided timeout,
@@ -2352,7 +2352,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def backpressureTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.backpressureTimeout(timeout.asScala))
+    new SubFlow(delegate.backpressureTimeout(timeout.toScala))
 
   /**
    * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this
@@ -2372,7 +2372,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create()))
+    new SubFlow(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create()))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -2404,7 +2404,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def throttle(elements: Int, per: java.time.Duration): javadsl.SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.throttle(elements, per.asScala))
+    new SubFlow(delegate.throttle(elements, per.toScala))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -2446,7 +2446,7 @@ final class SubFlow[In, Out, Mat](
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): javadsl.SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.throttle(elements, per.asScala, maximumBurst, mode))
+    new SubFlow(delegate.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -2483,7 +2483,7 @@ final class SubFlow[In, Out, Mat](
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): javadsl.SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.throttle(cost, per.asScala, costCalculation.apply))
+    new SubFlow(delegate.throttle(cost, per.toScala, costCalculation.apply))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -2529,7 +2529,7 @@ final class SubFlow[In, Out, Mat](
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): javadsl.SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode))
+    new SubFlow(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode))
 
   /**
    * Detaches upstream demand from downstream demand without detaching the
@@ -2557,7 +2557,7 @@ final class SubFlow[In, Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def initialDelay(delay: java.time.Duration): SubFlow[In, Out, Mat] =
-    new SubFlow(delegate.initialDelay(delay.asScala))
+    new SubFlow(delegate.initialDelay(delay.toScala))
 
   /**
    * Change the attributes of this [[Source]] to the given ones and seal the list
@@ -2797,7 +2797,7 @@ final class SubFlow[In, Out, Mat](
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = Option(emitOnTimer).map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         }))
   }
 
@@ -2830,7 +2830,7 @@ final class SubFlow[In, Out, Mat](
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = emitOnTimer.toScala.map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         }))
   }
 
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala
index d09c74fdf1..369a47a672 100755
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala
@@ -29,7 +29,7 @@ import pekko.stream._
 import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava }
 import pekko.util.ConstantFun
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 import pekko.util.ccompat.JavaConverters._
 
@@ -1009,7 +1009,7 @@ final class SubSource[Out, Mat](
   def groupedWithin(
       maxNumber: Int,
       duration: java.time.Duration): SubSource[java.util.List[Out @uncheckedVariance], Mat] =
-    new SubSource(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step
+    new SubSource(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1033,7 +1033,7 @@ final class SubSource[Out, Mat](
       maxWeight: Long,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.SubSource[java.util.List[Out @uncheckedVariance], Mat] =
-    new SubSource(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava))
+    new SubSource(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Chunk up this stream into groups of elements received within a time window,
@@ -1059,7 +1059,7 @@ final class SubSource[Out, Mat](
       maxNumber: Int,
       costFn: function.Function[Out, java.lang.Long],
       duration: java.time.Duration): javadsl.SubSource[java.util.List[Out @uncheckedVariance], Mat] =
-    new SubSource(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava))
+    new SubSource(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava))
 
   /**
    * Discard the given number of elements at the beginning of the stream.
@@ -1088,7 +1088,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def dropWithin(duration: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.dropWithin(duration.asScala))
+    new SubSource(delegate.dropWithin(duration.toScala))
 
   /**
    * Terminate processing (and cancel the upstream publisher) after predicate
@@ -1193,7 +1193,7 @@ final class SubSource[Out, Mat](
    * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
    */
   def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): SubSource[Out, Mat] =
-    new SubSource(delegate.delay(of.asScala, strategy))
+    new SubSource(delegate.delay(of.toScala, strategy))
 
   /**
    * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount.
@@ -1428,7 +1428,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels or timer fires
    */
   def takeWithin(duration: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.takeWithin(duration.asScala))
+    new SubSource(delegate.takeWithin(duration.toScala))
 
   /**
    * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary
@@ -2279,7 +2279,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def initialTimeout(timeout: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.initialTimeout(timeout.asScala))
+    new SubSource(delegate.initialTimeout(timeout.toScala))
 
   /**
    * If the completion of the stream does not happen until the provided timeout, the stream is failed
@@ -2294,7 +2294,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def completionTimeout(timeout: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.completionTimeout(timeout.asScala))
+    new SubSource(delegate.completionTimeout(timeout.toScala))
 
   /**
    * If the time between two processed elements exceeds the provided timeout, the stream is failed
@@ -2310,7 +2310,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def idleTimeout(timeout: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.idleTimeout(timeout.asScala))
+    new SubSource(delegate.idleTimeout(timeout.toScala))
 
   /**
    * If the time between the emission of an element and the following downstream demand exceeds the provided timeout,
@@ -2326,7 +2326,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def backpressureTimeout(timeout: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.backpressureTimeout(timeout.asScala))
+    new SubSource(delegate.backpressureTimeout(timeout.toScala))
 
   /**
    * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this
@@ -2346,7 +2346,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): SubSource[Out, Mat] =
-    new SubSource(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create()))
+    new SubSource(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create()))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -2378,7 +2378,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def throttle(elements: Int, per: java.time.Duration): javadsl.SubSource[Out, Mat] =
-    new SubSource(delegate.throttle(elements, per.asScala))
+    new SubSource(delegate.throttle(elements, per.toScala))
 
   /**
    * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate
@@ -2420,7 +2420,7 @@ final class SubSource[Out, Mat](
       per: java.time.Duration,
       maximumBurst: Int,
       mode: ThrottleMode): javadsl.SubSource[Out, Mat] =
-    new SubSource(delegate.throttle(elements, per.asScala, maximumBurst, mode))
+    new SubSource(delegate.throttle(elements, per.toScala, maximumBurst, mode))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -2457,7 +2457,7 @@ final class SubSource[Out, Mat](
       cost: Int,
       per: java.time.Duration,
       costCalculation: function.Function[Out, Integer]): javadsl.SubSource[Out, Mat] =
-    new SubSource(delegate.throttle(cost, per.asScala, costCalculation.apply _))
+    new SubSource(delegate.throttle(cost, per.toScala, costCalculation.apply _))
 
   /**
    * Sends elements downstream with speed limited to `cost/per`. Cost is
@@ -2503,7 +2503,7 @@ final class SubSource[Out, Mat](
       maximumBurst: Int,
       costCalculation: function.Function[Out, Integer],
       mode: ThrottleMode): javadsl.SubSource[Out, Mat] =
-    new SubSource(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply _, mode))
+    new SubSource(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply _, mode))
 
   /**
    * Detaches upstream demand from downstream demand without detaching the
@@ -2531,7 +2531,7 @@ final class SubSource[Out, Mat](
    * '''Cancels when''' downstream cancels
    */
   def initialDelay(delay: java.time.Duration): SubSource[Out, Mat] =
-    new SubSource(delegate.initialDelay(delay.asScala))
+    new SubSource(delegate.initialDelay(delay.toScala))
 
   /**
    * Change the attributes of this [[Source]] to the given ones and seal the list
@@ -2771,7 +2771,7 @@ final class SubSource[Out, Mat](
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = Option(emitOnTimer).map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         }))
   }
 
@@ -2804,7 +2804,7 @@ final class SubSource[Out, Mat](
         aggregate = (agg, out) => aggregate.apply(agg, out).toScala,
         harvest = agg => harvest.apply(agg),
         emitOnTimer = emitOnTimer.toScala.map {
-          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala)
+          case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala)
         }))
   }
 }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala
index 7255a02e6a..6b0655555e 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala
@@ -40,7 +40,7 @@ import pekko.stream.TLSClosing
 import pekko.stream.scaladsl
 import pekko.util.ByteString
 import pekko.util.FutureConverters._
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.OptionConverters._
 
 object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider {
@@ -355,6 +355,6 @@ class Tcp(system: ExtendedActorSystem) extends pekko.actor.Extension {
   }
 
   private def optionalDurationToScala(duration: Optional[java.time.Duration]) = {
-    if (duration.isPresent) duration.get.asScala else Duration.Inf
+    if (duration.isPresent) duration.get.toScala else Duration.Inf
   }
 }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala b/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala
index e92a33cf3f..8a857c2e08 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala
@@ -42,7 +42,7 @@ import pekko.stream.impl.io.ConnectionSourceStage
 import pekko.stream.impl.io.OutgoingConnectionStage
 import pekko.stream.impl.io.TcpIdleTimeout
 import pekko.util.ByteString
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.unused
 
 object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider {
@@ -114,7 +114,7 @@ final class Tcp(system: ExtendedActorSystem) extends pekko.actor.Extension {
 
   // TODO maybe this should be a new setting, like `pekko.stream.tcp.bind.timeout` / `shutdown-timeout` instead?
   val bindShutdownTimeout: FiniteDuration =
-    system.settings.config.getDuration("pekko.stream.materializer.subscription-timeout.timeout").asScala
+    system.settings.config.getDuration("pekko.stream.materializer.subscription-timeout.timeout").toScala
 
   /**
    * Creates a [[Tcp.ServerBinding]] instance which represents a prospective TCP server binding on the given `endpoint`.
diff --git a/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala b/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala
index 75a34504e1..3cc5107a89 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala
@@ -1759,8 +1759,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
    * adding the new timer.
    */
   final protected def scheduleOnce(timerKey: Any, delay: java.time.Duration): Unit = {
-    import pekko.util.JavaDurationConverters._
-    scheduleOnce(timerKey, delay.asScala)
+    import scala.jdk.DurationConverters._
+    scheduleOnce(timerKey, delay.toScala)
   }
 
   /**
@@ -1793,8 +1793,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
       timerKey: Any,
       initialDelay: java.time.Duration,
       interval: java.time.Duration): Unit = {
-    import pekko.util.JavaDurationConverters._
-    scheduleWithFixedDelay(timerKey, initialDelay.asScala, interval.asScala)
+    import scala.jdk.DurationConverters._
+    scheduleWithFixedDelay(timerKey, initialDelay.toScala, interval.toScala)
   }
 
   /**
@@ -1827,8 +1827,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
       timerKey: Any,
       initialDelay: java.time.Duration,
       interval: java.time.Duration): Unit = {
-    import pekko.util.JavaDurationConverters._
-    scheduleAtFixedRate(timerKey, initialDelay.asScala, interval.asScala)
+    import scala.jdk.DurationConverters._
+    scheduleAtFixedRate(timerKey, initialDelay.toScala, interval.toScala)
   }
 
   /**
diff --git a/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala b/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala
index d724722860..d1b840903b 100644
--- a/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala
+++ b/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala
@@ -23,7 +23,7 @@ import org.apache.pekko
 import pekko.actor._
 import pekko.annotation.InternalApi
 import pekko.testkit.{ TestActor, TestDuration, TestProbe }
-import pekko.util.JavaDurationConverters._
+import scala.jdk.DurationConverters._
 import pekko.util.ccompat.JavaConverters._
 
 /**
@@ -77,7 +77,7 @@ class TestKit(system: ActorSystem) {
   /**
    * Java timeouts (durations) during tests with the configured
    */
-  def dilated(duration: java.time.Duration): java.time.Duration = duration.asScala.dilated(getSystem).asJava
+  def dilated(duration: java.time.Duration): java.time.Duration = duration.toScala.dilated(getSystem).toJava
 
   /**
    * Query queue status.
@@ -144,20 +144,20 @@ class TestKit(system: ActorSystem) {
    * block or throw an [[java.lang.AssertionError]] if no `within` block surrounds this
    * call.
    */
-  def getRemaining: java.time.Duration = tp.remaining.asJava
+  def getRemaining: java.time.Duration = tp.remaining.toJava
 
   /**
    * Obtain time remaining for execution of the innermost enclosing `within`
    * block or missing that it returns the given duration.
    */
-  def getRemainingOr(duration: java.time.Duration): java.time.Duration = tp.remainingOr(duration.asScala).asJava
+  def getRemainingOr(duration: java.time.Duration): java.time.Duration = tp.remainingOr(duration.toScala).toJava
 
   /**
    * Obtain time remaining for execution of the innermost enclosing `within`
    * block or missing that it returns the properly dilated default for this
    * case from settings (key "pekko.test.single-expect-default").
    */
-  def getRemainingOrDefault: java.time.Duration = tp.remainingOrDefault.asJava
+  def getRemainingOrDefault: java.time.Duration = tp.remainingOrDefault.toJava
 
   /**
    * Execute code block while bounding its execution time between `min` and
@@ -178,7 +178,7 @@ class TestKit(system: ActorSystem) {
    * }}}
    */
   def within[T](min: java.time.Duration, max: java.time.Duration, f: Supplier[T]): T =
-    tp.within(min.asScala, max.asScala)(f.get)
+    tp.within(min.toScala, max.toScala)(f.get)
 
   /**
    * Execute code block while bounding its execution time between `min` and
@@ -198,7 +198,7 @@ class TestKit(system: ActorSystem) {
    *
    * }}}
    */
-  def within[T](max: java.time.Duration, f: Supplier[T]): T = tp.within(max.asScala)(f.get)
+  def within[T](max: java.time.Duration, f: Supplier[T]): T = tp.within(max.toScala)(f.get)
 
   /**
    * Await until the given condition evaluates to `true` or the timeout
@@ -222,7 +222,7 @@ class TestKit(system: ActorSystem) {
    * Note that the timeout is scaled using Duration.dilated,
    * which uses the configuration entry "pekko.test.timefactor".
    */
-  def awaitCond(max: java.time.Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max.asScala)
+  def awaitCond(max: java.time.Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max.toScala)
 
   /**
    * Await until the given condition evaluates to `true` or the timeout
@@ -235,7 +235,7 @@ class TestKit(system: ActorSystem) {
    * which uses the configuration entry "pekko.test.timefactor".
    */
   def awaitCond(max: java.time.Duration, interval: java.time.Duration, p: Supplier[Boolean]): Unit =
-    tp.awaitCond(p.get, max.asScala, interval.asScala)
+    tp.awaitCond(p.get, max.toScala, interval.toScala)
 
   /**
    * Await until the given condition evaluates to `true` or the timeout
@@ -248,7 +248,7 @@ class TestKit(system: ActorSystem) {
    * which uses the configuration entry "pekko.test.timefactor".
    */
   def awaitCond(max: java.time.Duration, interval: java.time.Duration, message: String, p: Supplier[Boolean]): Unit =
-    tp.awaitCond(p.get, max.asScala, interval.asScala, message)
+    tp.awaitCond(p.get, max.toScala, interval.toScala, message)
 
   /**
    * Evaluate the given assert every `interval` until it does not throw an exception and return the
@@ -276,7 +276,7 @@ class TestKit(system: ActorSystem) {
    * Note that the timeout is scaled using Duration.dilated,
    * which uses the configuration entry "pekko.test.timefactor".
    */
-  def awaitAssert[A](max: java.time.Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max.asScala)
+  def awaitAssert[A](max: java.time.Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max.toScala)
 
   /**
    * Evaluate the given assert every `interval` until it does not throw an exception.
@@ -288,7 +288,7 @@ class TestKit(system: ActorSystem) {
    * @return an arbitrary value that would be returned from awaitAssert if successful, if not interested in such value you can return null.
    */
   def awaitAssert[A](max: java.time.Duration, interval: java.time.Duration, a: Supplier[A]): A =
-    tp.awaitAssert(a.get, max.asScala, interval.asScala)
+    tp.awaitAssert(a.get, max.toScala, interval.toScala)
 
   /**
    * Same as `expectMsg(remainingOrDefault, obj)`, but correctly treating the timeFactor.
@@ -302,7 +302,7 @@ class TestKit(system: ActorSystem) {
    *
    * @return the received object
    */
-  def expectMsgEquals[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.asScala, obj)
+  def expectMsgEquals[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.toScala, obj)
 
   /**
    * Same as `expectMsg(remainingOrDefault, obj)`, but correctly treating the timeFactor.
@@ -314,7 +314,7 @@ class TestKit(system: ActorSystem) {
    * given object. Wait time is bounded by the given duration, with an
    * AssertionFailure being thrown in case of timeout.
    */
-  def expectMsg[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.asScala, obj)
+  def expectMsg[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.toScala, obj)
 
   /**
    * Receive one message from the test actor and assert that it equals the
@@ -347,7 +347,7 @@ class TestKit(system: ActorSystem) {
    * processing.
    */
   def expectMsgPF[T](max: java.time.Duration, hint: String, f: JFunction[Any, T]): T = {
-    tp.expectMsgPF(max.asScala, hint)(new CachingPartialFunction[Any, T] {
+    tp.expectMsgPF(max.toScala, hint)(new CachingPartialFunction[Any, T] {
       @throws(classOf[Exception])
       override def `match`(x: Any): T = f.apply(x)
     })
@@ -363,7 +363,7 @@ class TestKit(system: ActorSystem) {
    * the given class. Wait time is bounded by the given duration, with an
    * AssertionFailure being thrown in case of timeout.
    */
-  def expectMsgClass[T](max: java.time.Duration, c: Class[T]): T = tp.expectMsgClass(max.asScala, c)
+  def expectMsgClass[T](max: java.time.Duration, c: Class[T]): T = tp.expectMsgClass(max.toScala, c)
 
   /**
    * Same as `expectMsgAnyOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor.
@@ -377,7 +377,7 @@ class TestKit(system: ActorSystem) {
    * AssertionFailure being thrown in case of timeout.
    */
   @varargs
-  def expectMsgAnyOfWithin[T](max: java.time.Duration, objs: T*): T = tp.expectMsgAnyOf(max.asScala, objs: _*)
+  def expectMsgAnyOfWithin[T](max: java.time.Duration, objs: T*): T = tp.expectMsgAnyOf(max.toScala, objs: _*)
 
   /**
    * Same as `expectMsgAllOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor.
@@ -394,7 +394,7 @@ class TestKit(system: ActorSystem) {
    */
   @varargs
   def expectMsgAllOfWithin[T](max: java.time.Duration, objs: T*): JList[T] =
-    tp.expectMsgAllOf(max.asScala, objs: _*).asJava
+    tp.expectMsgAllOf(max.toScala, objs: _*).asJava
 
   /**
    * Same as `expectMsgAnyClassOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor.
@@ -409,7 +409,7 @@ class TestKit(system: ActorSystem) {
    */
   @varargs
   def expectMsgAnyClassOf[T](max: java.time.Duration, objs: Class[_]*): T =
-    tp.expectMsgAnyClassOf(max.asScala, objs: _*).asInstanceOf[T]
+    tp.expectMsgAnyClassOf(max.toScala, objs: _*).asInstanceOf[T]
 
   /**
    * Assert that no message is received. Waits for the default period configured as
@@ -422,7 +422,7 @@ class TestKit(system: ActorSystem) {
    * Assert that no message is received for the specified time.
    * Supplied value is not dilated.
    */
-  def expectNoMessage(max: java.time.Duration): Unit = tp.expectNoMessage(max.asScala)
+  def expectNoMessage(max: java.time.Duration): Unit = tp.expectNoMessage(max.toScala)
 
   /**
    * Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.
@@ -433,7 +433,7 @@ class TestKit(system: ActorSystem) {
    * @param target the actor ref expected to be Terminated
    * @return the received Terminated message
    */
-  def expectTerminated(max: java.time.Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max.asScala)
+  def expectTerminated(max: java.time.Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max.toScala)
 
   /**
    * Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.
@@ -454,7 +454,7 @@ class TestKit(system: ActorSystem) {
    *         partial function returned true
    */
   def fishForMessage(max: java.time.Duration, hint: String, f: JFunction[Any, Boolean]): Any =
-    tp.fishForMessage(max.asScala, hint)(new CachingPartialFunction[Any, Boolean] {
+    tp.fishForMessage(max.toScala, hint)(new CachingPartialFunction[Any, Boolean] {
       @throws(classOf[Exception])
       override def `match`(x: Any): Boolean = f.apply(x)
     })
@@ -463,7 +463,7 @@ class TestKit(system: ActorSystem) {
    * Same as `fishForMessage`, but gets a different partial function and returns properly typed message.
    */
   def fishForSpecificMessage[T](max: java.time.Duration, hint: String, f: JFunction[Any, T]): T = {
-    tp.fishForSpecificMessage(max.asScala, hint)(new CachingPartialFunction[Any, T] {
+    tp.fishForSpecificMessage(max.toScala, hint)(new CachingPartialFunction[Any, T] {
       @throws(classOf[Exception])
       override def `match`(x: Any): T = f.apply(x)
     })
@@ -479,7 +479,7 @@ class TestKit(system: ActorSystem) {
   /**
    * Receive N messages in a row before the given deadline.
    */
-  def receiveN(n: Int, max: java.time.Duration): JList[AnyRef] = tp.receiveN(n, max.asScala).asJava
+  def receiveN(n: Int, max: java.time.Duration): JList[AnyRef] = tp.receiveN(n, max.toScala).asJava
 
   /**
    * Receive one message from the internal queue of the TestActor. If the given
@@ -487,7 +487,7 @@ class TestKit(system: ActorSystem) {
    *
    * This method does NOT automatically scale its Duration parameter!
    */
-  def receiveOne(max: java.time.Duration): AnyRef = tp.receiveOne(max.asScala)
+  def receiveOne(max: java.time.Duration): AnyRef = tp.receiveOne(max.toScala)
 
   /**
    * Receive a series of messages until one does not match the given partial
@@ -505,7 +505,7 @@ class TestKit(system: ActorSystem) {
       idle: java.time.Duration,
       messages: Int,
       f: JFunction[AnyRef, T]): JList[T] = {
-    tp.receiveWhile(max.asScala, idle.asScala, messages)(new CachingPartialFunction[AnyRef, T] {
+    tp.receiveWhile(max.toScala, idle.toScala, messages)(new CachingPartialFunction[AnyRef, T] {
       @throws(classOf[Exception])
       override def `match`(x: AnyRef): T = f.apply(x)
     })
@@ -513,7 +513,7 @@ class TestKit(system: ActorSystem) {
   }
 
   def receiveWhile[T](max: java.time.Duration, f: JFunction[AnyRef, T]): JList[T] = {
-    tp.receiveWhile(max = max.asScala)(new CachingPartialFunction[AnyRef, T] {
+    tp.receiveWhile(max = max.toScala)(new CachingPartialFunction[AnyRef, T] {
       @throws(classOf[Exception])
       override def `match`(x: AnyRef): T = f.apply(x)
     })


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pekko.apache.org
For additional commands, e-mail: commits-help@pekko.apache.org