Java ArrayList的分歧排序辦法。本站提示廣大學習愛好者：（Java ArrayList的分歧排序辦法）文章只能為提供參考，不一定能成為您想要的結果。以下是Java ArrayList的分歧排序辦法正文
因為其功效性和靈巧性，ArrayList是 Java 聚集框架中應用最為廣泛的聚集類之一。ArrayList 是一種 List 完成，它的外部用一個靜態數組來存儲元素，是以 ArrayList 可以或許在添加和移除元素的時刻停止靜態的擴大和縮減。你能夠曾經應用過 ArrayList，是以我將略過基本部門。假如你對 ArrayList 還不熟習，你可以參考它的 API 文檔，可以很輕易懂得在 ArrayList 上履行根本的操作。
在這篇文章中，我將評論辯論 ArrayList 中一種極端主要的操作，你很有能夠須要在企業運用開辟中完成它。它就是 ArrayList 元素的排序。
排序字符串對象的ArrayList
斟酌一個 ArrayList 存儲著以字符串情勢存在的國名（country name），為了對這個 ArrayList 停止排序，你須要挪用 Collections.sort()辦法，傳遞由國名組成的 ArrayList 對象。這類辦法將依照天然次序（按字母升序）對元素（國名）停止排序。讓我們為此來寫一段代碼。
SortArrayListAscendingDescending.java
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
package guru.springframework.blog.sortarraylist.ascendingdescending;
import org.junit.Test;
import java.util.ArrayList;
import static org.junit.Assert.*;
public class SortArrayListAscendingDescendingTest {
<a href="http://www.jobbole.com/members/madao">@Test</a>
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 對象。
到今朝為止，所要排序的 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()辦法。
JobCandidate類的代碼以下：
JobCandidate.java
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
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
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 { <a href="http://www.jobbole.com/members/madao">@Test</a> 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。
應用 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
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停止排序。如今我們寫一個類，為拜托方對 ArrayList 的元素停止排序。
JobCandidateSorter.java
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
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);
}
<a href="http://www.jobbole.com/members/madao">@Test</a>
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);
}
}
<a href="http://www.jobbole.com/members/madao">@Test</a>
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。
在本文中我們看到了 ArrayList 排序的分歧辦法。一種是應用 Comparable 另外一種是應用 Comparator。辦法的選擇一向是形成法式員們迷惑的緣由之一。你最應當記住的就是一個 Comparable 對象可以說“我可以本身與別的一個對象比擬”而一個 Comparator 對象可以說“我可以比擬兩個分歧的對象”。你不克不及說一個接口比另外一個要好。選擇的接口取決於你須要完成的功效。
以上就是本文的全體內容，願望對年夜家的進修有所贊助。
