Java_ArrayList_排序
via:?http://www.importnew.com/17211.html
?
Java ArrayList的不同排序方法
排序字符串對象的 ArrayList
考慮一個 ArrayList 存儲著以字符串形式存在的國名（country name），為了對這個 ArrayList 進行排序，你需要調用 Collections.sort()方法，傳遞由國名構成的 ArrayList 對象。這種方法將按照自然順序（按字母升序）對元素（國名）進行排序。讓我們為此來寫一段代碼。
SortArrayListAscendingDescending.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | package guru.springframework.blog.sortarraylist.ascendingdescending; ?import java.util.ArrayList; ?import java.util.Collections; ?public class SortArrayListAscendingDescending { ?private ArrayList arrayList; ?public SortArrayListAscendingDescending(ArrayList arrayList) { ?this.arrayList = arrayList; ?} ?public ArrayList getArrayList() { ?return this.arrayList; ?} ?public ArrayList sortAscending() { ?Collections.sort(this.arrayList); ?return this.arrayList; ?} ?public ArrayList sortDescending() { ?Collections.sort(this.arrayList, Collections.reverseOrder()); ?return this.arrayList; ?} ?} |
在上面的類中，我們在構造器中初始化了一個 ArrayList 對象。在 sortAscending()方法中，我們調用了 Collections.sort()方法，并傳遞這個初始化的 ArrayList對象為參數，返回排序后的 ArrayList。在 sortDescending()方法中，我們調用重載的 Collections.sort()方法讓其按照降序對元素排序，這個版本的 Collections.sort()接收ArrayList對象作為第一個參數，一個由 Collections.reverseOrder()方法返回的 Comparator 對象作為第二個參數。我們將會在稍后講解 Comparator。為了測試排序功能，我們將寫一段測試代碼。
SortArrayListAscendingDescendingTest.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package guru.springframework.blog.sortarraylist.ascendingdescending; ?import org.junit.Test; ?import java.util.ArrayList; ?import static org.junit.Assert.*; ?public class SortArrayListAscendingDescendingTest { @Test ?public void testSortAscendingDescending() throws Exception { ?ArrayList countryList = new ArrayList<>(); ?countryList.add("France"); ?countryList.add("USA"); ?countryList.add("India"); ?countryList.add("Spain"); ?countryList.add("England"); ?SortArrayListAscendingDescending sortArrayList = new SortArrayListAscendingDescending(countryList); ?ArrayList unsortedArrayList = sortArrayList.getArrayList(); ?System.out.println("Unsorted ArrayList: " + unsortedArrayList); ?ArrayList sortedArrayListAscending = sortArrayList.sortAscending(); ?System.out.println("Sorted ArrayList in Ascending Order : " + sortedArrayListAscending); ?ArrayList sortedArrayListDescending = sortArrayList.sortDescending(); ?System.out.println("Sorted ArrayList in Descending Order: " + sortedArrayListDescending); ?} ?} |
在上面的測試代碼中，我們創建一個 ArrayList 對象，并添加了 5 個字符串對象代表 5 個國家的名字。然后我們調用 getArrayList()、sortAscending()和 sortDescending()方法，并打印這些方法返回的 ArrayList 對象。
輸出如下：
| ------------------------------------------------------- T E S T S -------------------------------------------------------?? Running guru.springframework.blog.sortarraylist.ascendingdescending.SortArrayListAscendingDescendingTest?? Unsorted ArrayList: [France, USA, India, Spain, England] Sorted ArrayList in Ascending Order : [England, France, India, Spain, USA] Sorted ArrayList in Descending Order: [USA, Spain, India, France, England]?? Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec - in guru.springframework.blog.sortarraylis |
到目前為止，所要排序的 ArrayList 元素都是非常簡單的，我們僅僅只是調用 Collections.sort()方法并傳遞了需要排序的 ArrayList 對象作為參數。但是更多的是你會遇到一些復雜的情景下對 ArrayList 進行排序。
Collections.sort() 方法對 ArrayList 的元素或者任何其他 List 的實現提供的可比較的元素進行排序，這意味著這些元素的類需要實現 java.lang 包中的 Comparable 接口。正如 String 類實現了 Comparable 接口，我們就可以對由國名構成的 ArrayList 排序。有些其他的標準 Java 類實現了 Comparable 接口，包括原始的包裝類，例如 Integer、Short、Double、Float、Boolean、BigInteger、BigDecimal、File 和 Date 類都實現了 Comparable 接口。
使用Comparable排序ArrayList
Comparable 是帶有單一?compareTo()方法的接口。一個實現了 Comparable 接口的類對象可以與其它同類型的對象進行比較，實現 Comparable 接口的類需要重寫 compareTo()方法，這個方法接收一個同類型的對象，并實現這個對象和傳遞給方法的另一個對象比較的邏輯。compareTo()方法返回Int類型的比較結果，分別代表下面的含義：
正值表示當前對象比傳遞給 comPareTO()的對象大
負值表示當前對象比傳遞給 comPareTO()的對象小
零表示兩個對象相等
讓我們來舉一個例子，JobCandidate 類的對象保存在 ArrayList 中并準備對其進行排序。JobCandidate 類有三個成員變量：字符串類型的姓名和性別、整型的年齡。我們想要對保存在 ArrayList 中的 JobCandidate 對象按照年齡進行排序。因此我們要讓 JobCandidate 類實現 Comparable 接口并重寫 compareTo()方法。
The code of the JobCandidate class is this.
JobCandidate類的代碼如下：
JobCandidate.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | package guru.springframework.blog.sortarraylist.comparable; ?public class JobCandidate implements Comparable { ?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; ?} ?@Override ?public int compareTo(JobCandidate candidate) { ?return (this.getAge() < candidate.getAge() ? -1 : ?(this.getAge() == candidate.getAge() ? 0 : 1)); ?} ?@Override ?public String toString() { ?return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age; ?} ?} |
在上面 JobCandidate 類被重寫的 compareTo()方法中，我們實現了基于年齡的比較邏輯。我見過很多程序員將(this.getAge() – candidate.getAge())作為返回的比較結果。盡管使用這種 return 語句看上去似乎很吸引人，并且也不會對我們的例子造成影響，我的建議是遠離這種語句。想象一下，比較整數值，其中有一個或者兩個都是負數的結果。這會導致一些錯誤，讓你的程序行為不定，而且更重要的是，這樣的錯誤是很細微的，尤其是在大型的企業應用中很難檢測出來。下面我們將寫一個輔助類，為委托方對包含了 JobCandidate 元素的 ArrayList 對象進行排序。
JobCandidateSorter.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | package guru.springframework.blog.sortarraylist.comparable; 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); ?return jobCandidate; ?} ?} |
在 JobCandidateSorter 類中，我們初始化了一個 ArrayList 對象，委托方將通過構造函數實例化 JobCandidateSorter 。然后我們編寫了 getSortedJobCandidateByAge()方法，在這個方法中，我們調用 Collections.sort()并傳遞已經初始化了的 ArrayList 為參數，最后返回排序后的 ArrayList。
接下來，我們寫一個測試類來測試一下我們的代碼。
JobCandidateSorterTest.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | package guru.springframework.blog.sortarraylist.comparable; ?import org.junit.Test; ?import java.lang.reflect.Array; ?import java.util.ArrayList; ?import static org.junit.Assert.*; ?public class JobCandidateSorterTest { @Test ?public void testGetSortedJobCandidateByAge() throws Exception { ?JobCandidate jobCandidate1 = new JobCandidate("Mark Smith", "Male", 26); ?JobCandidate jobCandidate2 = new JobCandidate("Sandy Hunt", "Female", 23); ?JobCandidate jobCandidate3 = new JobCandidate("Betty Clark", "Female", 20); ?JobCandidate jobCandidate4 = new JobCandidate("Andrew Styne", "Male", 24); ?ArrayList jobCandidateList = new ArrayList<>(); ?jobCandidateList.add(jobCandidate1); ?jobCandidateList.add(jobCandidate2); ?jobCandidateList.add(jobCandidate3); ?jobCandidateList.add(jobCandidate4); ?JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList); ?ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge(); ?System.out.println("-----Sorted JobCandidate by age: Ascending-----"); for (JobCandidate jobCandidate : sortedJobCandidate) { ?System.out.println(jobCandidate); ?} ?} ?} |
在上面的測試類中，我們創建了四個 JobCandidate 對象并把它們添加到 ArrayList，然后傳遞這個 ArrayList 到構造函數來實例化 JobCandidateSorter 類。最后，我們調用 JobCandidateSorter 類的 getSortedJobCandidateByAge()方法，并打印這個方法返回的排序后的 ArrayList。測試的輸出結果如下：
| ------------------------------------------------------- T E S T S ------------------------------------------------------- Running guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest -----Sorted JobCandidate by age: Ascending----- Name: Betty Clark, Gender: Female, age:20 Name: Sandy Hunt, Gender: Female, age:23 Name: Andrew Styne, Gender: Male, age:24 Name: Mark Smith, Gender: Male, age:26 Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.003 sec - in guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest |
使用 Comparable 對 ArrayList 排序是一種常用的方法。但是你必須知道有某些限制。你想要排序的對象的類必須實現 Comparable 并覆寫 compareTo()方法。這基本上意味著你將只能基于一個成員變量來比較對象(我們例子中的年齡字段)。如果要求你按照姓名和年齡來對 JobCandidate 對象進行排序怎么辦？ Comparable 就不是解決的方法了。另外，比較邏輯是需要進行比較的對象的類的一部分，它消除了比較邏輯可復用性的可能。Java 通過使用在 java.util 包下提供的Comparator接口解決了上述的比較需求。
使用 Comparator 排序 ArrayList
Comparator 接口與Comparable 接口相似也提供了一個單一的比較方法叫作 compare()。然而，與 Comparable的 compareTo()方法不同的是，這個 compare()接受兩個同類型的不同對象進行比較。
我們將用 Comparator 對我們之前使用過的相同?JobCandidate 類對象進行排序。我們將通過實現 Comparatoras 匿名內部類，允許對 JobCandidate 對象按照年齡和姓名進行排序。
下面是使用了 Comparator 的 JobCandidate 類代碼
JobCandidate.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 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; ?} ?} |
在上面的類中，從 29 行到 35 行，我們寫了一個匿名類并實現了 compare()方法，按照年齡的降序對 JobCandidate 對象進行排序。從37行到42行，我們又寫了一個匿名類并實現了 compare() 方法，按照姓名的升序對 JobCandidate進行排序?，F在我們寫一個類，為委托方對 ArrayList 的元素進行排序。
JobCandidateSorter.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | 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 對象。
Let’s write a test class to test our code.
讓我們寫一個測試類來測試我們的代碼。
JobCandidateSorterTest.java
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | package guru.springframework.blog.sortarraylist.comparator; ?import guru.springframework.blog.sortarraylist.comparator.JobCandidate; ?import guru.springframework.blog.sortarraylist.comparator.JobCandidateSorter; ?import org.junit.Before; ?import org.junit.Test; ?import java.util.ArrayList; ?import static org.junit.Assert.*; ?public class JobCandidateSorterTest { ?JobCandidateSorter jobCandidateSorter; ?@Before ?public void setUp() throws Exception { ?JobCandidate jobCandidate1 = new JobCandidate("Mark Smith", "Male", 26); ?JobCandidate jobCandidate2 = new JobCandidate("Sandy Hunt", "Female", 23); ?JobCandidate jobCandidate3 = new JobCandidate("Betty Clark", "Female", 20); ?JobCandidate jobCandidate4 = new JobCandidate("Andrew Styne", "Male", 24); ?ArrayList jobCandidateList = new ArrayList<>(); ?jobCandidateList.add(jobCandidate1); ?jobCandidateList.add(jobCandidate2); ?jobCandidateList.add(jobCandidate3); ?jobCandidateList.add(jobCandidate4); ?jobCandidateSorter = new JobCandidateSorter(jobCandidateList); ?} @Test ?public void testGetSortedJobCandidateByAge() throws Exception { ?System.out.println("-----Sorted JobCandidate by age: Descending-----"); ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge(); ?for (JobCandidate jobCandidate : sortedJobCandidate) { ?System.out.println(jobCandidate); ?} ?} @Test ?public void testGetSortedJobCandidateByName() throws Exception { ?System.out.println("-----Sorted JobCandidate by name: Ascending-----"); ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByName(); ?for (JobCandidate jobCandidate : sortedJobCandidate) { ?System.out.println(jobCandidate); ?} ?} ?} |
在測試類中我們向 ArrayList 中添加若干 JobCandidate 對象，并使用 Before 注釋在測試單元的 setup()方法中創建了一個 JobCandidateSorter 對象。如果你是一個 Junit 新手，可以參考我以前的文章包括 Junit 注釋（Junit 單元測試系列）。在 testGetSortedJobCandidateByAge()測試方法中我們調用了 getSortedJobCandidateByAge()方法，并打印了該方法返回的排序后的 ArrayList。在 testGetSortedJobCandidateByName()測試方法中我們調用了getSortedJobCandidateByName()方法并同樣打印該方法返回的 ArrayList。測試的輸出如下：
| ------------------------------------------------------- T E S T S ------------------------------------------------------- Running guru.springframework.blog.sortarraylist.comparator.JobCandidateSorterTest -----Sorted JobCandidate by name: Ascending----- Name: Andrew Styne, Gender: Male, age:24 ?Name: Betty Clark, Gender: Female, age:20 ?Name: Mark Smith, Gender: Male, age:26 ?Name: Sandy Hunt, Gender: Female, age:23 -----Sorted JobCandidate by age: Descending----- Name: Mark Smith, Gender: Male, age:26 ?Name: Andrew Styne, Gender: Male, age:24 ?Name: Sandy Hunt, Gender: Female, age:23 ?Name: Betty Clark, Gender: Female, age:20 ?Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.023 sec - in guru.springframework.blog.sortarraylist.comparator.JobCandidateSorterTest |
總結
在本文中我們看到了 ArrayList 排序的不同方法。一種是使用 Comparable 另一種是使用 Comparator。方法的選擇一直是造成程序員們困惑的原因之一。你最應該記住的就是一個 Comparable 對象可以說“我可以自己與另外一個對象比較”而一個 Comparator 對象可以說“我可以比較兩個不同的對象”。你不能說一個接口比另一個要好。選擇的接口取決于你需要實現的功能。
總結
以上是生活随笔為你收集整理的Java_ArrayList_排序的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： php中如何调用javascript,如
- 下一篇： JavaMail 访问Hotmail