Question

我有一个员工集合。每位员工都有一个ID。此ID号具有格式 -x＆gt; = 0＆gt; = x。我必须将Employees排序为0 ... x -1 ....- x。我怎么能这样做？

List<Employee> empSort = new ArrayList(em.getEmployees());
Collections.sort(empSort, new Comparator<Employee>() {
                @Override
                public int compare(Employee p1, Employee p2) {
                   // WHAT LOGIC SHOULD I DO THERE TO HAVE THEM
                                      SORTED AS 0...x -1....-x
                }
            });

Answer 1

在晚餐时给了一些想法，我更喜欢这个。

int sign1 = (p1 >= 0) ? 1 : -1;
int sign2 = (p2 >= 0) ? 1 : -1;

int result = Integer.compare(sign2, sign1);

if( result == 0){
    // same sign
    result = sign1 * Integer.compare(p1, p2);
}
return result;

输出仍然是：

[0, 0, 0, 1, 3, 5, -1, -2]

Answer 2

你能不进行三次测试吗？

非负面来自负面。 return如果只有一个是否定的。

如果两者都是否定的，较大的值出现在较小的值之前。

如果两者都是非负面的，较小的值出现在较大的值之前。

Answer 3

比较返回负整数，零或正整数，因为第一个参数小于，等于或大于第二个参数。

if( p1.id * p2.id < 0 ) {
    // opposite sign
    // if p1 is negative, p2 is positive, p1 is greater than p2
    // otherwise p1 is positive, p2 is negative, p1 is less than p2
    return -p1.id;
}
if( p1.id > 0 && p2.id > 0 || p1.id + p2.id >= 0) {
    // both positive, normal ordering or a zero and a positive number, also normal ordering
    return p1.id - p2.id;
}
if( p1.id <0 && p2.id < 0 ){
    // both negative, inverse ordering
    return p2.id - p1.id;
}
// zero and a negative number, zero comes first
if( p1.id == 0 ) {
    return -1;
}
return 1;

[0,0,0,1,3,5，-1，-2]

Answer 4

这很模糊，但你可以做到

Integer.compare(x >= 0 ? x + Integer.MIN_VALUE : ~x, y >= 0 ? y + Integer.MIN_VALUE);

甚至更加模糊

Integer.compare(x ^ (-1 << ~(x >> -1)), y ^ (-1 << ~(y >> -1)))

注意：相同的公式适用于long s;）

将[0，Integer.MAX_VALUE]映射到[Integer.MIN_VALUE，-1]并将[Integer.MIN_VALUE，-1]翻转为[0，Integer.MAX_VALUE]

集合排序 - 正，0，负序

4 个答案: