自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

Java ArrayList 的不同排序方法

開發(fā) 后端
在這篇文章中，將討論ArrayList 中一種極其重要的操作，你很有可能需要在企業(yè)應(yīng)用開發(fā)中實現(xiàn)它。它就是ArrayList元素的排序。

由于其功能性和靈活性，ArrayList是 Java 集合框架中使用最為普遍的集合類之一。ArrayList 是一種 List 實現(xiàn)，它的內(nèi)部用一個動態(tài)數(shù)組來存儲元素，因此 ArrayList 能夠在添加和移除元素的時候進行動態(tài)的擴展和縮減。你可能已經(jīng)使用過 ArrayList，因此我將略過基礎(chǔ)部分。如果你對 ArrayList 還不熟悉，你可以參考它的 API 文檔，可以很容易理解在 ArrayList 上執(zhí)行基本的操作。

在這篇文章中，我將討論ArrayList中一種極其重要的操作，你很有可能需要在企業(yè)應(yīng)用開發(fā)中實現(xiàn)它。它就是ArrayList元素的排序。

排序字符串對象的 ArrayList

考慮一個 ArrayList 存儲著以字符串形式存在的國名（country name），為了對這個 ArrayList 進行排序，你需要調(diào)用 Collections.sort()方法，傳遞由國名構(gòu)成的 ArrayList 對象。這種方法將按照自然順序（按字母升序）對元素（國名）進行排序。讓我們?yōu)榇藖韺懸欢未a。

SortArrayListAscendingDescending.java

  1. package guru.springframework.blog.sortarraylist.ascendingdescending; 
  2. import java.util.ArrayList; 
  3. import java.util.Collections; 
  4. public class SortArrayListAscendingDescending { 
  5. private ArrayList arrayList; 
  6. public SortArrayListAscendingDescending(ArrayList arrayList) { 
  7. this.arrayList = arrayList; 
  8. } 
  9. public ArrayList getArrayList() { 
  10. return this.arrayList; 
  11. } 
  12. public ArrayList sortAscending() { 
  13. Collections.sort(this.arrayList); 
  14. return this.arrayList; 
  15. } 
  16. public ArrayList sortDescending() { 
  17. Collections.sort(this.arrayList, Collections.reverseOrder()); 
  18. return this.arrayList; 
  19. } 
  20. } 

在上面的類中，我們在構(gòu)造器中初始化了一個 ArrayList 對象。在 sortAscending()方法中，我們調(diào)用了 Collections.sort()方法，并傳遞這個初始化的 ArrayList對象為參數(shù)，返回排序后的 ArrayList。在 sortDescending()方法中，我們調(diào)用重載的 Collections.sort()方法讓其按照降序?qū)υ嘏判?，這個版本的 Collections.sort()接收ArrayList對象作為***個參數(shù)，一個由 Collections.reverseOrder()方法返回的 Comparator 對象作為第二個參數(shù)。我們將會在稍后講解 Comparator。為了測試排序功能，我們將寫一段測試代碼。

SortArrayListAscendingDescendingTest.java

  1. package guru.springframework.blog.sortarraylist.ascendingdescending; 
  2. import org.junit.Test; 
  3. import java.util.ArrayList; 
  4. import static org.junit.Assert.*; 
  5. public class SortArrayListAscendingDescendingTest { 
  6. <a href="http://www.jobbole.com/members/madao">@Test</a> 
  7. public void testSortAscendingDescending() throws Exception { 
  8. ArrayList countryList = new ArrayList&lt;&gt;(); 
  9. countryList.add("France"); 
  10. countryList.add("USA"); 
  11. countryList.add("India"); 
  12. countryList.add("Spain"); 
  13. countryList.add("England"); 
  14. SortArrayListAscendingDescending sortArrayList = new SortArrayListAscendingDescending(countryList); 
  15. ArrayList unsortedArrayList = sortArrayList.getArrayList(); 
  16. System.out.println("Unsorted ArrayList: " + unsortedArrayList); 
  17. ArrayList sortedArrayListAscending = sortArrayList.sortAscending(); 
  18. System.out.println("Sorted ArrayList in Ascending Order : " + sortedArrayListAscending); 
  19. ArrayList sortedArrayListDescending = sortArrayList.sortDescending(); 
  20. System.out.println("Sorted ArrayList in Descending Order: " + sortedArrayListDescending); 
  21. } 
  22. } 

