Java 集合之给ArrayList排序

Java 集合之给ArrayList排序

ArrayList的排序可以借助Collections工具类的sort(List list)以及重载的sort(List list, Comparator<? super T> c)方法；其中要想使用sort(List lis)方法进行排序集合元素必须实现comparable接口中的compareTo方法；使用重载的sort(List list, Comparator<? super T> c)方法则要传入一个自定义构造器，可以使用匿名内部类的方式传入构造器；

• 1、如果是集合元素类型是8大基本类型的包装类（如Interge、Character等）或者是String类源码中这些类已经实现了Comparable接口，下面拿Integer类举例：

　　List<Integer> list0 = new ArrayList<>();
    Random random = new Random();
    for(int i = 0; i<10;i++){
        list0.add(random.nextInt(100));
    }

    list0.forEach(System.out::println);  
	//排序前  [27,71，6，65，53，84，75，0，66，70]

    //直接使用默认自然排序（即从小到大的顺序）
    Collections.sort(list0);
    System.out.println("自然排序后>>>>>>>>>");
    list0.forEach(System.out::println);
	//自然排序后 [0,6,27,53,65,66,70,71,75,84]
	
    //我们也可以使用同名重载方法传一个构造器进行临时改变排序规则（按从大到小排序）
	Collections.sort(list0, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 < o1 ? -1 : ((02 == 01) ? 0 : 1);
            }
     });
    list0.forEach(System.out::println); 
	// [84,75,71,70,66,65,53,27,6,0]

• 对于对象的排序
  　　　　　　　要想使用sort(List list)方法给集合排序集合元素必须实现comparable接口中的compareTo方法，所以要想实现对象自定义排序就要在compareTo方法里面做文章：

int compareTo(T t);
   该方法用于使当前对象与给定对象进行比较。
   当返回值>0时：当前对象比参数对象大
   当返回值<0时：当前对象比参数对象小
   当返回值=0时：当前对象等于参数对象

例子:
Person类:

@Data
public class Person implements  Comparable<Person>{

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

    private String name;

    private Integer age;



    @Override
    public int compareTo(Person o) {
   　　　// 按照年龄从小到大排序
        return this.getAge().compareTo(o.getAge());
    }
}

测试代码：

Person p1 = new Person("小王",22);
        Person p2 = new Person("小m",20);
        Person p3 = new Person("小t",30);
        Person p4 = new Person("小q",19);
        Person p5 = new Person("小u",20);
        Person p6 = new Person("小L",36);

        List<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        System.out.println("未排序之前>>>:");
        list.forEach(System.out::println);

        Collections.sort(list);
        
         System.out.println("自定义排序之后>>>:");
        list.forEach(System.out::println);

输出结果：

未排序之前>>>:
Person(name=小王, age=22)
Person(name=小m, age=20)
Person(name=小t, age=30)
Person(name=小q, age=19)
Person(name=小u, age=20)
Person(name=小L, age=36)
自定义排序之后>>>:
Person(name=小q, age=19)
Person(name=小m, age=20)
Person(name=小u, age=20)
Person(name=小王, age=22)
Person(name=小t, age=30)
Person(name=小L, age=36)

我们会发现使用sort(List list)方法侵入性比较高,所以不建议使用这个方法,我们可以使用它的重载的sort(List list, Comparator<? super T> c)方法,以匿名内部类的方式传入构造器来完成排序，上面的例子使用此方法演示如下：
　
　Person类:

@Data
public class Person {

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

    private String name;

    private Integer age;


}

测试代码：

 Person p1 = new Person("小王",22);
        Person p2 = new Person("小m",20);
        Person p3 = new Person("小t",30);
        Person p4 = new Person("小q",19);
        Person p5 = new Person("小u",20);
        Person p6 = new Person("小L",36);

        List<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        System.out.println("未排序之前>>>:");
        list.forEach(System.out::println);
　　　　　//自定义排序，这里我按招年龄从小到大排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge().compareTo(o2.getAge());
            }
        });
        System.out.println("自定义排序之后>>>:");
        list.forEach(System.out::println);

结果和上一种方法是一样的；

仅供参考！！！感谢阅读！！！欢迎指正！！！！