Java 类似对象的惯用用法

发布于 2024-12-20 16:22:39 字数 168 浏览 1 评论 0原文

我正在使用一些 java.util.Date （它实现了 java.lang.Comparable）并且希望能够很好地使用它，例如使用 <和 >= 而不是“compareTo(other) == 1”。有没有一种很好的方法可以轻松地混合像 scala.math.Ordered 这样的东西，而不需要大量的样板？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

不乱于心 2024-12-27 16:22:39

在 Ordering 伴生对象中，存在从 Comparable[A] 到 Ordering[A] 的隐式转换。所以你可以这样做：

import java.util.Date

val dateOrdering = implicitly[Ordering[Date]]
import dateOrdering._

val now = new Date
val then = new Date(now.getTime + 1000L)

println(now < then) // true

In the Ordering companion object there is an implicit conversion from Comparable[A] to Ordering[A]. So you can do this:

import java.util.Date

val dateOrdering = implicitly[Ordering[Date]]
import dateOrdering._

val now = new Date
val then = new Date(now.getTime + 1000L)

println(now < then) // true

回复收藏 0 原文

尴尬癌患者 2024-12-27 16:22:39

我知道这是一个老问题，但这里有一个稍微简单的解决方案，在提出问题时可能不可用。

import scala.math.Ordering.Implicits._

任何实现 Comparable 的 Java 类型都应该与比较运算符无缝协作。例如，

import java.time.Instant

val x = Instant.now()
val y = x.plusSeconds(1)

print(x < y)   // prints true
print(x <= y)  // prints true
print(x > y)   // prints false

I know this is an old question, but here's a slightly simpler solution that may not have been available when the question was asked.

import scala.math.Ordering.Implicits._

Any Java types that implement Comparable should then work seamlessly with comparison operators. For example,

import java.time.Instant

val x = Instant.now()
val y = x.plusSeconds(1)

print(x < y)   // prints true
print(x <= y)  // prints true
print(x > y)   // prints false

回复收藏 0 原文

蝶舞 2024-12-27 16:22:39

在这种情况下，你不能混合使用 Ordered ，afaik...我尝试了一下，但遇到了困难，因为 compareTo 在那里和 java.lang 中都定义了.可比较。编译器抱怨 Ordered 在方法的定义中没有使用 override；我不知道如何解决这个问题。

因此定义一个隐式的Ordering[Date]。您可以将此DateOrdering 对象放在任何地方（例如，在伴生对象中）。

import java.util.Date
implicit object DateOrdering extends Ordering[Date] {
  def compare(x: Date, y: Date) = x compareTo y
}

然后在您的代码中：

import DateOrdering._
val a = new Date
Thread.sleep(1000)
val b = new Date
println(a < b)     // prints true
println(a >= b)    // prints false

Ordering 对象包含一个隐式 def mkOrderingOps (lhs: T): Ops。 Ops 类包含 <。 >= 等方法，并且此隐式 def 是 根据 Ordering 的类型参数（此处为任何 Date 实例）来拉皮条我的库模式。

You can't mix in Ordered in this case, afaik... I tried it and ran into difficulties because compareTo is defined both there and in java.lang.Comparable. The compiler complains that Ordered doesn't use override in its definition of the method; I don't know how to get around that.

So define an implicit Ordering[Date]. You can put this DateOrdering object anywhere (e.g. in companion object).

import java.util.Date
implicit object DateOrdering extends Ordering[Date] {
  def compare(x: Date, y: Date) = x compareTo y
}

Then in your code:

import DateOrdering._
val a = new Date
Thread.sleep(1000)
val b = new Date
println(a < b)     // prints true
println(a >= b)    // prints false

The Ordering object contains an implicit def mkOrderingOps (lhs: T): Ops. The Ops class contains the <. >= etc methods, and this implicit def is an example of the pimp my library pattern on whatever the type parameter of the Ordering is (here, any Date instance).

回复收藏 0 原文

~没有更多了~