Java 比较器 Arrays.sort()

我想排序一个arrayJava中的二维数组根据一些规则，比如说距原点的距离。我看到了几种使用方法Arrays.sort():

1) Arrays.sort(points, Comparator.comparing(p -> p[0]*p[0] + p[1]*p[1]));

2) Arrays.sort(points, (p1, p2) -> p1[0]*p1[0] + p1[1]*p1[1] - p2[0]*p2[0] - p2[1]*p2[1]);

3）定义class:

class Point implements Comparable<Point>{
     // class variables, constructor
     public int compareTo(Point p) {
         return (x*x + y*y).compareTo(p.x*p.x + p.y*p.y);
     }
}

数组pts类型的Points然后创建并且Arrays.sort(pts)用来。我的问题是关于1) and 2)：我看到了两者之间的区别，但我不明白何时使用其中一种，何时使用另一种，以及到底是什么Comparator.comparing()是在做。为什么第一个解决方案只携带一个点，而第二个解决方案需要两个点？

Comparator.comparing实现如下：

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
        Function<? super T, ? extends U> keyExtractor)
{
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

即它使用Function您传递给它以便将每个比较的元素转换为Comparable，然后使用Comparable's compareTo method.

当你传递函数时p -> p[0]*p[0] + p[1]*p[1]，您将每个点转换为其平方和。然后，当Comparator需要比较两个点，它比较两个点的平方和，这几乎相当于计算两个点的平方和的差（这并不完全等价，因为通过计算它们的差来比较两个数字可以产生数字溢出时输出错误）。

这正是你的第二个Comparator - (p1, p2) -> p1[0]*p1[0] + p1[1]*p1[1] - p2[0]*p2[0] - p2[1]*p2[1] - does,

since p1[0]*p1[0] + p1[1]*p1[1] - p2[0]*p2[0] - p2[1]*p2[1] == (p1[0]*p1[0] + p1[1]*p1[1]) - (p2[0]*p2[0] + p2[1]*p2[1]).

Using Comparator.comparing()更安全，因为它比较两个点的平方和而不计算它们的差。它用Double's compareTo()相反（假设你的点的坐标是Double or double).

换句话说，第一个替代方案使用Function只需要一点，因为这个函数告诉Comprator.comparing如何变换这 2 个点中的每一个。

另一方面，第二种选择接受 2 点（这是Comparator.compare()方法）并确定这两个点的相对顺序。