Java对象集合List排序的5种⽅式⽬标明确
排序对象类
public class Student{
private String name;
private Integer age;
public Student(String name, Integer age) {
this.name = name;
this.age = age;
}
public Student() {
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
⽅式⼀：排序对象类实现Comparable接⼝的compareTo⽅法
Student类
public class Student implements Comparable<Student>{
private String name;
private Integer age;
public Student(String name, Integer age) {
this.name = name;
this.age = age;
}
public Student() {
java集合排序怎么实现
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
/**
* 需要实现的⽅法，实现升序排序，降序请反写
* this表⽰当前的对象
* @param o ⽐较时传⼊的对象
* @param o ⽐较时传⼊的对象
* @return
*/
@Override
public int compareTo(Student o) {
return this.age-o.age;
}
}
Main
public class Test {
public static void main(String[] args) {
//数据准备
List<Student> list = new ArrayList<>();
list.add(new Student("⼩明",1));
list.add(new Student("⼩红",4));
list.add(new Student("⼩刚",3));
list.add(new Student("⼩鸡",5));
list.add(new Student("⼩狗",2));
//使⽤Collections集合⼯具类进⾏排序
Collections.sort(list);
for (Student student : list) {
System.out.println(student);
}
}
}
compareTo⽅法实际上是⼀个⽐较⼤⼩的⽅法，只要是排序，我们必须⽤到⽐较，若果是简单的整数数组排序，我们只需要⽤ > 、 < 等进⾏⽐较，但是对于对象来说，Collections集合⼯具类在进⾏排序时，每次⽐较，都是调⽤的我们实现的compareTo⽅法，this表⽰当前对象，o表⽰要进⾏⽐较的传⼊对象，返回是⼀个int类型的整数
返回值>0：表⽰当前对象⽐传⼊对象⼤（年龄）
返回值=0：表⽰当前对象和传⼊对象⼀样⼤（年龄）
返回值<0：表⽰当前对象⽐传⼊对象⼩（年龄）
排序结果：
Student{name='⼩明', age=1}
Student{name='⼩狗', age=2}
Student{name='⼩刚', age=3}
Student{name='⼩红', age=4}
Student{name='⼩鸡', age=5}
Process finished with exit code
⽅式⼆：使⽤Comparator接⼝⾃定义⾏为
使⽤⽅式⼀我们必须在Student类上⾯进⾏修改，这显然不是最好的办法，如果我们不想按年龄排序，想要按照姓名排序，或者我们有⼀个⽅法需要按照年龄，另⼀个⽅法需要按照姓名，那么重写compareTo⽅法显然就没法完成我们的⽬标了，Collections的重载sort⽅法可以允许我们在排序对象外部⾃定义⼀个⽐较器（Comparator接⼝的实现类），因为我们仅需要实现compare（）⽅法（实际上Comparator接⼝是⼀个函数式接⼝，⽆伤⼤雅最后解释，想了解的看最后），没必要在定义⼀个类，我们直接使⽤匿名内部类的⽅式。
此时的Student类我们不⽤进⾏任何改写，和最原始的⼀样即可
Main
public class Test {
public static void main(String[] args) {
//数据准备
List<Student> list = new ArrayList<>();
list.add(new Student("⼩明",1));
list.add(new Student("⼩红",4));
list.add(new Student("⼩刚",3));
list.add(new Student("⼩鸡",5));
list.add(new Student("⼩狗",2));
//使⽤Collections集合⼯具类进⾏排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//升序排序，降序反写
Age()-o2.getAge();
}
});
for (Student student : list) {
System.out.println(student);
}
}
}
排序结果：
Student{name='⼩明', age=1}
Student{name='⼩明', age=1}
Student{name='⼩狗', age=2}
Student{name='⼩刚', age=3}
Student{name='⼩红', age=4}
Student{name='⼩鸡', age=5}
Process finished with exit code 0
我们也可以使⽤List的sort⽅法（这是List接⼝的⼀个默认⽅法）源码如下：@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = Array();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
<();
i.set((E) e);
}
}
我们也需要传⼊⼀个Comparator，此处使⽤匿名类的形式，代码如下：public static void main(String[] args) {
//数据准备
List<Student> list = new ArrayList<>();
list.add(new Student("⼩明",1));
list.add(new Student("⼩红",4));
list.add(new Student("⼩刚",3));
list.add(new Student("⼩鸡",5));
list.add(new Student("⼩狗",2));
list.sort(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
Age()-o2.getAge();
}
});
for (Student student : list) {
System.out.println(student);
}
}
⽅式三：Lambda表达式
⽅式⼆相⽐，只改变了⼀⾏代码
将
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//升序排序，降序反写
Age()-o2.getAge();
}
});
变为
Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
或者使⽤list的sort⽅法：
将
list.sort(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
Age()-o2.getAge();
}
});
变为：
list.sort((o1, o2) -> o1.getAge()-o2.getAge());
⽅式四：使⽤⽅法引⽤进⼀步简化
上⽂⽅式三
Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
可以变为：
Collections.sort(list, ComparatorparingInt(Student::getAge));
使⽤List的sort⽅法时：
list.sort((o1, o2) -> o1.getAge()-o2.getAge());
可以改为
list.sort(ComparatorparingInt(Student::getAge));
list.sort(ComparatorparingInt(Student::getAge));
⽅式五：使⽤Stream流
List<Student> students = list.stream().
sorted((ComparatorparingInt(Student::getAge)))
.List());
注：返回⼀个有序的List集合
关于Comparator接⼝
上⽂说Comparator接⼝是⼀个函数式接⼝，那么什么是函数式接⼝呢？
函数式接⼝就是只定义⼀个抽象⽅法的接⼝。
JDK1.8开始⽀持默认⽅法，即便这个接⼝拥有很多默认⽅法，只要接⼝只有⼀个抽象⽅法，那么这个接⼝就是函数式接⼝。
函数式接⼝常常⽤@FunctionInterface来标注，不是必须的，带有@FunctionInterface注解的接⼝如果不满⾜函数式接⼝（有多个抽象⽅法），编译器会返回提⽰信息，⾃⼰创建函数式接⼝时推荐使⽤。
end

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。