在上面的測試代碼中，我們創(chuàng)建一個 ArrayList 對象，并添加了 5 個字符串對象代表 5 個國家的名字。然后我們調(diào)用 getArrayList()、sortAscending()和 sortDescending()方法，并打印這些方法返回的 ArrayList 對象。

輸出如下：

  1. ------------------------------------------------------- 
  2. T E S T S 
  3. -------------------------------------------------------   
  4. Running guru.springframework.blog.sortarraylist.ascendingdescending.SortArrayListAscendingDescendingTest   
  5. Unsorted ArrayList: [France, USA, India, Spain, England] 
  6. Sorted ArrayList in Ascending Order : [England, France, India, Spain, USA] 
  7. Sorted ArrayList in Descending Order: [USA, Spain, India, France, England]   
  8. Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec - in guru.springframework.blog.sortarraylis 

到目前為止，所要排序的 ArrayList 元素都是非常簡單的，我們僅僅只是調(diào)用 Collections.sort()方法并傳遞了需要排序的 ArrayList 對象作為參數(shù)。但是更多的是你會遇到一些復(fù)雜的情景下對 ArrayList 進行排序。

Collections.sort() 方法對 ArrayList 的元素或者任何其他 List 的實現(xiàn)提供的可比較的元素進行排序，這意味著這些元素的類需要實現(xiàn) java.lang 包中的 Comparable 接口。正如 String 類實現(xiàn)了 Comparable 接口，我們就可以對由國名構(gòu)成的 ArrayList 排序。有些其他的標準 Java 類實現(xiàn)了 Comparable 接口，包括原始的包裝類，例如 Integer、Short、Double、Float、Boolean、BigInteger、BigDecimal、File 和 Date 類都實現(xiàn)了 Comparable 接口。

使用Comparable排序ArrayList

Comparable 是帶有單一 compareTo()方法的接口。一個實現(xiàn)了 Comparable 接口的類對象可以與其它同類型的對象進行比較，實現(xiàn) Comparable 接口的類需要重寫 compareTo()方法，這個方法接收一個同類型的對象，并實現(xiàn)這個對象和傳遞給方法的另一個對象比較的邏輯。compareTo()方法返回Int 類型的比較結(jié)果，分別代表下面的含義：

  • 正值表示當前對象比傳遞給 comPareTO()的對象大

  • 負值表示當前對象比傳遞給 comPareTO()的對象小

  • 零表示兩個對象相等

讓我們來舉一個例子，JobCandidate 類的對象保存在 ArrayList 中并準備對其進行排序。JobCandidate 類有三個成員變量：字符串類型的姓名和性別、整型的年齡。我們想要對保存在 ArrayList 中的 JobCandidate 對象按照年齡進行排序。因此我們要讓 JobCandidate 類實現(xiàn) Comparable 接口并重寫 compareTo()方法。

JobCandidate類的代碼如下：

JobCandidate.java

  1. package guru.springframework.blog.sortarraylist.comparable; 
  2. public class JobCandidate implements Comparable { 
  3. private String name; 
  4. private String gender; 
  5. private int age; 
  6. public JobCandidate(String name, String gender, int age) { 
  7. this.name = name; 
  8. this.gender = gender; 
  9. this.age = age; 
  10. } 
  11. public String getName() { 
  12. return name; 
  13. } 
  14. public String getGender() { 
  15. return gender; 
  16. } 
  17. public int getAge() { 
  18. return age; 
  19. } 
  20. @Override 
  21. public int compareTo(JobCandidate candidate) { 
  22. return (this.getAge() < candidate.getAge() ? -1 : 
  23. (this.getAge() == candidate.getAge() ? 0 : 1)); 
  24. } 
  25. @Override 
  26. public String toString() { 
  27. return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age; 
  28. } 
  29. } 

在上面 JobCandidate 類被重寫的 compareTo()方法中，我們實現(xiàn)了基于年齡的比較邏輯。我見過很多程序員將(this.getAge() – candidate.getAge())作為返回的比較結(jié)果。盡管使用這種 return 語句看上去似乎很吸引人，并且也不會對我們的例子造成影響，我的建議是遠離這種語句。想象一下，比較整數(shù)值，其中有一個或者兩個都是負數(shù)的結(jié)果。這會導致 一些錯誤，讓你的程序行為不定，而且更重要的是，這樣的錯誤是很細微的，尤其是在大型的企業(yè)應(yīng)用中很難檢測出來。下面我們將寫一個輔助類，為委托方對包含了 JobCandidate 元素的 ArrayList 對象進行排序。

