java中如何實現(xiàn)對ArrayList排序和ArrayList的去重復(fù)
In this post, I will discuss one of the most important operation on ArrayList that you will most likely require implementing during enterprise application development. It’s sorting the elements of an ArrayList.
在這篇文章中，我將討論 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
在上面的類中，我們在構(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。為了測試排序功能，我們將寫一段測試代碼。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;
}
}
SortArrayListAscendingDescendingTest.java
在上面的測試代碼中，我們創(chuàng)建一個 ArrayList 對象，并添加了 5 個字符串對象代表 5 個國家的名字。然后我們調(diào)用 getArrayList()、sortAscending()和 sortDescending()方法，并打印這些方法返回的 ArrayList 對象。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);
}
}
輸出如下：
-------------------------------------------------------
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 元素都是非常簡單的，我們僅僅只是調(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()方法。
The code of the JobCandidate class is this.
JobCandidate類的代碼如下：
JobCandidate.java
在上面 JobCandidate 類被重寫的 compareTo()方法中，我們實現(xiàn)了基于年齡的比較邏輯。我見過很多程序員將(this.getAge() – candidate.getAge())作為返回的比較結(jié)果。盡管使用這種 return 語句看上去似乎很吸引人，并且也不會對我們的例子造成影響，我的建議是遠離這種語句。想象一下，比較整數(shù)值，其中有一個或者兩個都是負數(shù)的結(jié)果。這會導(dǎo)致一些錯誤，讓你的程序行為不定，而且更重要的是，這樣的錯誤是很細微的，尤其是在大型的企業(yè)應(yīng)用中很難檢測出來。下面我們將寫一個輔助類，為委托方對包含了 JobCandidate 元素的 ArrayList 對象進行排序。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;
}
}
JobCandidateSorter.java
在 JobCandidateSorter 類中，我們初始化了一個 ArrayList 對象，委托方將通過構(gòu)造函數(shù)實例化 JobCandidateSorter 。然后我們編寫了 getSortedJobCandidateByAge()方法，在這個方法中，我們調(diào)用 Collections.sort()并傳遞已經(jīng)初始化了的 ArrayList 為參數(shù)，最后返回排序后的 ArrayList。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;
}
}
接下來，我們寫一個測試類來測試一下我們的代碼。
JobCandidateSorterTest.java
在上面的測試類中，我們創(chuàng)建了四個 JobCandidate 對象并把它們添加到 ArrayList，然后傳遞這個 ArrayList 到構(gòu)造函數(shù)來實例化 JobCandidateSorter 類。最后，我們調(diào)用 JobCandidateSorter 類的 getSortedJobCandidateByAge()方法，并打印這個方法返回的排序后的 ArrayList。測試的輸出結(jié)果如下：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);
}
}
}
-------------------------------------------------------
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 排序是一種常用的方法。但是你必須知道有某些限制。你想要排序的對象的類必須實現(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
在上面的類中，從 29 行到 35 行，我們寫了一個匿名類并實現(xiàn)了 compare()方法，按照年齡的降序?qū)?JobCandidate 對象進行排序。從37行到42行，我們又寫了一個匿名類并實現(xiàn)了 compare() 方法，按照姓名的升序?qū)?JobCandidate進行排序。現(xiàn)在我們寫一個類，為委托方對 ArrayList 的元素進行排序。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;
}
}
JobCandidateSorter.java
在上面的類中，我們寫了 getSortedJobCandidateByAge()方法，在這個方法內(nèi)部我們調(diào)用了 Collections.sort()的重載版本，這個版本傳遞要被排序的 ArrayList 對象和比較年齡的 Comparator 對象。在 getSortedJobCandidateByName()方法內(nèi)部，我們又調(diào)用了 Collections.sort()的另一個重載版本，這個版本傳遞要被排序的 ArrayList 對象和比較姓名的 Comparator 對象。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;
}
}
Let’s write a test class to test our code.
讓我們寫一個測試類來測試我們的代碼。
JobCandidateSorterTest.java
在測試類中我們向 ArrayList 中添加若干 JobCandidate 對象，并使用 Before 注釋在測試單元的 setup()方法中創(chuàng)建了一個 JobCandidateSorter 對象。如果你是一個 Junit 新手，可以參考我以前的文章包括 Junit 注釋（Junit 單元測試系列）。在 testGetSortedJobCandidateByAge()測試方法中我們調(diào)用了 getSortedJobCandidateByAge()方法，并打印了該方法返回的排序后的 ArrayList。在 testGetSortedJobCandidateByName()測試方法中我們調(diào)用了getSortedJobCandidateByName()方法并同樣打印該方法返回的 ArrayList。測試的輸出如下：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);
}
}
}
-------------------------------------------------------
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
總結(jié)
在本文中我們看到了 ArrayList 排序的不同方法。一種是使用 Comparable 另一種是使用 Comparator。方法的選擇一直是造成程序員們困惑的原因之一。你最應(yīng)該記住的就是一個 Comparable 對象可以說“我可以自己與另外一個對象比較”而一個 Comparator 對象可以說“我可以比較兩個不同的對象”。你不能說一個接口比另一個要好。選擇的接口取決于你需要實現(xiàn)的功能。
寫了一個java數(shù)組排序示例，
package com.yonyou.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test {
public static void main(String[] args) {
Student zlj = new Student("丁曉宇", 21);
Student dxy = new Student("趙四", 22);
Student cjc = new Student("張三", 11);
Student lgc = new Student("劉武", 19);
List<Student> studentList = new ArrayList<Student>();
studentList.add(zlj);
studentList.add(dxy);
studentList.add(cjc);
studentList.add(lgc);
System.out.println("按照年齡排序：");
Collections.sort(studentList, new SortByAge());
for (Student student : studentList) {
System.out.println(student.getName() + " / " + student.getAge());
}
System.out.println(" ========= ");
System.out.println("按照姓名排序");
Collections.sort(studentList, new SortByName());
for (Student student : studentList) {
System.out.println(student.getName() + " / " + student.getAge());
}
}
}
class SortByAge implements Comparator {
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
if (s1.getAge() > s2.getAge())
return 1;
else if (s1.getAge() == s2.getAge()) {
return 0;
}
return -1;
}
}
class SortByName implements Comparator {
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
if(s1.getName().compareTo(s2.getName()) < 0)
return -1;
else if (s1.getName().compareTo(s2.getName()) > 0) {
return 1;
}
return 0;
}
}
class Student{
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name,int age) {
this.age = age;
this.name = name;
}
}
Java中ArrayList的去重復(fù)及排序
去重復(fù)
思想：首先創(chuàng)建一個新都集合，通過遍歷舊的集合，用舊集合的元素判斷新集合當中是否有該元素，沒有就添加到新集合當中。
字符類型元素去重復(fù)
package com.lj.test;
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("hello");
arrayList.add("hello");
arrayList.add("hello");
arrayList.add("world");
arrayList.add("world");
arrayList.add("java");
ArrayList<String> arrayListnew = new ArrayList<>();
for(String s:arrayList){
if(!arrayListnew.contains(s)){
arrayListnew.add(s);
//便利舊集合沒有就添加到新集合
}
}
System.out.println("arraylistnew:" + arrayListnew);
}
}
運行結(jié)果如下：
arraylistnew:[hello, world, java]
自定義對象去重復(fù)
因為要比較自定義對象首先我們肯定要創(chuàng)建一個自定義對象
簡單定義一個學(xué)生類，傳入名字及年齡即可。需要特別注意的是由于我們要比較學(xué)生對象里面的名字及年齡是否相等才能判斷該對象是否相等所以這里需要重寫學(xué)生類的equals（）方法，有ecplise自動生成即可package com.lj.test;
public class Student {
private String studnet;
private int age;
public Student() {
super();
}
public Student(String studnet, int age) {
super();
this.studnet = studnet;
this.age = age;
}
public String getStudnet() {
return studnet;
}
public void setStudnet(String studnet) {
this.studnet = studnet;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [studnet=" + studnet + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (studnet == null) {
if (other.studnet != null)
return false;
} else if (!studnet.equals(other.studnet))
return false;
return true;
}
}
回到main方法中
package com.lj.test;
import java.util.ArrayList;
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList<Student> arrayList = new ArrayList<>();
ArrayList<Student> arrayListnew = new ArrayList<>();
Student s1 = new Student("pirlo",21);
Student s2 = new Student("pirlo",21);
Student s3 = new Student("范廚師",22);
Student s4 = new Student("馬師傅",21);
Student s5 = new Student("非洲德化",24);
Student s6 = new Student("pirlo",22);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
arrayList.add(s4);
arrayList.add(s5);
arrayList.add(s6);
for(Student s :arrayList){
System.out.println(s);
if(!arrayListnew.contains(s)){
arrayListnew.add(s);
}
}
System.out.println("---------------------");
for(Student s:arrayListnew){
System.out.println(s);
}
}
}
首先新建兩個集合，然后創(chuàng)建學(xué)生類對象，將學(xué)生類對象添加到ArrayList中，遍歷ArrayList如果沒有就將其添加進ArrayListnew中。
對兩個集合進行打印得到結(jié)果如下：
Student [studnet=pirlo, age=21]
Student [studnet=pirlo, age=21]
Student [studnet=范廚師, age=22]
Student [studnet=馬師傅, age=21]
Student [studnet=非洲德化, age=24]
Student [studnet=pirlo, age=22]
ArrayList如上
———————
ArrayListnew如下
Student [studnet=pirlo, age=21]
Student [studnet=范廚師, age=22]
Student [studnet=馬師傅, age=21]
Student [studnet=非洲德化, age=24]
Student [studnet=pirlo, age=22]
集合排序
思路：使用Collections.sort()方法進行排序
字符集合排序
package com.lj.test;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListDemo3 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("adobe");
arrayList.add("piack");
arrayList.add("錘子");
arrayList.add("手");
arrayList.add("下面是中文");
arrayList.add("我是中文");
arrayList.add("上面是中文加1");
arrayList.add("敖廠長");
arrayList.add("王尼瑪");
arrayList.add("back");
arrayList.add("aeobe");
Collections.sort(arrayList);
System.out.println(arrayList);
}
}
運行結(jié)果如下：
[adobe, aeobe, back, piack, 上面是中文加1, 下面是中文, 我是中文, 手, 敖廠長, 王尼瑪, 錘子]
觀察結(jié)果我們可以看到，對英文字符串是按字母自然排序規(guī)則進行，中文沒有看出來待核實。
自定義對象排序
同樣我們首先自定義一個學(xué)生類
package com.lj.test;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
super();
}
public Student(String studnet, int age) {
super();
this.name = studnet;
this.age = age;
}
public String getStudnet() {
return name;
}
public void setStudnet(String studnet) {
this.name = studnet;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [studnet=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
int num = this.age - o.age;
int num2 = num == 0 ?this.name.compareTo(o.name):num;
return num2;
}
}
需要注意的是要對自定義類實現(xiàn)排序我們必須在這個類實現(xiàn)一個Comparable接口并復(fù)寫其compareTo()方法。
再次回到MainActivity中：
運行結(jié)果：package com.lj.test;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListDemo3 {
public static void main(String[] args) {
ArrayList<Student> arrayList = new ArrayList<Student>();
Student s1 = new Student("pirlo",21);
Student s3 = new Student("范廚師",23);
Student s4 = new Student("馬師傅",21);
Student s5 = new Student("非洲德化",24);
Student s6 = new Student("pirlo",22);
arrayList.add(s1);
arrayList.add(s3);
arrayList.add(s4);
arrayList.add(s5);
arrayList.add(s6);
Collections.sort(arrayList);
for(Student s : arrayList){
System.out.println(s);
}
}
}
Studnet [name=pirlo, age=21]
Studnet [name=馬師傅, age=21]
Studnet [name=pirlo, age=22]
Studnet [name=范廚師, age=23]
Studnet [name=非洲德化, age=24]
已經(jīng)可以看到我們對學(xué)生們按年齡進行了排序。
有了以上兩種方法之后我們就可以使用Arraylist進行去重復(fù)和排序功能了
如對本文有疑問，請?zhí)峤坏浇涣髡搲?，廣大熱心網(wǎng)友會為你解答?。?點擊進入論壇
