Java排序之sort方法使用代码解析

本篇文章小编给大家分享一下Java排序之sort方法使用代码解析，文章代码介绍的很详细，小编觉得挺不错的，现在分享给大家供大家参考，有需要的小伙伴们可以来看看。

升序

升序是默认情况下的，所以这里就简单展示一下使用的方法；

数组

数组的sort方法位于Arrays工具类下

代码如下：

import java.util.Arrays;

public class SortTest01 {
    public static void main(String[] args) {
        int[] array = {2, 4, 8, 9, 78, 1, 3, 66}; // 整型数组
        Arrays.sort(array); // 升序排序
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

结果如下：

1 2 3 4 8 9 66 78

集合

集合的sort方法位于Collections类下

代码如下：

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class SortTest02 {
    public static void main(String[] args) {
        List list = new LinkedList<>(); // 定义一个链表
        // 降序放入list
        for (int i = 10; i >= 0; --i) {
            list.add(i);
        }
        Collections.sort(list); // 升序排序
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下：

0 1 2 3 4 5 6 7 8 9 10

降序

降序就需要一点额外的步骤；这里就需要用到一个接口：Comparator

其实实际上我们用到的只是Comparator接口中的一个方法，也是这个接口唯一的方法：int compare(T o1, T o2)；

sort方法默认情况下是升序，但是它的一个重载版本可以额外放一个Comparator的参数，作为一个比较器

可以看看Collections的sort方法：

还有Arrays里的sort方法

可以看到它们都Comparator参数，所以我们只需要在这里制定指定的规则，就可以按照我们的方式进行排序；

所以接下来的问题就是如何实现Comparator接口并重写int compare(T o1, T o2)方法了，这里我提供三种方法：

下面就只用集合来作为例子；

声明一个类实现接口

代码如下：

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest03 {
    public static void main(String[] args) {
        List list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        Collections.sort(list, new MyCompare()); // 降序排序
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}
class MyCompare implements Comparator {
    // 制定排序规则：降序
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

匿名内部类实现接口

代码如下：

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest04 {
    public static void main(String[] args) {
        List list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        // 匿名内部类降序排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

Lambda表达式实现接口

代码如下：

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class SortTest04 {
    public static void main(String[] args) {
        List list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        // Lambda表达式降序排序
        Collections.sort(list, (o1, o2) -> o2 - o1);
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下：

10 9 8 7 6 5 4 3 2 1 0

这三种方法还是需要根据实际情况使用的，假如这个排序规则需要多次使用，还是单独创建一个类实现比较好；

如果只是使用一次，那么就用匿名内部类或者Lambda表达式，相对而言Lambda表达式更简单；

自定义数据类型的排序

如果想要对自己定义的类实例化的对象进行排序，那么同样需要Comparator去指定排序的规则；

下面例子通过创建一个类的方式来实现接口；

代码如下：

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest05 {
    public static void main(String[] args) {
        List list = new LinkedList<>(); // 创建一个链表
        list.add(new Student(18, "202101", "张三"));
        list.add(new Student(28, "202180", "李四"));
        list.add(new Student(11, "202135", "王五"));
        list.add(new Student(18, "202169", "赵六"));
        list.add(new Student(11, "202122", "小七"));
        list.add(new Student(48, "202156", "碧萝"));
        // 排序前
        for (var i : list) {
            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());
        }
        Collections.sort(list, new StuCompare()); // 自定义排序规则排序
        // 排序后
        System.out.println("=======================");
        for (var i : list) {
            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());
        }
    }
}
// 学生类
class Student {
    private int age; // 年龄
    private String ID; // 学号
    private String name; // 姓名

    public Student() {
    }
    public Student(int age, String ID, String name) {
        this.age = age;
        this.ID = ID;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getID() {
        return ID;
    }
    public void setID(String ID) {
        this.ID = ID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
// 学生排序类
class StuCompare implements Comparator {
    // 升序
    @Override
    public int compare(Student o1, Student o2) {
        int flag;
        // 先通过年龄排序
        flag = o1.getAge() - o2.getAge();
        // 如果年龄相同，则通过学号比较排序
        if (flag == 0) {
            flag = o1.getID().compareTo(o2.getID());
        }
        return flag;
    }
}

结果如下：

name:张三 age:18 ID:202101

name:李四 age:28 ID:202180

name:王五 age:11 ID:202135

name:赵六 age:18 ID:202169

name:小七 age:11 ID:202122

name:碧萝 age:48 ID:202156

=======================

name:小七 age:11 ID:202122

name:王五 age:11 ID:202135

name:张三 age:18 ID:202101

name:赵六 age:18 ID:202169

name:李四 age:28 ID:202180

name:碧萝 age:48 ID:202156

可以看出来我们可以自己定义自定义类型的排序规则，非常简单；

这里我使用一个类实现了Comparator，匿名内部类和Lambda表达式也可以；但是还是一样，如果经常需要排序还是推荐定义一排序类，这样用起来更方便；

总结：

需要掌握的就是两点：

sort基本方法使用

Comparator接口的使用（这里注意一下：不要和Comparable弄混）