JobCandidateSorter.java

  1. package guru.springframework.blog.sortarraylist.comparable; 
  2. import java.util.ArrayList; 
  3. import java.util.Collections; 
  4. public class JobCandidateSorter { 
  5. ArrayList jobCandidate = new ArrayList<>(); 
  6. public JobCandidateSorter(ArrayList jobCandidate) { 
  7. this.jobCandidate = jobCandidate; 
  8. } 
  9. public ArrayList getSortedJobCandidateByAge() { 
  10. Collections.sort(jobCandidate); 
  11. return jobCandidate; 
  12. } 
  13. } 

在 JobCandidateSorter 類中，我們初始化了一個 ArrayList 對象，委托方將通過構(gòu)造函數(shù)實例化 JobCandidateSorter 。然后我們編寫了 getSortedJobCandidateByAge()方法，在這個方法中，我們調(diào)用 Collections.sort()并傳遞已經(jīng)初始化了的 ArrayList 為參數(shù)，***返回排序后的 ArrayList。

接下來，我們寫一個測試類來測試一下我們的代碼。

JobCandidateSorterTest.java

  1. package guru.springframework.blog.sortarraylist.comparable; 
  2. import org.junit.Test; 
  3. import java.lang.reflect.Array; 
  4. import java.util.ArrayList; 
  5. import static org.junit.Assert.*; 
  6. public class JobCandidateSorterTest { 
  7. <a href="http://www.jobbole.com/members/madao">@Test</a> 
  8. public void testGetSortedJobCandidateByAge() throws Exception { 
  9. JobCandidate jobCandidate1 = new JobCandidate("Mark Smith", "Male", 26); 
  10. JobCandidate jobCandidate2 = new JobCandidate("Sandy Hunt", "Female", 23); 
  11. JobCandidate jobCandidate3 = new JobCandidate("Betty Clark", "Female", 20); 
  12. JobCandidate jobCandidate4 = new JobCandidate("Andrew Styne", "Male", 24); 
  13. ArrayList jobCandidateList = new ArrayList&lt;&gt;(); 
  14. jobCandidateList.add(jobCandidate1); 
  15. jobCandidateList.add(jobCandidate2); 
  16. jobCandidateList.add(jobCandidate3); 
  17. jobCandidateList.add(jobCandidate4); 
  18. JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList); 
  19. ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge(); 
  20. System.out.println("-----Sorted JobCandidate by age: Ascending-----"); 
  21. for (JobCandidate jobCandidate : sortedJobCandidate) { 
  22. System.out.println(jobCandidate); 
  23. } 
  24. } 
  25. } 

在上面的測試類中，我們創(chuàng)建了四個 JobCandidate 對象并把它們添加到 ArrayList，然后傳遞這個 ArrayList 到構(gòu)造函數(shù)來實例化 JobCandidateSorter 類。***，我們調(diào)用 JobCandidateSorter 類的 getSortedJobCandidateByAge()方法，并打印這個方法返回的排序后的 ArrayList。測試的輸出結(jié)果如下：

  1. ------------------------------------------------------- 
  2. T E S T S 
  3. ------------------------------------------------------- 
  4. Running guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest 
  5. -----Sorted JobCandidate by age: Ascending----- 
  6. Name: Betty Clark, Gender: Female, age:20 
  7. Name: Sandy Hunt, Gender: Female, age:23 
  8. Name: Andrew Styne, Gender: Male, age:24 
  9. Name: Mark Smith, Gender: Male, age:26 
  10. Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.003 sec 
  11. - in guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest 

使用 Comparable 對 ArrayList 排序是一種常用的方法。但是你必須知道有某些限制。你想要排序的對象的類必須實現(xiàn) Comparable 并覆寫 compareTo()方法。這基本上意味著你將只能基于一個成員變量來比較對象(我們例子中的年齡字段)。如果要求你按照姓名和年齡來對 JobCandidate 對象進行排序怎么辦？ Comparable 就不是解決的方法了。另外，比較邏輯是需要進行比較的對象的類的一部分，它消除了比較邏輯可復(fù)用性的可能。Java 通過使用在 java.util 包下提供的Comparator接口解決了上述的比較需求。

使用 Comparator 排序 ArrayList

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

我們將用 Comparator 對我們之前使用過的相同 JobCandidate 類對象進行排序。我們將通過實現(xiàn) Comparatoras 匿名內(nèi)部類，允許對 JobCandidate 對象按照年齡和姓名進行排序。

