Java如何按降序排列有符号整数数组，忽略这些符号？

Question

标题是不言自明的。 例如

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

会变成

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

我的策略是先按升序排序，然后按负数和正数分别对它们进行排序，但我的策略是模糊的。 我知道这很模糊，但你的答案对我很有帮助。

Answer 1

简洁版本 ：

Integer[] ary = { 2, 1, 0, -2, -5 };

Arrays.sort(ary, (Integer i1, Integer i2) -> Math.abs(i2) - Math.abs(i1));
System.out.println(Arrays.toString(ary));

不需要ArrayList。 但是需要整数而不是int。

我的第一个答案是：

我首先从int []转换为List <Integer>，然后使用Lambda比较器按照您想要的方式对其进行排序。

int[] ary = { 2, 1, 0, -2, -5 };

List<Integer> intList = new ArrayList<Integer>();
for (int index = 0; index < ary.length; index++) { 
  intList.add(ary[index]);
} 

intList.sort((Integer i1, Integer i2) -> Math.abs(i2) - Math.abs(i1));

System.out.println(intList);

它返回

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

Answer 2

如果你真的需要一个int[]这有点乱。

您可以定义一个Comparator，但由于Generics不能使用原语，因此它不适用于int[] 。

Comparator<Integer> integerComparator = (x, y) -> Integer.compare(Math.abs(x), Math.abs(y));

使用List<Integer>和Integer[]更容易：

List<Integer> integerList = Arrays.asList(2, 1, 0, -2, -5);
Integer[] integerArray = new Integer[] {2, 1, 0, -2, -5};


integerList.sort(integerComparator.reversed());
Arrays.sort(integerArray,integerComparator.reversed());
System.out.println("ints = " + integerList);
System.out.println("integerArray = " + Arrays.toString(integerArray));

使用int[] ，它更加混乱。 您可以使用IntStream并使用boxed()将其IntStream Stream<Integer> 。 但是，你会受到性能影响，但除非你正在处理大型数组或在应用程序的关键部分使用它，否则它不会成为问题。

int[]primitiveArray = new int[]{2, 1, 0, -2, -5};

int[] ints = IntStream.of(primitiveArray)
        .boxed()
        .sorted(integerComparator.reversed())
        .mapToInt(Integer::valueOf)
        .toArray();

System.out.println("ints = " + Arrays.toString(ints));

Answer 3

只需对输入comparing(Math::abs, reverseOrder())排序comparing(Math::abs, reverseOrder()) ：

@Test
public void test() {
    List<Integer> input = asList(2, 1, 0, -2, -5);

    List<Integer> output = input.stream()
            .sorted(comparing(Math::abs, reverseOrder()))
            .collect(toList());

    System.out.println(output);
}

输出

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

需要进口：

import org.junit.Test;

import java.util.List;

import static java.util.Arrays.asList;
import static java.util.Comparator.comparing;
import static java.util.Comparator.reverseOrder;
import static java.util.stream.Collectors.toList;

Answer 4

这是一个过度面向对象的解决方案，不需要内存将数组复制到List，不需要将List解包回数组，也不需要重新发明任何排序算法：

final int[] array = new int[] {2, 1, 0, -2, -5};
Collections.sort(
        new AbstractList<Integer>() {
            public Integer get(int index) {
                return array[index];
            }

            public int size() {
                return array.length;
            }

            @Override
            public Integer set(int index, Integer element) {
                int old = array[index];
                array[index] = element;
                return old;
            }
        },
        new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return Math.abs(o1) - Math.abs(o2);
            }
        }
);

如果你有Commons Lang，它会更清洁：

final int[] array = new int[] {2, 1, 0, -2, -5};
Collections.sort(
        ArrayUtils.toObject(array),
        new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return Math.abs(o1) - Math.abs(o2);
            }
        }
);

来自另一个答案的比较器((Integer i1, Integer i2) -> Math.abs(i2) - Math.abs(i1)) ，如果是这里的那个就是lambda版本。 如果你有Java 8+，请随意使用。