方法1：自然排序（實現comparable接口compareto方法）
方法2：自定義排序（Comparator接口、compare方法）
1、Comparable是在集合內部定義的方法實現的排序，位於java.util下。
2、如果創建一個集合來儲存對象，當存儲的對象是Integer類型、String類型時，因為這些類型已經實現了Comparable接口. 所以遍歷輸出這個集合時會按照這些類的重寫的compareTo()方法來順序輸出。List<String> list1 = new ArrayList<>();
3、如果我們想要排序一個自定義類，或者讓一個自定義類可以比較大小就需要該類實現Comparable接口，重寫compareto()方法。
4、TreeSet類的排序
1 package text; 2 3 4 5 import java.util.Iterator; 6 7 import java.util.Set; 8 9 import java.util.TreeSet; 10 11 12 13 public class Main { 14 15 16 17 public static void main(String[] args) { 18 19 Set set = new TreeSet(); 20 21 People p1 = new People(1, 18,"小明"); 22 23 People p2 = new People(2, 5,"大壯"); 24 25 People p3 = new People(3, 20,"小紅"); 26 27 28 29 set.add(p1); 30 31 set.add(p2); 32 33 set.add(p3); 34 35 36 37 Iterator it=set.iterator(); 38 39 while(it.hasNext()){ 40 41 System.out.println(it.next()); 42 43 } 44 45 } 46 47 48 49 } 50 51 52 53 package text; 54 55 56 57 public class People implements Comparable{ 58 59 int id; 60 61 int age; 62 63 String name; 64 65 66 67 public People(int id, int age, String name) { 68 69 super(); 70 71 this.id = id; 72 73 this.age = age; 74 75 this.name = name; 76 77 } 78 79 80 81 @Override 82 83 public String toString() { 84 85 return "people [id=" + id + ", age=" + age + ", name=" + name + "]"; 86 87 } 88 89 90 91 92 93 @Override 94 95 public int compareTo(Object o) { 96 97 People p; 98 99 if(o instanceof People){ 100 101 p = (People)o; 102 103 }else{ 104 105 return -1; 106 107 } 108 109 int diff = this.age - p.age; 110 111 if(diff!=0){ 112 113 diff = diff / Math.abs(diff); 114 115 } 116 117 return diff; 118 119 } 120 121 122 123 124 125 }
5、HashSet
（1）HashSet類的使用，不支持對元素數據進行排序
（2）即使自定義的類實現了comparable接口，但是結果還是不排序
6、ArrayList的排序（LInkedList的排序類似）
1 package com.xykj.comparable; 2 3 public class User implements Comparable 4 5 6 7 {//這里的User是后面集合類的泛型 8 9 String name = ""; 10 11 String password = ""; 12 13 public User(String name, String password) { 14 15 this.name = name; 16 17 this.password = password; 18 19 } 20 21 // 實現排序必須要重寫的方法 22 23 @Override 24 25 public int compareTo(User o) {//按照密碼的升序排列，想要按照名字排序就把password換成name就可以了 26 27 return password.compareTo(o.password); 28 29 } 30 31 // 重寫toString方法 32 33 @Override 34 35 public String toString() { 36 37 return name + " " + password; 38 39 } 40 41 } 42 43 44 45 46 47 package com.xykj.comparable; 48 import java.util.ArrayList; 49 50 import java.util.Collections; 51 52 public class ArrayListTest { 53 54 //對ArrayList排序必須要使用Collections.sort(list)，否則不會排序， 55 56 //會按照添加的順序打印出來 57 58 public static void main(String[] args) { 59 60 ArrayList 61 62 63 64 list = new ArrayList<>(); 65 66 for (int i = 1; i <= 10; i++) { 67 68 list.add(new User("ArrayList_name" + i, " ArrayList_password" + (50 - i))); 69 70 } 71 72 Collections.sort(list);//如果注釋后，輸入輸出不改變 73 74 for (User user : list) { 75 76 System.out.println(user.toString()); 77 78 } 79 80 } 81 82 }
結果：
升序輸入，降序輸出
二、自定義排序
1、Comparator是在集合外部實現的排序，位於java.lang下，是一個專用的比較器。當這個對象不支持自比較或者自比較函數不能滿足要求時，可寫一個比較器來完成兩個對象之間大小的比較。
2、Comparator體現了一種策略模式(strategy design pattern)，就是不改變對象自身，而用一個策略對象(strategy object)來改變它的行為。使用方法只能用Collections類的sort方法，並且是傳遞兩個參數進去（List list，Class class），第一個參數是集合的對象list，第二個是實現了comparator接口的實現類的對象。
3、 功能：按照存儲的對象的某個屬性排列來顯示該對象的所有屬性，只能對任意集合List接口下的實現類ArrayList和LinkedList進行排序
4、使用方法：
（1）需要在另一個類是實現Comparator，同樣后面也要加泛型，這個泛型是需要排序的自定義類
（2）要重寫compare方法，比較Object里面的具體屬性用compareTo
（3）需要Collections工具類的sort方法，方法里面傳入兩個參數：第一個參數是列表信息list，第二個參數是實現了comparator的類的對象
5.Comparator的示例
（1）先建一個基本屬性類
1 package com.xykj.comparatorTest; 2 3 public class Student { 4 5 //創建兩個基本屬性 6 7 String name=""; 8 9 int age=0; 10 11 12 13 //從寫構造方法用來傳遞數據 14 15 public Student(String name, int age) { 16 17 super(); 18 19 this.name = name; 20 21 this.age = age; 22 23 } 24 25 //從寫toString方法，方便顯示 26 27 @Override 28 29 public String toString() { 30 31 return name + " " + age ; 32 33 } 34 35 36 37 //基本屬性的get和set方法 38 39 public String getName() { 40 41 return name; 42 43 } 44 45 public void setName(String name) { 46 47 this.name = name; 48 49 } 50 51 public int getAge() { 52 53 return age; 54 55 } 56 57 public void setAge(int age) { 58 59 this.age = age; 60 61 } 62 63 64 65 } 66 67
（2）創建按照姓名升序排列的實現類
1 package com.xykj.comparatorTest; 2 3 4 5 import java.util.Comparator; 6 7 //按照名字的升序排列 實現接口 泛型是自定義類，里面有要排序的內容 8 9 public class NameSort implements Comparator 10 11 12 13 { 14 15 @Override //兩個參數是泛型的對象 16 17 public int compare(Student o1, Student o2) { 18 19 //按照姓名的升序排列，前面加個負號就按照降序排列 20 21 return o1.getName().compareTo(o2.getName()); 22 23 } 24 25 } 26 27
（3）創建按照年齡升序排列的實現類
1 package com.xykj.comparatorTest; 2 3 import java.util.Comparator; 4 5 //按照年齡的升序排列 實現接口 泛型是自定義類，里面有要排序的內容 6 7 public class AgeSort implements Comparator 8 9 10 11 { 12 13 14 15 @Override //兩個參數是泛型的對象 16 17 public int compare(Student o1, Student o2) { 18 19 //按照姓名的升序排列，前面加個負號就按照降序排列 20 21 return o1.getAge()-o2.getAge(); 22 23 } 24 25 }
（4）對ArrayList進行排序
1 package com.xykj.comparatorTest; 2 3 import java.util.ArrayList; 4 5 import java.util.Collections; 6 7 public class MainClass { 8 9 /** 10 11 * comparator的使用 12 13 * */ 14 15 public static void main(String[] args) { 16 17 ArrayList 18 19 20 21 list = new ArrayList<>(); 22 23 list.add(new Student("1wenzhi", 18)); 24 25 list.add(new Student("3wenzhi", 19)); 26 27 list.add(new Student("2wenzhi", 33)); 28 29 list.add(new Student("66wenzhi", 10)); 30 31 list.add(new Student("4wenzhi", 18)); 32 33 System.out.println("=========排序前======="); 34 35 for (Student student : list) { 36 37 System.out.println(student); 38 39 } 40 41 42 43 // 按照年齡升序排列 44 45 Collections.sort(list, new AgeSort()); 46 47 System.out.println("=========排序后======="); 48 49 50 51 for (Student student : list) { 52 53 System.out.println(student); 54 55 } 56 57 } 58 59 }
結果
可以看到添加數亂序添加的，正常打印是按照添加的順序打印的，排序后就可以得到想要的
Collections.sort方法只能對List接口下的實現類進行排序，對Set接口下的實現類不能進行排序