下面是使用了 Comparator 的 JobCandidate 類代碼

JobCandidate.java

  1. package guru.springframework.blog.sortarraylist.comparator; 
  2. import java.util.Comparator; 
  3. public class JobCandidate { 
  4. private String name; 
  5. private String gender; 
  6. private int age; 
  7. public JobCandidate(String name, String gender, int age) { 
  8. this.name = name; 
  9. this.gender = gender; 
  10. this.age = age; 
  11. } 
  12. public String getName() { 
  13. return name; 
  14. } 
  15. public String getGender() { 
  16. return gender; 
  17. } 
  18. public int getAge() { 
  19. return age; 
  20. } 
  21. public static Comparator ageComparator = new Comparator() { 
  22. @Override 
  23. public int compare(JobCandidate jc1, JobCandidate jc2) { 
  24. return (jc2.getAge() < jc1.getAge() ? -1 : 
  25. (jc2.getAge() == jc1.getAge() ? 0 : 1)); 
  26. } 
  27. }; 
  28. public static Comparator nameComparator = new Comparator() { 
  29. @Override 
  30. public int compare(JobCandidate jc1, JobCandidate jc2) { 
  31. return (int) (jc1.getName().compareTo(jc2.getName())); 
  32. } 
  33. }; 
  34. @Override 
  35. public String toString() { 
  36. return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age; 
  37. } 
  38. } 

在上面的類中，從 29 行到 35 行，我們寫了一個匿名類并實現(xiàn)了 compare()方法，按照年齡的降序?qū)?JobCandidate 對象進行排序。從37行到42行，我們又寫了一個匿名類并實現(xiàn)了 compare() 方法，按照姓名的升序?qū)? JobCandidate進行排序。現(xiàn)在我們寫一個類，為委托方對 ArrayList 的元素進行排序。

JobCandidateSorter.java

  1. package guru.springframework.blog.sortarraylist.comparator; 
  2. import java.util.ArrayList; 
  3. import java.util.Collections; 
  4. public class JobCandidateSorter { 
  5. ArrayList jobCandidate = new ArrayList<>(); 
  6. public JobCandidateSorter(ArrayList jobCandidate) { 
  7. this.jobCandidate = jobCandidate; 
  8. } 
  9. public ArrayList getSortedJobCandidateByAge() { 
  10. Collections.sort(jobCandidate, JobCandidate.ageComparator); 
  11. return jobCandidate; 
  12. } 
  13. public ArrayList getSortedJobCandidateByName() { 
  14. Collections.sort(jobCandidate, JobCandidate.nameComparator); 
  15. return jobCandidate; 
  16. } 
  17. } 

在上面的類中，我們寫了 getSortedJobCandidateByAge()方法，在這個方法內(nèi)部我們調(diào)用了 Collections.sort()的重載版本，這個版本傳遞要被排序的 ArrayList 對象和比較年齡的 Comparator 對象。在 getSortedJobCandidateByName()方法內(nèi)部，我們又調(diào)用了 Collections.sort()的另一個重載版本，這個版本傳遞要被排序的 ArrayList 對象和比較姓名的 Comparator 對象。

讓我們寫一個測試類來測試我們的代碼。

JobCandidateSorterTest.java

  1. package guru.springframework.blog.sortarraylist.comparator; 
  2. import guru.springframework.blog.sortarraylist.comparator.JobCandidate; 
  3. import guru.springframework.blog.sortarraylist.comparator.JobCandidateSorter; 
  4. import org.junit.Before; 
  5. import org.junit.Test; 
  6. import java.util.ArrayList; 
  7. import static org.junit.Assert.*; 
  8. public class JobCandidateSorterTest { 
  9. JobCandidateSorter jobCandidateSorter; 
  10. @Before 
  11. public void setUp() throws Exception { 
  12. JobCandidate jobCandidate1 = new JobCandidate("Mark Smith", "Male", 26); 
  13. JobCandidate jobCandidate2 = new JobCandidate("Sandy Hunt", "Female", 23); 
  14. JobCandidate jobCandidate3 = new JobCandidate("Betty Clark", "Female", 20); 
  15. JobCandidate jobCandidate4 = new JobCandidate("Andrew Styne", "Male", 24); 
  16. ArrayList jobCandidateList = new ArrayList&lt;&gt;(); 
  17. jobCandidateList.add(jobCandidate1); 
  18. jobCandidateList.add(jobCandidate2); 
  19. jobCandidateList.add(jobCandidate3); 
  20. jobCandidateList.add(jobCandidate4); 
  21. jobCandidateSorter = new JobCandidateSorter(jobCandidateList); 
  22. } 
  23. <a href="http://www.jobbole.com/members/madao">@Test</a> 
  24. public void testGetSortedJobCandidateByAge() throws Exception { 
  25. System.out.println("-----Sorted JobCandidate by age: Descending-----"); 
  26. ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge(); 
  27. for (JobCandidate jobCandidate : sortedJobCandidate) { 
  28. System.out.println(jobCandidate); 
  29. } 
  30. } 
  31. <a href="http://www.jobbole.com/members/madao">@Test</a> 
  32. public void testGetSortedJobCandidateByName() throws Exception { 
  33. System.out.println("-----Sorted JobCandidate by name: Ascending-----"); 
  34. ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByName(); 
  35. for (JobCandidate jobCandidate : sortedJobCandidate) { 
  36. System.out.println(jobCandidate); 
  37. } 
  38. } 
  39. } 

