对list中的对象进行排序

最新推荐文章于 2025-06-19 19:16:49 发布
原创 最新推荐文章于 2025-06-19 19:16:49 发布 · 1.9w 阅读 · 62 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入讲解Java中List的排序方法，包括对简单包装类型如String和Integer的排序，以及自定义对象类型的排序策略。探讨了实现Comparable接口和使用Comparator接口进行排序的细节，并提供了丰富的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

list的排序分为两大类：

一种是针对简单的包装类型进行排序，即list中存放的String或者Integer类型

另一种是针对自定义的对象类型进行排序，对象需要像包装类型一样去实现Comparable接口，然后重写CompareTo方法

一、针对简单包装类型进行排序

package com.hungteshun;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author hungteshun
 * @description: 对String类型、Integer类型进行排序
 * @date 2018/11/29 16:45
 */
public class EasySort {

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("张三");
        stringList.add("李四");
        stringList.add("王五");
        stringList.add("赵六");
        System.out.println("排序之前的顺序：" + stringList );
        Collections.sort(stringList);
        System.out.println("排序之后的顺序：" + stringList );
        /**
         * 注意这个reserve方法，是反转，而不是在无序的前提下直接倒序
         */
        Collections.reverse(stringList);
        System.out.println("反转之后的顺序：" + stringList );

        List<Integer> integerList = new ArrayList<>();
        integerList.add(2);
        integerList.add(1);
        integerList.add(9);
        integerList.add(5);
        integerList.add(12);
        integerList.add(20);
        System.out.println("排序之前的顺序" + integerList);
        Collections.sort(integerList);
        System.out.println("排序之后的顺序" + integerList);
        /**
         * 注意这个reserve方法，是反转，而不是在无序的前提下直接倒序
         */
        Collections.reverse(integerList);
        System.out.println("反转之后的顺序：" + integerList );
    }
}

输出结果如下：

排序之前的顺序：[张三, 李四, 王五, 赵六]
排序之后的顺序：[张三, 李四, 王五, 赵六]
反转之后的顺序：[赵六, 王五, 李四, 张三]
排序之前的顺序[2, 1, 9, 5, 12, 20]
排序之后的顺序[1, 2, 5, 9, 12, 20]
反转之后的顺序：[20, 12, 9, 5, 2, 1]

查看String类的源代码，String类也实现了Comparable<String>接口，查看其重写的compareTo()方法源码：

public int compareTo(String anotherString) {
	int len1 = value.length;
	int len2 = anotherString.value.length;
	int lim = Math.min(len1, len2);
	char v1[] = value;
	char v2[] = anotherString.value;

	int k = 0;
	while (k < lim) {
		char c1 = v1[k];
		char c2 = v2[k];
		if (c1 != c2) {
			return c1 - c2;
		}
		k++;
	}
	return len1 - len2;
}

二、针对list中的对象按照某个属性进行排序

2.1、对象实现Comparable接口

新建对象的时候需要实现Comparable接口，然后重写CompareTo方法。

创建一个Student对象：

package com.hungteshun.domain;

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/29 19:58
 */
public class Student implements Comparable<Student> {

    private Integer age;
    private Integer score;
    private String name;

    public Student() {
    }

    public Student(Integer age, Integer score, String name) {
        this.age = age;
        this.score = score;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Student o) {
        //先按照年龄排序
        Integer i = this.age.compareTo(o.getAge());
        if (i == 0) {
            //如果年龄相等，则按照分数排序
            i = this.score.compareTo(o.getScore());
            if (i == 0) {
                //如果分数相等，则按照姓名排序
                i = this.getName().compareTo(o.getName());
            }
        }
        /**
         * i等于0的时候表示相等；
         * i等于1的时候表示大于；
         * i等于-1的时候表示小于；
         */
        return i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", score=" + score +
                ", name='" + name + '\'' +
                '}';
    }
}

