ArrayList实现自定义排序

ArrayList 是一种 List 实现，它的内部用一个动态数组来存储元素，因此 ArrayList 能够在添加和移除元素的时候进行动态的扩展和缩减。

字符串排序

ArrayList中存储的是String类型的数据，在对这个 ArrayList 进行排序，你需要调用 Collections.sort()方法

public class SortArrayListAscDes {
    private ArrayList arrayList;

    public SortArrayListAscDes(ArrayList arrayList) {
        this.arrayList = arrayList;
    }

    public ArrayList getArrayList() {
        return arrayList;
    }

    public ArrayList sortAscending(){                 //升序排序方法
         Collections.sort(this.arrayList);
        return this.arrayList;
    }

    public ArrayList sortDescending(){                //降序排序方法
        Collections.sort(this.arrayList,Collections.reverseOrder());
        return this.arrayList;
    }
}

/*--------------Test---------------------*/
public static void main(String[] args) {

        ArrayList stringArrayListist = new ArrayList<>();
        stringArrayListist.add("Itlay");
        stringArrayListist.add("China");
        stringArrayListist.add("America");
        stringArrayListist.add("Russian");

        SortArrayListAscDes sortArrayListAscDes = new SortArrayListAscDes(stringArrayListist);
        System.out.println("没有经过排序的数组: "+stringArrayListist);

        System.out.println("升序排序: "+ sortArrayListAscDes.sortAscending());
        System.out.println("降序排序: "+ sortArrayListAscDes.sortDescending());
    }

在 sortDescending()方法中，我们调用重载的 Collections.sort()方法让其按照降序对元素排序，这个版本的 Collections.sort()接收ArrayList对象作为第一个参数，一个由 Collections.reverseOrder()方法返回的 Comparator 对象作为第二个参数。reverseOrder 指的是逆序。

Collections.sort() 方法对 ArrayList 的元素或者任何其他 List 的实现提供的可比较的元素进行排序，这意味着这些元素的类需要实现 Java.lang 包中的 Comparable 接口。正如 String 类实现了Comparable接口，Integer、Short、Double、Float、Boolean、BigInteger、BigDecimal、File 和 Date 类也都实现了Comparable接口。

使用Comparable排序

Comparable 是带有单一 compareTo()方法的接口。一个实现了 Comparable 接口的类对象可以与其它同类型的对象进行比较，实现 Comparable 接口的类需要重写 compareTo()方法，这个方法接收一个同类型的对象，并实现这个对象和传递给方法的另一个对象比较的逻辑。

public class Student implements Comparable,Serializable{
    private String name;
    private String number;
    private float score1;
    private float score2;
    private float score3;
    private float totlescore;

    public Student() {
    }

    public Student(String name, String number, float score1, float score2, float score3) {
        this.name = name;
        this.number = number;
        this.score1 = score1;
        this.score2 = score2;
        this.score3 = score3;
        this.totlescore = score1 + score2 + score3;
    }

　　//按学生总分的降序排列
    @Override
    public int compareTo(Student o) {
        return (this.totlescore > o.totlescore ? -1 : (this.totlescore == o.totlescore ? 0 : 1));
    }
}

public class saveStudent {
    public List sortStudent(List sortlist){
        Collections.sort(sortlist);
        return sortlist;
    }
}

使用 Comparator 排序

public class JobCandidate {
     private String name;
     private String gender;
     private int age;
     public JobCandidate(String name, String gender, int age)        
     {
         this.name = name;
         this.gender = gender;
         this.age = age;
     }
     //匿名内部类
     public static Comparator ageComparator = new Comparator() {
     @Override
     public int compare(JobCandidate jc1, JobCandidate jc2) {
     return (jc2.getAge() < jc1.getAge() ? -1 :(jc2.getAge() == jc1.getAge() ? 0 : 1));
     }
 };
     public static Comparator nameComparator = new Comparator() {
     @Override
     public int compare(JobCandidate jc1, JobCandidate jc2) {
         return (int) (jc1.getName().compareTo(jc2.getName()));
     }
 };
}

public class JobCandidateSorter {
 ArrayList jobCandidate = new ArrayList<>();
     public JobCandidateSorter(ArrayList jobCandidate) {
         this.jobCandidate = jobCandidate;
     }
     public ArrayList getSortedJobCandidateByAge() {
         Collections.sort(jobCandidate, JobCandidate.ageComparator);
         return jobCandidate;
     }
     public ArrayList getSortedJobCandidateByName() {
         Collections.sort(jobCandidate, JobCandidate.nameComparator);
     return jobCandidate;
     }
 }

对compareTo和compare返回值的理解

A.compareTo(B);就是返回正数的话，当前对象（调用compareTo方法的对象A）要排在比较对象（compareTo传参对象B）后面；返回负数的话，放在前面；等于0两数相等。

compare(A，B);就是返回正数的话，当前对象A要排在比较对象B后面；返回负数的话，放在前面；等于0两数相等。