list集合对sort的使用方法

List集合的排序:

java提供了两种排序方式,分别是Collections.sort(List)和Collections.sort(List,Commparator),下面就这两种方法的使用做详细的说明:

方法一：Collections.sort(List)

这个方法有分两种情况：1、比较的是基础数据 2、比较的是引用数据

1、基础数据的比较呢，一般都是直接比较，因为基础数据都实现了CompareTo（）方法，例如

 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class CommparableClass {
    /**
     * 用Collections.sort(List)排序
     * list元素的类型是String类型
     * String 类型实现了Commparable接口,并重写了CompareTo方法
     * CompareTo方法中写的是比较原则
     */
    public void sortString(){
        ArrayList<String> strs=new ArrayList<String>();
        strs.add("123");
        strs.add("987");
        strs.add("abc");
        strs.add("ABC");
 
        System.out.println("---------------原始顺序,没有排序-------------");
        for(String str:strs){
            System.out.println(str);
        }
        System.out.println("----------------------------------------");
        Collections.sort(strs);
        System.out.println("--------------- 经过排序后输出   --------------");
        for(String str:strs){
            System.out.println(str);
        }
    }
}

1. 比较的是引用数据，引用数据就必须要我们实现Comparable接口,并重写CompareTo方法,在此方法中指定排序原则，例如

public class Student  implements Comparable<Student>{
    public String stuNo;
 
    public String name；
   
    public Integer age；
 
 
    @Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        //按照年龄排序
        int result1=this.getAge()-o.getAge();
        return result1;
    }
}

排序的情况如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CommparableClass {
/**
     * 用Collections.sort(List)排序
     * list元素的类型是Student类型
     * String 类型实现了Commparable接口,并重写了CompareTo方法
     * CompareTo方法中写的是比较原则
     */
    public void sortStudent(){
        ArrayList<Student> stus=new ArrayList<Student>();
        Student stu1=new Student("张三",20,"S001");
        Student stu2=new Student("李四",21,"S002");
        Student stu3=new Student("王五",22,"S003");
        Student stu4=new Student("张四",22,"S004");
 
        stus.add(0,stu1); 
        stus.add(1,stu2);
        stus.add(2,stu3);
        stus.add(3,stu4);
 
        System.out.println("---------------原始顺序,没有排序-------------");
        for(Student stu:stus){
            System.out.println("name="+stu.getName()+"age="+stu.getAge()+"stuNo="+stu.getStuNo());
        }
        System.out.println("----------------------------------------");
        Collections.sort(stus);
        System.out.println("--------------- 经过排序后输出   --------------");
        for(Student str:stus){
            System.out.println("name="+str.getName()+"age="+str.getAge()+"stuNo="+str.getStuNo());
        }
    }
    }

方法二：Collections.sort(List,Commparator)

-Collections.sort(List,Commparator);

sort方法的参数有两个,一个是要排序的List集合,另一个参数是Comparator接口,在比较器中,指定要排序的原则,

使用比较器方式就不用对要比较的集合的类类型实现Comparable接口

可以实现多个比较器,每个比较器就是一种排序原则

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
import www.lxk.day15.demo1.Student;
 
public class ComparatorClass {
    /**
     * 此方法用于获取一个List集合
     * @return
     */
    public List<Student> getStudents(){
        List<Student> stus=new ArrayList<Student>();
        Student stu1=new Student("张三",20,"S001");
        Student stu2=new Student("李四",21,"S002");
        Student stu3=new Student("王五",22,"S003");
        Student stu4=new Student("张四",22,"S004");
 
        stus.add(0,stu1);
        stus.add(1,stu2);
        stus.add(2,stu3);
        stus.add(3,stu4);
        return stus;
    }
    /**
     * 根据Comparator接口的子实现来指定排序的原则,策略模式
     * 按照姓名排序
     * @param stus
     */
    public void sortName(List<Student> stus){
        Collections.sort(stus, new Comparator<Student>(){
 
            @Override
            public int compare(Student stu1, Student stu2) {
                return stu1.getName().compareTo(stu2.getName());
            }
 
        });
        for(Student stu:stus){
            System.out.println("name="+stu.getName()+"age="+stu.getAge()+"stuNo="+stu.getStuNo());
        }
    }
    /**
     * 根据Comparator接口的子实现来指定排序的原则,策略模式
     * 按照年龄排序
     * @param stus
     */
    public void sortAge(List<Student> stus){
        Collections.sort(stus, new Comparator<Student>(){
 
            @Override
            public int compare(Student stu1, Student stu2) {
                return stu1.getAge()-stu2.getAge();
            }
 
        });
        for(Student stu:stus){
            System.out.println("name="+stu.getName()+"age="+stu.getAge()+"stuNo="+stu.getStuNo());
        }
    }
    /**
     * 根据Comparator接口的子实现来指定排序的原则,策略模式
     * 按照年龄排序
     * @param stus
     */
    public void sortstuNo(List<Student> stus){
        Collections.sort(stus, new Comparator<Student>(){
 
            @Override
            public int compare(Student stu1, Student stu2) {
                return stu1.getStuNo().compareTo(stu2.getStuNo());
            }
 
        });
        for(Student stu:stus){
            System.out.println("name="+stu.getName()+"age="+stu.getAge()+"stuNo="+stu.getStuNo());
        }
    }

    /**
     * 根据时间戳排序
     */
        //正序
    public void sortAge(List<Map<String,Object>> stus){
        stus.sort(new Comparator<Map<String, Object>>() {

            @Override
            public int compare(Map<String, Object> stu1, Map<String, Object> stu2) {
                long ctime = Long.parseLong(stu1.get("ctime").toString());
                long ctime1 = Long.parseLong(stu2.get("ctime").toString());

                return Long.compare(ctime,ctime1);
            }
        });
    }    

}

随机排序

Collections.shuffle(list); //进行随机排序