查看一下Integer类的compareTo()方法的实现源码：

public int compareTo(Integer anotherInteger) {
	return compare(this.value, anotherInteger.value);
}

继续查看compare()方法：

public static int compare(int x, int y) {
	return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

* i等于-1的时候表示小于；
* i等于0的时候表示相等；
* i等于1的时候表示大于；

对该对象的集合进行排序

package com.hungteshun;

import com.hungteshun.domain.Student;

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

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/29 19:56
 */
public class StudentSort {

    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student(23, 90, "张三"));
        studentList.add(new Student(22, 97, "李四"));
        studentList.add(new Student(23, 95, "王五"));
        studentList.add(new Student(24, 91, "赵六"));
        studentList.add(new Student(21, 98, "赵六"));
        studentList.add(new Student(21, 98, "赵五"));
        studentList.add(new Student(21, 98, "赵七"));
        System.out.println("排序之前的list：");
        studentList.stream().forEach(System.out::println);
        //Collections.sort(studentList);
        //System.out.println("排序之后的list：");
        //studentList.stream().forEach(System.out::println);
        //使用lambda表达式的sort是一样的效果
        System.out.println("使用lambda表达式排序之后的list：");
        studentList.stream().sorted().forEach(System.out::println);
    }

}

输出结果：

排序之前的list：
Student{age=23, score=90, name='张三'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=95, name='王五'}
Student{age=24, score=91, name='赵六'}
Student{age=21, score=98, name='赵六'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵七'}
使用lambda表达式排序之后的list：
Student{age=21, score=98, name='赵七'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵六'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=90, name='张三'}
Student{age=23, score=95, name='王五'}
Student{age=24, score=91, name='赵六'}

2.2、使用Comparator接口

Studen对象不用实现Comparable接口

package com.hungteshun.domain;

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/29 19:58
 */
public class Student {

    private Integer age;
    private Integer score;
    private String name;

    public Student() {
    }

    public Student(Integer age, Integer score, String name) {
        this.age = age;
        this.score = score;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", score=" + score +
                ", name='" + name + '\'' +
                '}';
    }
}

对该对象的集合进行排序

package com.hungteshun;

import com.hungteshun.domain.Student;

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

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/29 19:56
 */
public class StudentSort {

    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student(23, 90, "张三"));
        studentList.add(new Student(22, 97, "李四"));
        studentList.add(new Student(23, 95, "王五"));
        studentList.add(new Student(24, 91, "赵六"));
        studentList.add(new Student(21, 98, "赵六"));
        studentList.add(new Student(21, 98, "赵五"));
        studentList.add(new Student(21, 98, "赵七"));
        System.out.println("排序之前的list：");
        studentList.stream().forEach(System.out::println);
        Collections.sort(studentList, (o1, o2) -> {
            //先按照年龄排序
            Integer i = o1.getAge().compareTo(o2.getAge());
            if (i == 0) {
                //如果年龄相等，则按照分数排序
                i = o1.getScore().compareTo(o2.getScore());
                if (i == 0) {
                    //如果分数相等，则按照姓名排序
                    i = o1.getName().compareTo(o2.getName());
                }
            }
            return i;
        });
        System.out.println("排序之后的list：");
        studentList.stream().forEach(System.out::println);

        //只按照年龄排序方式一：
        Collections.sort(studentList, (e1, e2) -> e1.getAge().compareTo(e2.getAge()));
        //只按照年龄排序方式二：
        Collections.sort(studentList, Comparator.comparingInt(Student::getAge));
        System.out.println("只按照年龄排序之后的list：");
        studentList.stream().forEach(System.out::println);
        //只按照姓名排序方式一：
        Collections.sort(studentList, (e1, e2) -> e1.getName().compareTo(e2.getName()));
        //只按照姓名排序方式二：
        Collections.sort(studentList, Comparator.comparing(Student::getName));
        //只按照姓名排序方式三：
        Collections.sort(studentList, Comparator.comparing(e -> e.getName()));
        //只按照姓名排序方式四：
        studentList.sort((e1, e2) -> e1.getName().compareTo(e2.getName()));
        //只按照姓名排序方式五：
        studentList.sort(Comparator.comparing(Student::getName));
        //只按照姓名排序方式六：
        studentList.sort(Comparator.comparing(e -> e.getName()));
    }

}

