淺談對象數組或list排序及Collections排序道理。本站提示廣大學習愛好者：（淺談對象數組或list排序及Collections排序道理）文章只能為提供參考，不一定能成為您想要的結果。以下是淺談對象數組或list排序及Collections排序道理正文
常須要對list停止排序，小到List<String>，年夜到對自界說的類停止排序。不須要自行合並或堆排序。簡略完成一個接口便可。
本文先會引見應用Collections對List<String>停止排序，繼而講到Collections.sort的道理，
再講到若何對自界說類停止排序，
最初會引見應用Collections sort對自界說對象停止排序的別的一種辦法，並將兩種排序停止了簡略的機能比擬。
1、對List<String>排序及Collections.sort的道理
代碼以下
List<String> stringList = new ArrayList<String>();
stringList.add("nice");
stringList.add("delicious");
stringList.add("able");
stringList.add("moon");
stringList.add("try");
stringList.add("friend");
Collections.sort(stringList);
for (String str : stringList) {
System.out.println(str);
}
個中Collections為java.util.Collections。
檢查Collections中的sort完成
@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] array = list.toArray();
Arrays.sort(array);
int i = 0;
ListIterator<T> it = list.listIterator();
while (it.hasNext()) {
it.next();
it.set((T) array[i++]);
}
}
從中可以看出排序主體為Arrays.sort(array);Arrays的sort完成為
public static void sort(Object[] array) {
// BEGIN android-changed
ComparableTimSort.sort(array);
// END android-changed
}
持續追蹤，ComparableTimSort的sort完成ComparableTimSort.sort
static void sort(Object[] a)到static void sort(Object[] a, int lo, int hi)到private static void binarySort(Object[] a, int lo, int hi, int start)。在binarySort頂用於年夜小比擬部門為
Comparable<Object> pivot = (Comparable) a[start];
int left = lo;
int right = start;
assert left <= right;
while (left < right) {
int mid = (left + right) >>> 1;
if (pivot.compareTo(a[mid]) < 0)
right = mid;
else
left = mid + 1;
}
會挪用Object的compareTo停止比擬。而默許相似String和Integer類型都曾經籠罩compareTo辦法。所以可以自行停止比擬
2、對自界說類停止比擬
經由過程下面的引見懂得了Collections排序的道理，上面引見下自界說對象的排序，先檢查下Integer和String的比擬道理、然後引見若何對自界說類停止比擬
2.1 我們檢查Object的完成發明個中並沒有compareTo辦法，
再看下Integer界說
public final class Integer extends Number implements Comparable<Integer>
再看下String的界說
public final class String implements java.io.Serializable, Comparable<String>, CharSequence
我們可以發明他們都繼續自Comparable
2.2 檢查Comparable接口
可以發明Comparable中只要一個辦法
Java代碼
public int compareTo(T o);
也就是說現實上binarySort辦法中挪用的是Comparable的compareTo辦法，以此可知只需繼續自Comparable，
並完成compareTo便可挪用Collections.sort對自界說對象停止排序
2.3 自界說類的比擬
上面代碼為對User停止排序，起首按姓名字母前後排序，若姓名雷同，則按年紀由小到年夜排序
Java代碼
public class MainTest {
public static void main(String[] args) {
List<User> userList = new ArrayList<User>();
userList.add(new User("Lucy", 19));
userList.add(new User("Jack", 19));
userList.add(new User("Jim", 19));
userList.add(new User("James", 19));
userList.add(new User("Herry", 19));
userList.add(new User("Luccy", 19));
userList.add(new User("James", 18));
userList.add(new User("Herry", 20));
Collections.sort(userList);
for (User user : userList) {
System.out.println(user.getName() + "\t\t" + user.getAge());
}
}
private static class User implements Comparable<User> {
private String name;
private int age;
public User(String name, int age){
this.name = name;
this.age = age;
}
@Override
public int compareTo(User another) {
int compareName = this.name.compareTo(another.getName());
if (compareName == 0) {
return (this.age == another.getAge() ? 0 : (this.age > another.getAge() ? 1 : -1));
}
return compareName;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}
履行後輸入為：
Xml代碼：
Herry 19 Herry 20 Jack 19 James 18 James 19 Jim 19 Luccy 19 Lucy 19
可以看出只需兩點便可
a、繼續自Comparable
Java代碼
private static class User implements Comparable<User>
b、完成compareTo辦法
下面的public int compareTo(User another)為比擬的主體
可以看到個中int compareName = this.name.compareTo(another.getName());表現比擬姓名
若年夜於前往1，等於前往0，小於會前往-1。
若相等則依照int age的年夜小停止比擬。
下面的年夜於前往1，等於前往0，小於會前往-1也是用來binarySort比擬的根據。
3、應用Collections sort的重載函數對自界說對象停止排序
代碼以下，仍同2中的一樣先比擬姓名，若相等再比擬年紀輸入
Java代碼
public class MainTest {
public static void main(String[] args) {
List<User> userList = new ArrayList<User>();
userList.add(new User("Lucy", 19));
userList.add(new User("Jack", 19));
userList.add(new User("Jim", 19));
userList.add(new User("James", 19));
userList.add(new User("Herry", 19));
userList.add(new User("Luccy", 19));
userList.add(new User("James", 18));
userList.add(new User("Herry", 20));
Collections.sort(userList, new Comparator<User>() {
public int compare(User user1, User user2) {
int compareName = user1.getName().compareTo(user2.getName());
if (compareName == 0) {
return (user1.getAge() == user2.getAge() ? 0 : (user1.getAge() > user2.getAge() ? 1 : -1));
}
return compareName;
}
});
for (User user : userList) {
System.out.println(user.getName() + "\t\t" + user.getAge());
}
}
private static class User {
private String name;
private int age;
public User(String name, int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}
可以看出個中
Java代碼
Collections.sort(userList, new Comparator<User>())
為比擬的主體，而且完成了Comparator的compare辦法。上面引見下此種辦法的道理
追蹤Collections的
Java代碼
public static <T> void sort(List<T> list, Comparator<? super T> c)
到
Java代碼
public static <T> void sort(T[] a, Comparator<? super T> c)
到
Java代碼
private static void mergeSort(Object[] src, Object[] dest, int low, int high, int off, Comparator c)
可以發明個中代碼以下：
Java代碼
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;
}
挪用Comparator的compare辦法
4、以上兩種排序機能的比擬
binarySort須要停止nlg(n)次的比擬，最壞情形下n^2次的挪動
mergeSort是赓續停止二分，二分到很小部門落後行拔出排序。所以會比擬nlg(n)次，挪動nlg(n)次。但它須要先復制一份源數據，所以會多占用一倍的空間
所以現實情形可以依據須要選擇
以上這篇淺談對象數組或list排序及Collections排序道理就是小編分享給年夜家的全體內容了，願望能給年夜家一個參考，也願望年夜家多多支撐。
