方法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接口下的实现类不能进行排序