目录
- lambda表达式实现接口
引言
在学习java过程中，排序sort是我们常用的功能；在java里，数组有arrays.sort()可以排序，集合则是collections.sort()方法排序；默认情况下是升序排列，但是降序又该怎么排？又可以通过哪几种方法呢？自定义类型又该怎么做？
下面就来介绍一下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<integer> 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<t>
其实实际上我们用到的只是comparator<t> 接口中的一个方法，也是这个接口唯一的方法：int compare(t o1, t o2)；
sort方法默认情况下是升序，但是它的一个重载版本可以额外放一个comparator<t>的参数，作为一个比较器
可以看看collections的sort方法：
还有arrays里的sort方法
可以看到它们都comparator<t>参数，所以我们只需要在这里制定指定的规则，就可以按照我们的方式进行排序；
所以接下来的问题就是如何实现comparator<t> 接口并重写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<integer> 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<integer> {
// 制定排序规则：降序
@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<integer> list = new linkedlist<>(); // 定义一个链表
// 升序放入list
for (int i = 0; i <= 10; ++i) {
list.add(i);
}
// 匿名内部类降序排序
collections.sort(list, new comparator<integer>() {
@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<integer> 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<t> 去指定排序的规则；
下面例子通过创建一个类的方式来实现接口；
代码如下：
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<student> 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<student> {
// 升序
@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<t> ，匿名内部类和lambda表达式也可以；但是还是一样，如果经常需要排序还是推荐定义一排序类，这样用起来更方便；
总结：
需要掌握的就是两点：
- sort基本方法使用
comparator<t>接口的使用（这里注意一下：不要和comparable<t>弄混）
sort还是挺实用的，希望这篇文章能够让你真正学会使用sort方法！
到此这篇关于java排序的那些事之sort方法的使用详解的文章就介绍到这了,更多相关java sort方法内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
