Question

标题不言自明。 E.g

[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 []转换为List＆lt;整数＆gt;，并使用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[]，这有点乱。

您可以定义比较器，但由于泛型不适用于基元，因此它不适用于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()将其加到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())进行排序：

@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+，请随意使用。

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

4 个答案: