对List集合中的对象进行按某个属性排序

 

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

/**
 * Created by IntelliJ IDEA
 * 这是一个神奇的Class
 *
 * @author zhz
 * @date 2019/9/25 10:37
 */
public class DemoTest {
    public static void main(String[] args) {


        List<String> list1 = new ArrayList<>();
        list1.add("3");
        list1.add("4");
        list1.add("1");
        list1.add("2");
        list1.add("f");
        list1.add("a");
        System.out.println("排序前--:"+list1.toString());
        Collections.sort(list1);
        System.out.println("排序前后--:"+list1.toString());


    }
}

打印结果如下：

 

 可以总结为，加单的String类型的排序，是排数字，再排字母，默认排序方式是升序。

下面言归正传，要是一个List中存的是某种对象，该对象有多种属性，那么如何进行升序或者降序排序呢？

这个时候我们就会进行一系列猛如虎的操作，结果有可能会遇到下面这种坑：

 

 这时候你可能会问那我们怎么搞啊：

下面首先我们先创建一个测试用类，这里重点说一哈，可以实现一个Comparable接口重写compareTo

/**
 * Created by IntelliJ IDEA
 * 这是一个神奇的Class
 *
 * @author zhz
 * @date 2019/9/25 10:49
 */
public class TestA implements Comparable<TestA> {
    private String name;

    private Integer age;

    public TestA(String name, Integer age) {
        super();
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "TestA [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(TestA o) {
        return this.age.compareTo(o.getAge());
    }
    
}

我们就可以进行下一步的检验结果的操作了

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

/**
 * Created by IntelliJ IDEA
 * 这是一个神奇的Class
 *
 * @author zhz
 * @date 2019/9/25 10:37
 */
public class DemoTest {
    
    public static void main(String[] args) {

        TestA testA1 = new TestA("老张", 3);
        TestA testA2 = new TestA("老李", 1);
        TestA testA3 = new TestA("老王", 2);
        List<TestA> list  = new ArrayList<>();
        list.add(testA1);
        list.add(testA2);
        list.add(testA3);
        System.out.println("排序前--:"+list.toString());
        Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //升序
                return o1.getAge().compareTo(o2.getAge());
            }
        });
        System.out.println("升序排序后--:"+list.toString());

        Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //降序
                return o2.getAge().compareTo(o1.getAge());
            }
        });
        System.out.println("降序排序后--:"+list.toString());

    }

}

输出的是啥：

　方法二就是在排序的时候，给sort()方法传入一个比较器。具体来说，就是传入一个实现比较器接口的匿名内部类，目的是告诉sort()方法，按照比较器来对list中的对象进行排序。如下所示：

 1 public class Test 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         ArrayList<Entity> list=new ArrayList<Entity>();
 6         list.add(new Entity("李四",24));
 7         list.add(new Entity("张三",13));
 8         list.add(new Entity("王五",25));
 9         System.out.println("排序前："+list);
10         Collections.sort(list,new Comparator<Entity>() {
11         @Override
12         public int compare(Entity o1, Entity o2) 
13         {
14             if(o1.getAge()>o2.getAge())
15             {
16                 return 1;
17             }
18             else if(o1.getAge()<o2.getAge())
19             {
20                 return -1;
21             }
22             else
23             {
24                 return 0;
25             }
26         }
27     });
28         System.out.println("排序后："+list);
29     }
30 }
31 class Entity
32 {
33     String name;
34     int age;
35     public Entity(String name, int age) {
36         super();
37         this.name = name;
38         this.age = age;
39     }
40     public String getName() {
41         return name;
42     }
43     public void setName(String name) {
44         this.name = name;
45     }
46     public int getAge() {
47         return age;
48     }
49     public void setAge(int age) {
50         this.age = age;
51     }
52     @Override
53     public String toString() {
54         return "Entity [name=" + name + ", age=" + age + "]";
55     }
56 }

　　当给sort()方法传入比较器的时候，sort()方法就会根据比较器来对list中的对象进行排序。

附：本文大部分参考网上资源,主要用于个人的笔记心得记录

 

下面是个人在处理业务中的使用：