输出结果：

排序之前的list：
Student{age=23, score=90, name='张三'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=95, name='王五'}
Student{age=24, score=91, name='赵六'}
Student{age=21, score=98, name='赵六'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵七'}
排序之后的list：
Student{age=21, score=98, name='赵七'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵六'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=90, name='张三'}
Student{age=23, score=95, name='王五'}
Student{age=24, score=91, name='赵六'}
只按照年龄排序之后的list：
Student{age=21, score=98, name='赵七'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵六'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=90, name='张三'}
Student{age=23, score=95, name='王五'}
Student{age=24, score=91, name='赵六'}
只按照姓名排序之后的list：
Student{age=23, score=90, name='张三'}
Student{age=22, score=97, name='李四'}
Student{age=23, score=95, name='王五'}
Student{age=21, score=98, name='赵七'}
Student{age=21, score=98, name='赵五'}
Student{age=21, score=98, name='赵六'}
Student{age=24, score=91, name='赵六'}

三、使用泛型对任何属性进行排序

定义一个UserInfo对象

package com.hungteshun.entity;

import java.text.SimpleDateFormat;
import java.util.Date;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/31 22:21
 */
@Getter
@Setter
@ToString
public class UserInfo {

    private Long userId;

    private String userName;

    private String password;

    private Date birthday;

    private Integer sex;

    private Integer age;

    public String getBirthdayStr(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(getBirthday());
    }
}

然后创建一个工具类

package com.hungteshun.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.apache.commons.lang.StringUtils;

/**
 * @author hungteshun
 * @description:
 * @date 2018/11/31 22:23
 */
public class SortListUtil<E> {

    public void Sort(List<E> list, final String method, final String order) {
        Collections.sort(list, new Comparator<E>() {
            @Override
            public int compare(E o1, E o2) {
                int ret = 0;
                try {
                    Method method1 = o1.getClass().getMethod(method, null);
                    Method method2 = o2.getClass().getMethod(method, null);
                    //倒序
                    if (StringUtils.isNotEmpty(order) && "desc".equalsIgnoreCase(order)) {
                        ret = method2.invoke(o2, null).toString().compareTo(method1.invoke(o1, null)
                                .toString());
                    }
                    else {
                        ret = method1.invoke(o1, null).toString()
                                .compareTo(method2.invoke(o2, null).toString());
                    }

                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                return ret;
            }
        });
    }
}

主方法中调用

package com.hungteshun;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.hungteshun.entity.UserInfo;
import com.hungteshun.util.SortListUtil;

/**
 * @author hungteshun
 * @description: 
 * @date 2018/11/31 22:15:30
 */
public class App {
    public static void main(String[] args) throws ParseException {
        List<UserInfo> userInfos = new ArrayList<>();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(2L);
        userInfo.setUserName("b");
        userInfo.setAge(10);
        userInfo.setBirthday(format.parse("2000-10-01"));
        userInfos.add(userInfo);

        userInfo = new UserInfo();
        userInfo.setUserId(1L);
        userInfo.setUserName("c");
        userInfo.setAge(30);
        userInfo.setBirthday(format.parse("1980-10-01"));
        userInfos.add(userInfo);

        userInfo = new UserInfo();
        userInfo.setUserId(3L);
        userInfo.setUserName("a");
        userInfo.setAge(20);
        userInfo.setBirthday(format.parse("1990-10-01"));
        userInfos.add(userInfo);

        SortListUtil<UserInfo> sortList = new SortListUtil<UserInfo>();

        System.out.println("==========原来的顺序==========");
        for (Iterator<UserInfo> iterator = userInfos.iterator(); iterator.hasNext(); ) {
            UserInfo userInfo1 = iterator.next();
            System.out.println(userInfo1);
        }

        System.out.println("==========按照userId排序==========");

        sortList.Sort(userInfos, "getUserId", null);
        for (Iterator<UserInfo> iterator = userInfos.iterator(); iterator.hasNext(); ) {
            UserInfo userInfo1 = iterator.next();
            System.out.println(userInfo1);
        }

        System.out.println("==========按照userName倒序排序==========");
        sortList.Sort(userInfos, "getUserName", "desc");
        for (Iterator<UserInfo> iterator = userInfos.iterator(); iterator.hasNext(); ) {
            UserInfo userInfo1 = iterator.next();
            System.out.println(userInfo1);
        }

        //这里按照日期排序是默认按照星期进行排序，因此我们需要对返回的日期格式进行手动格式化成yyyy-MM-dd类型
        System.out.println("==========按照birthday排序==========");
        sortList.Sort(userInfos, "getBirthday", null);
        for (Iterator<UserInfo> iterator = userInfos.iterator(); iterator.hasNext(); ) {
            UserInfo userInfo1 = iterator.next();
            System.out.println(userInfo1);
        }

        System.out.println("==========按照birthdayStr排序==========");
        sortList.Sort(userInfos, "getBirthdayStr", null);
        for (UserInfo userInfo1 : userInfos) {
            System.out.println(userInfo1);
        }

    }

}

 

List对象排序通用方法
10-09
List对象排序通用方法List对象排序通用方法List对象排序通用方法List对象排序通用方法
java中List对象排序通用方法
09-03
在Java编程中，List对象的排序是一个常见的需求。List接口提供了多种排序方法，其中最常用的是`Collections.sort()`。这个方法可以直接对实现了Comparable接口的List进行排序，它根据元素的自然顺序进行排序。但是，...
List对象进行排序
Lin_Miao_09的博客
02-13 3028
用空间换时间，Java在内存中进行对象集合排序。
【JAVA】list排序三种方法|Collections.sort|stream().sorted
最新发布
超级氯化钾的博客
06-19 247
实现Comparable接口，实现compareTo方法。
List集合中对象的排序
weixin_30731287的博客
04-21 354
使用到的是： Collections.sort(); 用法是： List<Book> list_book = new ArrayList<Book>(); Book book=new Book(1,"aa","a",2,1); Book book1=new Book(2,"bb","b",2,1); ...
对List中的对象排序
赵丙双的博客
08-26 339
package me.zhao; public class Student implements Comparable { private String name; private int age; public Student() { super(); } public Student(String name, int age) {...
list集合中的对象排序
EncodingKing的博客
03-10 1124
java中list集合中的对象排序
JAVA像SQL一样对List对象集合进行排序
08-18
在本文中，我们将详细介绍如何使用JAVA像SQL一样对List对象集合进行排序。我们将通过五个部分，分别介绍字符串List排序、整数类型List排序、对象字段对对象List排序、使用自定义Comparator排序和通过Comparator链对...
java实现List中对象排序的方法
09-03
总结来说，Java中实现List中对象排序的关键在于使用`Collections.sort()`方法配合自定义的`Comparator`。这使得我们可以根据对象的任意属性进行排序，不仅限于基本类型，也包括复杂的数据结构。这种方法具有很高的...
Java中对list元素进行排序的方法详解
09-03
本文将详细介绍如何在Java中对List元素进行排序，包括两种主要的方法：使用Comparable接口和Comparator接口。 1. **使用Comparable接口** 当你需要排序的类的实例（如`Student`类）直接实现了`Comparable`接口，...
List集合对象中按照不同属性大小排序的实例
08-31
在对List集合对象排序时，我们可以使用Collections.sort()方法，该方法可以根据不同的比较器对List集合对象进行排序。在本例中，我们使用匿名内部类实现Comparator接口，并重写compare方法，以便根据Person对象的...
List 对象属性排序
03-23
对List集合中 对象属性排序，不需要在每个实体类中重写Sort方法，实现了代码的重用。非常好用的Util类
给List中的对象排序
wawa129的专栏
10-31 183
package com.asia.home.cn.utils; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Collections; import java.util.Comparator; import java.util.Li...
list对象排序
weixin_33730836的博客
01-09 127
在数据库中查出来的列表list中，往往需要对不同的字段重新排序，一般的做法都是使用排序的字段，重新到数据库中查询。如果不到数据库查询，直接在第一次查出来的list中排序，无疑会提高系统的性能。 只要把第一次查出来的结果存放在session中，就可以对list重新排序了。一般对list排序可以使用 Collections.sort(list)，但如果list中包含是一个对象的话，这种方法还是行不通...
对List对象进行排序
gonglei181818的博客
07-24 389
对List对象进行排序 最近遇到需要对 List<Map<String, Object>>对象按照某一参数（String类型）进行排序的问题，网上教的大多是自己写排序方法或者用Collections.sort()方法按照某一int型参数进行排序，找了好久找到一种很方便快捷的排序方法。 //对systemDateList按systemType进行排序 syst...
爪哇(Java) 泛型集合排序
dingqi1722的博客
12-16 367
List对象排序通用方法 在数据库中查出来的列表中，往往需要对不同的字段重新排序，一般的做法都是使用排序的字段，重新到数据库中查询。如果不到数据库查询，直接在第一次查出来的list中排序，无疑会提高系统的性能。 只要把第一次查出来的结果存放在session中，就可以对list重新排序了。一般对list排序可以使用Collections.sort(list)，但如果list中包含...
List内 对象排序
改变ing
07-31 825
对象类 public class LogFile implements Comparable&lt;LogFile&gt; { } 集合里添加 对象  List&lt;LogFile&gt; logFiles = new ArrayList&lt;LogFile&gt;(); logFiles.add(logFile); 排序 Collections.sort(logFiles...
对List中的对象进行排序
嘟嘟的博客
05-22 700
最近有这样一个需求，List中保存的订单信息，先要对订单内的金额按照倒叙排序，金额大的放在最前面，然后按照日期倒序，最早的日期放在前面import com.google.common.collect.Lists; import com.google.common.collect.Ordering; import java.util.Collections; import java.util.Da...
java对List中对象属性进行排序
04-05
可以使用Comparator接口来对List中的对象的属性进行排序，具体步骤如下： 1. 定义一个实现了Comparator接口的类，重写compare方法，在方法中比较两个对象的属性值，返回一个int值，表示比较结果。 例如，对一个Person类的年龄进行排序，可以定义一个AgeComparator类： ``` public class AgeComparator implements Comparator<Person> { @Override public int compare(Person p1, Person p2) { return p1.getAge() - p2.getAge(); } } ``` 2. 在需要排序的代码中，调用Collections.sort方法，并将Comparator对象作为参数传入。 例如，对一个List<Person> list进行年龄排序，可以这样写： ``` Collections.sort(list, new AgeComparator()); ``` 完整示例代码： ``` import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Main { public static void main(String[] args) { List<Person> list = new ArrayList<>(); list.add(new Person("Tom", 20)); list.add(new Person("Jerry", 18)); list.add(new Person("Mike", 25)); list.add(new Person("Alice", 22)); Collections.sort(list, new AgeComparator()); for (Person p : list) { System.out.println(p.getName() + " " + p.getAge()); } } static class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } static class AgeComparator implements Comparator<Person> { @Override public int compare(Person p1, Person p2) { return p1.getAge() - p2.getAge(); } } } ``` 输出结果： ``` Jerry 18 Tom 20 Alice 22 Mike 25 ```
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值