在測試類中我們向 ArrayList 中添加若干 JobCandidate 對象，并使用 Before 注釋在測試單元的 setup()方法中創(chuàng)建了一個 JobCandidateSorter 對象。如果你是一個 Junit 新手，可以參考我以前的文章包括 Junit 注釋（Junit 單元測試系列）。 在 testGetSortedJobCandidateByAge()測試方法中我們調(diào)用了 getSortedJobCandidateByAge()方法，并打印了該方法返回的排序后的 ArrayList。在 testGetSortedJobCandidateByName()測試方法中我們調(diào)用了getSortedJobCandidateByName() 方法并同樣打印該方法返回的 ArrayList。測試的輸出如下：

  1. ------------------------------------------------------- 
  2. T E S T S 
  3. ------------------------------------------------------- 
  4. Running guru.springframework.blog.sortarraylist.comparator.JobCandidateSorterTest 
  5. -----Sorted JobCandidate by name: Ascending----- 
  6. Name: Andrew Styne, Gender: Male, age:24 
  7. Name: Betty Clark, Gender: Female, age:20 
  8. Name: Mark Smith, Gender: Male, age:26 
  9. Name: Sandy Hunt, Gender: Female, age:23 
  10. -----Sorted JobCandidate by age: Descending----- 
  11. Name: Mark Smith, Gender: Male, age:26 
  12. Name: Andrew Styne, Gender: Male, age:24 
  13. Name: Sandy Hunt, Gender: Female, age:23 
  14. Name: Betty Clark, Gender: Female, age:20 
  15. Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.023 sec 
  16. - in guru.springframework.blog.sortarraylist.comparator.JobCandidateSorterTest 

總結(jié)

在本文中我們看到了 ArrayList 排序的不同方法。一種是使用 Comparable 另一種是使用 Comparator。方法的選擇一直是造成程序員們困惑的原因之一。你最應(yīng)該記住的就是一個 Comparable 對象可以說“我可以自己與另外一個對象比較”而一個 Comparator 對象可以說“我可以比較兩個不同的對象”。你不能說一個接口比另一個要好。選擇的接口取決于你需要實現(xiàn)的功能。

責任編輯：王雪燕 來源： ImportNew
Java不同排序方法
相關(guān)推薦

2015-03-25 11:42:52

Java刪除特定元素

2015-08-04 09:18:26

JavaArrayList元素

2023-09-01 07:38:45

ArrayListArrayst實線類

2010-01-20 09:34:26

List<T>

2023-10-04 18:23:02

插入排序算法

2021-08-19 10:30:13

Java集合排序程序開發(fā)

2011-12-30 13:15:53

Java

2021-12-20 07:11:26

Java List排序 Java 基礎(chǔ)

2010-12-23 13:56:55

SharePointIntranet

2009-09-17 13:26:55

.NET方法簽名

2019-09-10 07:58:01

字符集MySQL數(shù)據(jù)庫

2023-01-03 07:49:45

Java隨機數(shù)線程

2012-06-08 03:36:30

C#Java

2009-06-26 16:31:50

區(qū)分不同對象Hibernate

2015-07-29 13:37:41

妹子處理

2024-02-22 08:59:41

JavaArrayListLinkedList

2019-11-06 16:21:25

ArrayListLinkedListVector

2011-05-26 14:49:53

ArrayListLinkedList

2010-09-02 10:15:46

SQL刪除

2009-10-10 09:27:42

Java泛型通用方法
點贊
收藏

51CTO技術(shù)棧公眾號