java中list的sort()功能如何使用？如果倒序如何正序？-神猿问答

1

采纳

在java8以前，list是没有sort()这个方法的。

如果需要对list进行排序可以把list转化为数组。

在Java8中，接口加入了默认方法。而List的sort就是这样一个默认方法。

    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

从源码中可以看出，该方法的原理实际上还是将List转化为了数组，再对数组进行排序。

该方法接收一个Comparator参数。

如果list里面放的类型实现了Comparable接口

那么可以这样调用

        List<Integer> list = IntStream.of(10,4,50,34,56,234,22,665,78,54,53).collect(ArrayList::new, List::add,
                List::addAll);
        list.sort(Integer::compareTo);

如果是普通的类型

public class Test {
    public static void main(String[] args) {
        List<NormalClass> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(NormalClass.getRandom());
        }
        list.sort(Test::compare);
    }
    static int compare(NormalClass n1, NormalClass n2) {
        if (n1.a == n2.a) {
            return n1.b - n2.b;
        }
        return n1.a - n2.a;
    }
}
class NormalClass {
    int a;
    int b;
    static NormalClass getRandom() {
        Random random = new Random();
        NormalClass n = new NormalClass();
        n.a = random.nextInt();
        n.b = random.nextInt();
        return n;
    }
}

采纳答案

很二很温柔

修改

0

采纳

排序时正序/倒序处理起来可能会混淆，可以用更简单的方法。
可以使用java.util自带的比较器来做

Comparator.comparingInt(Integer::intValue).reversed() // 倒序
Comparator.comparingInt(Integer::intValue) // 正序

示例：

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList(1, 2, 3);
        list.sort(Comparator.comparingInt(Integer::intValue).reversed()); // 倒序
        print(list);
        list.sort(Comparator.comparingInt(Integer::intValue)); // 默认正序
        print(list);
        List<Integer> list2 = Lists.newArrayList(1, 2, 3);
        list2 = list2.stream().sorted(Comparator.comparingInt(Integer::intValue).reversed())
                .collect(Collectors.toList()); // 倒序
        print(list2);
        list2 = list2.stream().sorted(Comparator.comparingInt(Integer::intValue))
                .collect(Collectors.toList()); // 默认正序
        print(list2);
    }
    /**
     * 输出
     */
    private static <T> void print(List<T> list) {
        list.forEach(e -> System.out.print(e + ","));
        System.out.println();
    }
}

上面代码执行输出为：

3,2,1,
1,2,3,
3,2,1,
1,2,3,

对于复杂对象，比如User,想通过年龄来比较

public class User {
    public String name; // 姓名
    public int age; // 年龄
    public int getAge() {
        return age;
    }
}

可以使用：

Comparator.comparingInt(User::getAge).reversed() // 倒序
Comparator.comparingInt(User::getAge) // 正序

采纳答案

hong

修改

-1

采纳

list.sort()接收一个Comparable接口，其中compare方法是必须实现的，int compare(T o1, T o2);，它接受两个参数：o1，o2. o2表示list排序前的前值，o1为后值，compare对他们通过比较进行排序。compare如果返回1则表示o1在后，o2在前（等价于位置不变）；返回-1表示o1在前o2在后(等价置换o1与o2的位置)；返回0表示位置不变
可以使用lambda表达式进行从小到大排序：

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            list.add(random.nextInt(100));
        }
        // 从小到大排序
        list.sort((o1, o2) -> {
            if (o1.equals(o2)) {
                return 0;
            } else if (o1 > o2) {
                //o2为前值，o1为后值；这里理解为：后值比前值大，则不交换位置,等价从小到大排序
                //如果这里返回 -1，则为从大到小排序
                return 1;
            } else {
                //后值比前值小，则交换位置
                return -1;
            }
        });
        list.forEach(e -> System.out.print(e + " "));
    }

如果需要从大到小排序，只需要将代码中 return 1改成return -1, return -1改成return 0即可.

采纳答案

hong

修改