java物件排序、中文排序、list排序
java物件排序(使用Comparator)
物件屬性為int型別排序
首先我們假設有這麼一個model類:
public class JobCandidate {
private String name;
private String sex;
private int age;
public JobCandidate(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
/*@Override
public int compareTo(JobCandidate candidate) {
return (this.getAge() < candidate.getAge() ? -1 : this.getAge() == candidate.getAge() ? 0 :1);
}*/
public static Comparator<JobCandidate> ageComparator = new Comparator<JobCandidate>() {
@Override
public int compare(JobCandidate jc1, JobCandidate jc2) {
return (jc2.getAge() < jc1.getAge() ? -1 : (jc2.getAge() == jc1.getAge() ? 0 : 1));
}
};
public static Comparator<JobCandidate> nameComparator = new Comparator<JobCandidate>() {
@Override
public int compare(JobCandidate jc1, JobCandidate jc2) {
return (jc1.getName().compareTo(jc2.getName()));
}
};
public static Comparator<JobCandidate> nameChina = new Comparator<JobCandidate>() {
Collator cmp = Collator.getInstance(java.util.Locale.CHINA);
@Override
public int compare(JobCandidate o1, JobCandidate o2) {
CollationKey c1 = cmp.getCollationKey(o1.getName());
CollationKey c2 = cmp.getCollationKey(o2.getName());
return cmp.compare(c1.getSourceString(), c2.getSourceString());
// return cmp.compare(o1.getName(), o2.getName());
// return (o1.getName().compareTo(o2.getName()));
}
};
@Override
public String toString() {
return " Name: " + this.name + ", sex: " + this.sex + ", age:" + this.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
我們先看ageComparator
上面的類中聲明瞭一個ageComparator靜態變數,其寫了一個匿名類實現了compare()的方法。
要是不想使用匿名類的方式,可以在外部再建立一個類來實現Comparator介面。
接著我再寫一個排序類。也就是你想通過JobCandidate類中那個屬性來排序。
JobCandidate類裡定義了排序方法。
public class JobCandidateSorter {
ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
public JobCandidateSorter(ArrayList<JobCandidate> jobCandidateList) {
this.jobCandidateList = jobCandidateList;
}
//使用Comparable類中compareTo方法來做
/*public ArrayList<JobCandidate> getSortedJobCandidateByAge() {
Collections.sort(jobCandidate);
return jobCandidate;
}*/
public ArrayList<JobCandidate> getSortedJobCandidateByAge(){
Collections.sort(jobCandidateList, JobCandidate.ageComparator);
return jobCandidateList;
}
public ArrayList<JobCandidate> getSortedJobCandidateByName(){
Collections.sort(jobCandidateList, JobCandidate.nameComparator);
return jobCandidateList;
}
public ArrayList<JobCandidate> getSortedJobCandidateByComparator() {
Collections.sort(jobCandidateList, JobCandidate.nameChina);
return jobCandidateList;
}
}
同樣目前我們只看getSortedJobCandidateByAge()
的方法:
Collections.sort(jobCandidateList, JobCandidate.ageComparator);
該方法就是呼叫Collections.sort()
方法。
第一個引數就是我們要排序的陣列,
這裡jobCandidateList
的是List<jobCandidateList>
型別的。
第二個引數:JobCandidate.ageComparator
就是我在JobCandidate
類中定義 的匿名類。該匿名類重寫了compare()
的方法。
@Override
public int compare(JobCandidate jc1, JobCandidate jc2) {
//jc1>jc2說明是
return (jc2.getAge() < jc1.getAge() ? -1 : (jc2.getAge() == jc1.getAge() ? 0 : 1));
}
好了我們現在寫個測試類,看看效果:
public class JobCandidateSorterTest {
public void testGetSortedJobCandidateByAge() throws Exception {
JobCandidate jobCandidate1 = new JobCandidate("王林", "Male", 26);
JobCandidate jobCandidate2 = new JobCandidate("楊寶", "Female", 23);
JobCandidate jobCandidate3 = new JobCandidate("李鎮", "Female", 20);
JobCandidate jobCandidate4 = new JobCandidate("劉迪", "Male", 24);
ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
jobCandidateList.add(jobCandidate1);
jobCandidateList.add(jobCandidate2);
jobCandidateList.add(jobCandidate3);
jobCandidateList.add(jobCandidate4);
JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList);
ArrayList<JobCandidate> sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge();//呼叫排序方法
System.out.println("-----Sorted JobCandidate by age: Ascending-----");
for (JobCandidate jobCandidate : sortedJobCandidate) {
System.out.println(jobCandidate);
}
jobCandidateSorter.getSortedJobCandidateByComparator();//Collator.getInstance(java.util.Locale.CHINA)
System.out.println(jobCandidateList);
}
public static void main(String[] args) throws Exception {
JobCandidateSorterTest jt = new JobCandidateSorterTest();
jt.testGetSortedJobCandidateByAge();
}
}
列印結果
—–排序後的結果—–
Name: 王林, sex: Male, age:26
Name: 劉迪, sex: Male, age:24
Name: 楊寶, sex: Female, age:23
Name: 李鎮, sex: Female, age:20
======未排序====================
[ Name: 李鎮, sex: Female, age:20, Name: 劉迪, sex: Male, age:24, Name: 王林, sex: Male, age:26, Name: 楊寶, sex: Female, age:23]
物件屬性為String的排序
我們接下來看到上面JobCandidate
類程式碼中靜態變數nameComparator
。
public static Comparator<JobCandidate> nameComparator =
new Comparator<JobCandidate>() {
@Override
public int compare(JobCandidate jc1, JobCandidate jc2) {
return (jc1.getName().compareTo(jc2.getName()));
}
};
其中Comparable
是帶有單一 compareTo()
方法的介面.也就是說要重寫conpareTo()
的方法,得實現comparable
類。不重寫的話,就是採用預設的。
以上就是通過物件屬性排序結果,這種排序方式只適合英文排序結果,由於age
是數字,結果中英文都一樣。
我們看看name
的排序結果:
—–排序後的結果—–
Name: 劉迪, sex: Male, age:24
Name: 李鎮, sex: Female, age:20
Name: 楊寶, sex: Female, age:23
Name: 王林, sex: Male, age:26
這個結果是預設中文字串排序的順序,他們拼音首字母:L L Y W
,
我們實際希望按照中國語言的預設順序也就是按照拼音首字母來排序。
希望的正確順序就是:L L Y M
。
物件屬性為String的中文排序。
我們接下來看到上面JobCandidate類程式碼中靜態變數nameChina
。
public static Comparator<JobCandidate> nameChina = new Comparator<JobCandidate>() {
Collator cmp = Collator.getInstance(java.util.Locale.CHINA);
@Override
public int compare(JobCandidate o1, JobCandidate o2) {
// CollationKey c1 = cmp.getCollationKey(o1.getName());
// CollationKey c2 = cmp.getCollationKey(o2.getName());
// return cmp.compare(c1.getSourceString(), c2.getSourceString());
return cmp.compare(o1.getName(), o2.getName());
}
};
—–排序後的結果—–
Name: 李鎮, sex: Female, age:20
Name: 劉迪, sex: Male, age:24
Name: 王林, sex: Male, age:26
Name: 楊寶, sex: Female, age:23
拼音首字母排序:L L W Y
這才是我們想要的。
這裡使用Collator
類。在網上我找到這麼一句話:
預設情況下,字串的比較使用字串包含字元的ASCII碼來比較。
java.text.Collator使用字串包含字元在指定語言的自然順序(譬如中文漢字的自然順序)做比較。是locale敏感的。
如果只比較純英文,那麼就不需要使用collator。一般情況下我們直接使用Collections.sort()來執行排序操作、或者根據字元的ASCII碼來排序。但是,如果其中包含一些特殊字元如é、中文漢字,那邊使用collator和預設的collections.sort排序結果並不一致。
也就是說我們要使用中文排序的話,就需要使用Collator
類,再調Collator
類中的比較方法:compare()
其中compare()
方法是Comparator
介面的單一的比較方法。
上面程式碼註釋掉的:
CollationKey c1 = cmp.getCollationKey(o1.getName());
CollationKey c2 = cmp.getCollationKey(o2.getName());
return cmp.compare(c1.getSourceString(), c2.getSourceString());
這是另一種寫法而已,依然使用的是Collator
類。
java物件排序(使用Comparable)
上面使用的是實現Comparator
介面並重寫compare()
的方法。
java中還可以實現Comparable
的方法並重寫compareTo()
的方法來實現排序。
JobCandidate
中程式碼:
public class JobCandidate implements Comparable<JobCandidate>{
private String name;
private String sex;
private int age;
public JobCandidate(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = 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 + ", sex: " + this.sex + ", age:" + this.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
JobCandidateSorter
類的程式碼:
這個類就是排序類。裡面定義的都是排序的方法。
public class JobCandidateSorter {
ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
public JobCandidateSorter(ArrayList<JobCandidate> jobCandidateList) {
this.jobCandidateList = jobCandidateList;
}
//使用Comparable類中compareTo方法來做
public ArrayList<JobCandidate> getSortedJobCandidateByAge() {
Collections.sort(jobCandidateList);
return jobCandidateList;
}
}
測試類JobCandidateSorterTest
的程式碼:
public class JobCandidateSorterTest {
public void testGetSortedJobCandidateByAge() throws Exception {
JobCandidate jobCandidate1 = new JobCandidate("王林", "Male", 26);
JobCandidate jobCandidate2 = new JobCandidate("楊寶", "Female", 23);
JobCandidate jobCandidate3 = new JobCandidate("李鎮", "Female", 20);
JobCandidate jobCandidate4 = new JobCandidate("劉迪", "Male", 24);
ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
jobCandidateList.add(jobCandidate1);
jobCandidateList.add(jobCandidate2);
jobCandidateList.add(jobCandidate3);
jobCandidateList.add(jobCandidate4);
JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList);
ArrayList<JobCandidate> sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge();
System.out.println("-----排序後的結果-----");
for (JobCandidate jobCandidate : sortedJobCandidate) {
System.out.println(jobCandidate);
}
}
public static void main(String[] args) throws Exception {
JobCandidateSorterTest jt = new JobCandidateSorterTest();
jt.testGetSortedJobCandidateByAge();
}
}
排序結果(age欄位排序):
—–排序後的結果—–
Name: 李鎮, sex: Female, age:20
Name: 楊寶, sex: Female, age:23
Name: 劉迪, sex: Male, age:24
Name: 王林, sex: Male, age:26
這裡我們會發現小區別:
compare()
的方法是傳入兩個引數,也就是兩個相同型別的不同物件。
compareTo()
的方法是傳入一個引數,和呼叫該方法的物件是相同型別的。
我重寫的compareTo()
:
@Override
public int compareTo(JobCandidate candidate) {
return (this.getAge() < candidate.getAge() ? -1 : this.getAge() == candidate.getAge() ? 0 :1);
}
如果也想進行中文排序,依然是使用:
Collator cmp = Collator.getInstance(java.util.Locale.CHINA);
再呼叫cmp.compare(o1,o2)
的方法來做。
Collections.sort()
Collections.sort()這個排序的關鍵方法。不管你實現Comparable
介面還是實現Comparator
介面,都得用到該方法。
假設我們實現Comparable
的介面,這個呼叫的是:
Collections.sort(List list)
原始碼:
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set((T)a[j]);
}
}
此時直接呼叫了Arrays.sort(a)來排序後,將陣列的資料寫回到list,另外根據方法的定義,
泛型T要求傳入的類必須是Comparable類的子類或實現類(我的例子中就是JobCandidate
類),
所以要呼叫Collections.sort(list)這個方法,傳入的list中包含的每行資料必須是implements
Comparable這個介面的,否則編譯時就會報錯。
假設我們實現Comparator
的介面,則呼叫的是:
以下轉載內容
Collections.sort(List list, Comparator<? super T> c)
原始碼:
public static <T> void sort(List<T> list, Comparator<? super T> c) {
Object[] a = list.toArray();
Arrays.sort(a, (Comparator)c);
ListIterator i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set(a[j]);
}
}
也是和第一個方法類似,就是呼叫了Arrays.sort相應的過載方法,看來都是在Arrays裡面是實現的,那麼就進一步向下看:
public static void sort(Object[] a) {
Object[] aux = (Object[])a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
看來程式碼片段交給了mergeSort來處理,而對陣列做了一次克隆,作為排序的基礎資料,而原來的陣列作為排序的目標,mergeSort的程式碼片段應該是核心部分,我們先放在這裡,先看下sort的另一個過載方法,另外需要注意,這裡並沒有像Collections.sort(Listlist)那樣在編譯時檢查型別,也就是在使用這個方法的時候,數組裡面的每行並沒有implements
Comparable也會不會出錯,只是在執行時會報錯而已,在下面的原始碼中會有說明。
Arrays.sort(T[]t, Comparator<? super T> c)
原始碼:
public static <T> void sort(T[] a, Comparator<? super T> c) {
aux = (T[])a.clone();
if (c==null)
mergeSort(aux, a, 0, a.length, 0);
else
mergeSort(aux, a, 0, a.length, 0, c);
}
看來mergeSort也進行了過載,也就是當傳入了自定義的Comparator和不傳入自定義的Comparator是呼叫不同的方法來實現的,然後我們來看下兩個方法的實現。
mergeSort(Object[]src , Object[]dst , int low , int high , int off)
原始碼:
private static void mergeSort(Object[] src,
Object[] dest,
int low,
int high,
int off) {
int length = high - low;
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);
if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
/**
* Swaps x[a] with x[b].
*/
private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
仔細閱讀程式碼可以發現排序是分段遞歸回調的方式來排序(注意中間的low和high兩個引數的變化),每次如果分段的大小大於INSERTIONSORT_THRESHOLD(定義為7)的時候,則再分段,前一段和後一段,然後分開的兩段再呼叫遞推,遞推後再回歸排序,若發現中間分隔的位置兩個資料是有序,則認為兩段是完全有序的,若不是,那麼再將兩段做一次排序,此時排序就很好排序了,因為兩個塊是排序排好的,所以不需要兩次迴圈,只需要迴圈掃描下去,兩個陣列按照順序向下走,分別對比出最小值寫入陣列,較大者暫時不寫入陣列與另一個數組的下一個值進行對比,最後一截資料(原始碼中是通過越界來判定的)寫入到尾巴當中:
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
這段對兩個有序陣列的排序是很經典的寫法,主要是if語句的濃縮,不然程式碼會寫得很長。
注意:這裡的程式碼排序中使用了強制型別轉換為Comparable來呼叫內部的comareTo方法,所以如果你的類沒有implements Comparable那麼在Collections.sort(Listlist)時編譯時會報錯上面已經說到,在呼叫Arrays.sort(Object []t)時,編譯時並不會報錯,但是執行時會報錯為:java.lang.ClassCastExceptionXXXDO cannot be cast to java.lang.Comparable
排序部分我們再看看其過載的mergeSort方法,就是傳入了自定義的Comparator的方法
原始碼片段:mergeSort(Object[]src,Object[]dst,int low,int high,intoff,Comparator c)
private static void mergeSort(Object[] src,
Object[] dest,
int low, int high, int off,
Comparator c) {
int length = high - low;
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off, c);
mergeSort(dest, src, mid, high, -off, c);
if (c.compare(src[mid-1], src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
可以發現演算法和上一個方法完全一樣,唯一的區別就是排序時使用的compare變成了傳入的comparator了,其餘的沒有任何區別。
大概清楚了,此時發現java提供的排序還是比較高效的,大多數情況下你不需要自己去寫排序演算法,最後我們再看看TreeSet中的在add的時候如何實現排序的,也是分別傳入了comparator和沒有傳入,我們跟著原始碼裡面,可以看到傳入了comparator將這個屬性設定給了TreeSet裡面定義的一個TreeeMap,而TreeMap中的一個屬性設定了這個Comparator:
原始碼片段:TreeSet以及TreeMap設定Comparator的構造方法
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<E,Object>(comparator));
}
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
當然沒有傳入這個Comparator的時候自然沒有設定到TreeMap中了,那麼我們來看看TreeMap的add方法:
原始碼片段:TreeSet#add(E e)
public boolean add(E e) {
return m.put(e,PRESENT)==null;
}
這個m是什麼呢?其實通過原始碼片段7就可以看出,m是開始例項化的一個TreeMap,那麼我們就需要看TreeMap的put方法
原始碼片段:TreeMap#put(K key , V value)
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
root = new Entry<K,V>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<K,V>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
這裡判定了是否存在Comparator進行不同方式來寫入不同的位置,並沒有過載方法,所以實現上也不一定有什麼絕對非要如何做,只需要保證程式碼可讀性很好就好,一切為它服務,否則那些過多的設計是屬於過度設計,當然並不是說程式碼設計不重要,但是這些需要適可而止;另外TreeSet裡面對於其他的方法也會做排序處理,我們這裡僅僅是用add方法來做一個例子而已。
相信你對java的排序有了一些瞭解,也許本文說了一堆廢話,因為本文不是在說排序演算法,我們只是告訴你java是如何排序的,你在大部分情況下無需自己寫排序演算法來完成排序導致一些不必要的bug,而且效率未必有java本身提供的排序演算法高效。
相關推薦
Java物件和例項的關係、Java資料封裝、Java繼承和多型、Java抽象類和介面、Java靜態欄位和方法、Java包和作用域、Java的classpath和jar、Java核心類
Java物件和例項的關係: 面向物件程式設計(Object-Oriented Programming),是對現實世界建立計算機模型的一種方法。 class是物件的模板,它定義瞭如何建立例項,class的名字就是資料型別。一個class裡可以有多個欄位(field),欄位用
1-5 (JVM)Java物件模型---oop-klass模型、物件頭
參考:http://www.hollischuang.com/archives/1910或如下相關文章 Java虛擬機器系列前言在前一篇文章中我們學習了Java虛擬機器的結構原理與執行時資料區域,那麼我們大概知道了Java虛擬機器的記憶體的概況,那麼記憶體中的資料是如何建立和
根據物件的某個欄位對List排序
首先說下需求,在開發中會遇到對List<Object>進行排序,這個也可以在資料庫裡面查詢排序出來,但是有的時候會在查出來之後做一些邏輯處理然後排序,所有就要用到物件排序。 首先建立一個
JAVA 物件陣列按照多個屬性進行排序
下文可以直接拿來執行使用,也可以直接下載附件包,編譯直接執行就可以看到效果。 //ObjectSort package sort; import java.util.ArrayList; import java.util.Collections; import j
JAVA物件分析之偏向鎖、輕量級鎖、重量級鎖升級過程
在HotSpot虛擬機器裡,物件在堆記憶體中的儲存佈局可以劃分為三個部分: 物件頭(Header) 例項資料(Instance Data) 對齊填充(Padding)。 ## 物件頭 HotSpot虛擬機器(後面沒有說明的話預設是這個虛擬機器)物件頭包括三部分: 1、Mark Word 2、
PL/SQL Developer x64 官網下載、中文包、註冊碼
PL/SQL Developer x64 官網下載、中文包、註冊碼 2018年02月06日 14:24:54 你的笑忘書 閱讀數:1063 標籤: oraclePLSQL Developerx64 更多 個人分類: 
樹莓派更換國內源、安裝vim、中文輸入法、B
更換國內源(中科大) sudo -s echo -e "deb http://mirrors.ustc.edu.cn/raspbian/raspbian/ stretch main contrib non-free rpi \n deb-src http://m
ubuntu sublimetex 安裝、中文輸入、破解
安裝 apt Install the GPG key: wget -qO - https://download.sublimetext.com/sublimehq-pub.gpg | sudo apt-key add - Ensure apt is se
tomcat 域名配置、中文域名、別名配置
修改 tomcat 下的 server.xml 檔案 ,程式碼如下。 <Host name="www.chn-highway.com.cn" appBase="webapps" unpackWARs="true" autoDeploy="tr
java物件排序、中文排序、list排序
java物件排序(使用Comparator) 物件屬性為int型別排序 首先我們假設有這麼一個model類: public class JobCandidate { private String name; private Str
Java物件排序、中文排序、SortedSet排序使用和原始碼講解
在C、C++中有很多排序演算法,但是通常排序演算法不得不讓程式設計師在寫程式碼的過程中陷入對底層很多指標和位置的理解,java不希望這樣,所以排序大多可以由java幫你做掉,例如,你要對一個數組排序,就通過:Collections.sort(list)那麼這個list就被排
java學習-排序及加密簽名時資料排序方式 十大經典排序演算法(動圖演示) Java Comparator字元排序(數字、字母、中文混合排序) 編寫高質量程式碼:改善Java程式的151個建議(第5章:陣列和集合___建議70~74)
排序有兩種 1. 類實現comparable介面呼叫List.sort(null)或Collections.sort(List<T>)方法進行排序 jdk內建的基本型別包裝類等都實現了Comparablel介面,預設是使用自然排序,即升序排序 自定義類實現Comparable介面必須要實現c
用java中的外部比較器、內部比較器實現物件陣列的排序
需求: 有一個People類,該類例項化的物件存放在物件陣列中。 該類的屬性有String name,int id。 請按id的大小對物件陣列中的物件進行從小到大的排序。 第一種方法:用內部比較器比較 People類如下: /* * 為了該類的物件可以比較
Java中對List集合內的元素進行順序、倒序、隨機排序的示例程式碼
import java.util.Collections; import java.util.LinkedList; import java.util.List; public class Test { List list = new LinkedLis
java中list、list、list排序
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Ma
List集合元素的計算、排序、查找、統計
List集合 元素 計算、排序、查找、統計 引入:針對List元素的計算、排序、查找、統計。1)計算(max,min,sum)示例1:list01=[45, 90, 123, 987, -18, 78, 96]print("list01的最小值:",min(list01))pr
Java 013 StringBuffer類、Arrays類(常見排序)、包裝類(Integer類)
知識點梳理 心得體會 小知識點 1.執行緒安全與不安全 概念:程式碼所在的程序中有多個執行緒在同時執行,而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的,而且其他的變數的值也和預期的是一樣的,就是執行緒安全的。執行緒安全的程式,多程序需要訪
折半、快排、插入排序的Java實現
插入排序 import java.util.Arrays; public class InsertionSort { /** * 對數組裡面進行插入排序 * 引數1 陣列 * 引數2 陣列大小 */ static void Inser
C++ STL list的初始化、新增、遍歷、插入、刪除、查詢、排序、釋放
list是C++標準模版庫(STL,Standard Template Library)中的部分內容。實際上,list容器就是一個雙向連結串列,可以高效地進行插入刪除元素。 使用list容器之前必須加上STL的list容器的標頭檔案:#include<list>;
C#泛型效能之List<T>類序列、陣列、ArrayList類序列的排序效能差異
綜上所述,在List<T>類序列、ArrayList類序列、陣列三種資料結構中: 對值型別元素進行排序 效能最優的是List<T>類序列;其次是陣列;而ArrayList類序列略微慢於陣列。 對sting型別元素進行排序: 效能最優的是ArrayList類