ArrayList 是一種 List 實現，它的內部用一個動態陣列來儲存元素，因此 ArrayList 能夠在新增和移除元素的時候進行動態的擴充套件和縮減。

<一> 排序字串的ArrayList

ArrayList中儲存的是String型別的資料，在對這個 ArrayList 進行排序，你需要呼叫 Collections.sort()方法，看一段示例程式碼：

package com.sort.pack;

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

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類:

package com.sort.pack;

import java.util.ArrayList;

public class SortArrayListAscDecTest {
    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排序ArrayList

Comparable 是帶有單一 compareTo()方法的介面。一個實現了 Comparable 介面的類物件可以與其它同類型的物件進行比較，實現 Comparable 介面的類需要重寫 compareTo()方法，這個方法接收一個同類型的物件，並實現這個物件和傳遞給方法的另一個物件比較的邏輯。可以看一段示例程式碼：

package com.objectfile.writeread;
import java.io.Serializable;

public class Student implements Comparable<Student>,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;
    }

    public String getName() {
        return name;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public float getScore1() {
        return score1;
    }

    public void setScore1(float score1) {
        this.score1 = score1;
    }

    public float getScore2() {
        return score2;
    }

    public void setScore2(float score2) {
        this.score2 = score2;
    }

    public float getScore3() {
        return score3;
    }

    public void setScore3(float score3) {
        this.score3 = score3;
    }

    public float getTotlescore() {
        return totlescore;
    }
    public void setTotlescore(float totlescore){
        this.totlescore = totlescore;
    }

    @Override
    public String toString() {
        return "name: "+this.getName()+" number: "+this.getNumber()+" score1: "+this.getScore1()+" score2: "+this.getScore2()+" score3: "+this.getScore3()+" totlescore："+this.getTotlescore();
    }

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

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

test類：

public class testObjectFile {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();
        for (int i = 1; i < 6; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("請輸入第 "+i+" 個同學的姓名：");
            String name = sc.nextLine();
            System.out.println("請輸入你的學號：");
            String number = sc.nextLine();
            System.out.println("請輸入你的成績1：");
            float score1 = sc.nextFloat();
            System.out.println("請輸入你的成績2：");
            float score2 = sc.nextFloat();
            System.out.println("請輸入你的成績3：");
            float score3 = sc.nextFloat();
            Student stu = new Student(name,number,score1,score2,score3);
            list.add(stu);
        }

        saveStudent student = new saveStudent();
        list = student.sortStudent(list);  //先對所有的學生成績進行排名
｝

這種方式你將只能基於一個成員變數（例如上面的例子就是基於學生資訊的總分）來物件的比較。

<三>使用 Comparator 排序 ArrayList

Comparator 介面與Comparable 介面相似也提供了一個單一的比較方法叫作 compare()。然而，與 Comparable的 compareTo()方法不同的是，這個 compare()接受兩個同類型的不同物件進行比較。

package guru.springframework.blog.sortarraylist.comparator;
 import java.util.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 String getName() {
         return name;
     }
     public String getGender() {
         return gender;
     }
     public int getAge() {
         return 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()));
     }
 };
     @Override
     public String toString() {
         return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age;
     }
 }

一個匿名類並實現了 compare()方法，按照年齡的降序對 JobCandidate 物件進行排序。從37行到42行，我們又寫了一個匿名類並實現了 compare() 方法，按照姓名的升序對 JobCandidate進行排序。現在我們寫一個類，為委託方對 ArrayList 的元素進行排序。

package guru.springframework.blog.sortarraylist.comparator;
 import java.util.ArrayList;
 import java.util.Collections;
 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;
     }
 }

getSortedJobCandidateByAge()方法，在這個方法內部我們呼叫了 Collections.sort()的過載版本，這個版本傳遞要被排序的 ArrayList 物件和比較年齡的 Comparator 物件。在 getSortedJobCandidateByName()方法內部，我們又呼叫了 Collections.sort()的另一個過載版本，這個版本傳遞要被排序的 ArrayList 物件和比較姓名的 Comparator 物件。