Scala sortWith for java.sql.Timestamp有时会或赢得'；使用两个下划线时不编译

我很困惑为什么

实现comparable

的类型不是“隐式可比的”，为什么

sortWith

的某些语法根本不会编译：

//iter是一组记录，每个事件的时间都是一个java.sql.Timestamp
//A.有效，但不会排序
val records=iter.toArray.sortWith（u.event\u time.getTime（r.event\u time））
//C.不编译，抱怨第二行，尽管它像第一行
val记录=iter.toArray.sortWith（u.event\u time.before（u.event\u time））
//不编译，也抱怨，虽然它更像第一行
val记录=iter.toArray.sortWith（uu.event\u time.compareTo（uu.event\u time）<0）
//E.Works，按纪元毫秒排序，然后按毫秒后的毫微秒排序。
val记录=iter.toArray.sortBy（r=>
（r.event\u time.getTime，r.event\u time.getNanos））
//但这就留下了关于sortWith的上述用法的问题，这些用法不起作用

考虑到第一行使用了两个下划线，我不明白为什么编译器会抱怨sortsWith的其他用法。是否有一些语法可以愉快地使用

before

方法？以某种方式使用时间戳的可比状态与行B

也许我应该注意到我在JDK 8中使用的是Scala 2.11.12，因为它是针对AWS EMR部署的特定版本的Spark

我可以看到，使用Scala 2.13.6行B编译并工作， 然而，在2.11.12中，我得到了：

No implicit Ordering defined for java.sql.Timestamp.
not enough arguments for method sortBy: (implicit ord: scala.math.Ordering[java.sql.Timestamp])List[Playground.Foo].
Unspecified value parameter ord.

我不清楚如何满足它的要求

然后行C给出的错误是：

missing parameter type for expanded function ((x$5) => x$5.event_time.before(((x$6) => x$6.event_time)))

而行D类似于：

missing parameter type for expanded function ((x$7) => x$7.event_time.compareTo(((x$8) => x$8.event_time)).$less(0))

如下面的回答所述，C和D可以用另一种语法完成：

val records=iter.toArray.sortWith{case（a，b）=>
a、 事件时间。之前（b.事件时间）}//C
val records=iter.toArray.sortWith{case（a，b）=>
a、 事件时间。与（b.事件时间）<0}//D比较

这让我修复了除2.11.12中B行之外的所有显示方式（请参见）

不知道你为什么认为它不起作用。为了我。。。 （顺便说一句，你有太多难看的括号。这最好写为

排序（事件时间）

是的，这些下划线占位符仅在直接作用域级别工作。 上面的这个表达式可以翻译为

   .sortWith(x => x.event_time.before(y => y.event_time))

当然，这是无效的。 有关如何在上下文中解释下划线的说明，请参见。 如果有疑问，只需显式声明变量：

.sortWith { case(a,b) => a.event_time.before(b.event_time) }

//不编译，也会抱怨，尽管它更像第一行
val记录=iter.toArray.sortWith（uu.event\u time.compareTo（uu.event\u time）<0）

---

与上述相同的原因/相同的修复方法通过扩展类型的

排序来提供
比较
的实现是行B问题的一个解决方法（在Scala 2.11.12中）：

导入java.sql.Timestamp
案例类记录（事件时间：时间戳）扩展已排序的[Record]{
def compare（that:Record）=this.event\u time.compareTo（that.event\u time）
}
def正确（记录：列表[记录]）=(
if（（records.head比较records.last）<0）“C”else“Inc”
)+“顺序正确”
val now1=新的时间戳（System.currentTimeMillis（））
现在1.setNanos（999000001）
val now2=新的时间戳（now1.getTime（））
现在2.setNanos（99999999）
val记录在：列表[记录]=新记录（now2）：：新记录（now1）：：无
//A.有效，但不会排序
val records\u outA=记录\u in.sortWith（u.event\u time.getTime（r.event\u time））
//B.通过依赖Record类对Orderable的定义来工作
val records\u outB=已排序的记录
println（“B:+记录输出B+正确（记录输出B））
//C.不编译，抱怨第二行，尽管它像第一行
//val records\u outC=记录\u in.sortWith（u.event\u time.before（u.event\u time））
//C.通过更改参数来使用显式命名的参数
val records\u outC=记录\u in.sortWith（（a，b）=>a.event\u time.before（b.event\u time））
println（“C:+记录\输出C+正确（记录\输出C））
//不编译，也抱怨，虽然它更像第一行
//val records\u outD=记录\u in.sortWith（\u.event\u time.compareTo（\u.event\u time）<0）
//D.通过将参数更改为没有隐式参数的其他参数来工作
val records\u outD=records\u in.sortWith{case（a，b）=>a.event\u time.compareTo（b.event\u time）<0}
println（“D:+记录输出+正确（记录输出））
//E.Works，按纪元毫秒排序，然后按毫秒后的毫微秒排序。
val records\u outE=记录\u in.排序（r=>
（r.event\u time.getTime，r.event\u time.getNanos））
println（“E:+记录输出+正确（记录输出））

委员会：

我想我应该说，由于使用Scala 2.11处理特定的EMR和spark内置。对于jdk 8，可能稍后的更新解决了其中一些问题。感谢案例（a，b）建议修复。
// Doesn't compile, complains about the 2nd _ though it's like the first line
val records = iter.toArray.sortWith(_.event_time.before(_.event_time))

   .sortWith(x => x.event_time.before(y => y.event_time))

.sortWith { case(a,b) => a.event_time.before(b.event_time) }

// Doesn't compile, also complains though it's more like the first line
val records = iter.toArray.sortWith(_.event_time.compareTo(_.event_time) < 0)

A: List(Record(2021-06-14 23:19:12.999999999), Record(2021-06-14 23:19:12.999000001)) Incorrectly ordered
B: List(Record(2021-06-14 23:19:12.999000001), Record(2021-06-14 23:19:12.999999999)) Correctly ordered
C: List(Record(2021-06-14 23:19:12.999000001), Record(2021-06-14 23:19:12.999999999)) Correctly ordered
D: List(Record(2021-06-14 23:19:12.999000001), Record(2021-06-14 23:19:12.999999999)) Correctly ordered
E: List(Record(2021-06-14 23:19:12.999000001), Record(2021-06-14 23:19:12.999999999)) Correctly ordered