1. 集合排序概述

1.1 集合排序的主要内容：

集合中的级别数据类型排序
集合中的字符串排序
Comparator接口
Comparable接口

1.2 数组排序回顾

1int[] arr={12,25,22,17,89,22};
2Arrays.sort(arr);
3输出：
412,17,22,22,25,89

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。也可以调用sort对数组指定部分进行排序，Arrays.sort(int[] a, int fromIndex, int toIndex)【左闭右开】：

1int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
2Arrays.sort(a, 0, 3);
3for(int i = 0; i < a.length; i ++) {
4    System.out.print(a[i] + " ");
5}
6输出：
77 8 9 2 3 4 1 0 6 5 （只是把 9 8 7排列成了7 8 9）

1.3 集合如何去排序？

也是使用sort方法，但不是Array类中的，而是使用Collections类的sort()方法。 sort(List<T>list):根据元素的自然顺序对指定列表按升序进行排序。（数值元素按数值大小进行升序。字符按ASCII码值进行升序。）
K(MC{}KNZU`U$R1UFKT(PGN 注：可以去API文档中去了解一下https://www.matools.com/api/java8

2. 对基本数据类型和字符类型进行排序

2.1 对整型进行排序

1package person.xsc.practice;
2import java.util.*;
3public class IntSort {
4
5	public static void main(String[] args) {
6		// TODO Auto-generated method stub
7		 //对存储在List中的整型数据进行排序
8        List<Integer> list=new ArrayList<Integer>();
9        list.add(5);
10        list.add(8);
11        list.add(3);
12        list.add(1);
13        list.add(12);
14        System.out.println("排序前:");
15        for(int n:list){
16            System.out.print(n+" ");
17        }
18        System.out.println();
19        //对List中的数据进行排序
20        Collections.sort(list);
21        System.out.println("排序后:");
22        for(int n:list){
23            System.out.print(n+" ");
24        }
25	}
26}
27输出：
28排序前:
295 8 3 1 12 
30排序后:
311 3 5 8 12

2.2 对字符串进行排序

1package person.xsc.practice;
2import java.util.*;
3public class StringSort {
4	public static void main(String[] args) {
5		// TODO Auto-generated method stub
6		//对存放在List中的字符串进行排序
7        List<String> list=new ArrayList<String>();
8        list.add("orange");
9        list.add("blue");
10        list.add("yellow");
11        list.add("gray");
12        System.out.println("排序前:");
13        for(String s:list){
14            System.out.print(s+" ");
15        }
16        System.out.println();
17        Collections.sort(list);
18        System.out.println("排序后:");
19        for(String s:list){
20            System.out.print(s+" ");
21        }
22	}
23}
24输出：
25排序前:
26orange blue yellow gray 
27排序后:
28blue gray orange yellow

3. Comparator接口

3.1 Comparator接口简单介绍

强行对某个对象进行整体排序的比较函数
可以将Comparator 传递给sort方法（如在集合中排序Collections.sort 或在数组中Arrays.sort）
int compare（T o1，T o2）比较用来排序的两个参数。如果o1<o2,返回负整数；如果o1==o2，返回0；如果o1>02，返回正整数
boolean equals（Object obj）指示某个其他对象是否“等于”此Comparator
此方法可以被Object类中的equals方法覆盖，不必重写

3.2 案例-对学生按姓名升序排序

1package person.xsc.practice;
2public class Student {
3    //成员变量
4    private int id;
5    private int age;
6    private String name;
7    //构造方法
8    public Student(){}
9    public Student(String name,int id,int age){
10        this.id=id;
11        this.age=age;
12        this.name=name;
13    }
14    //getter和setter方法
15    public int getId(){
16        return id;
17    }
18    public void setId(int id){
19        this.id=id;
20    }
21    public int getAge(){
22        return age;
23    }
24    public void setAge(int age){
25        this.age=age;
26    }
27    public String getName(){
28        return name;
29    }
30    public void setName(String name){
31        this.name=name;
32    }
33    //toString()方法
34    public String toString(){
35        return "【学号：" + this.getId() + "，年龄：" + this.getAge() + "，姓名：" + this.getName() + "】";
36    }
37}

1package person.xsc.practice;
2import java.util.Comparator;
3public class NameComparator implements Comparator<Student> {
4	@Override
5	public int compare(Student o1, Student o2) {
6		// TODO Auto-generated method stub
7		return o1.getName().toLowerCase().compareTo(o2.getName().toLowerCase());
8	}
9
10}
11

1package person.xsc.practice;
2import java.util.ArrayList;
3import java.util.Collections;
4import java.util.Iterator;
5import java.util.List;
6public class StudentTest{
7    public static void main(String[] args){
8        //定义Student类的对象
9        Student s1=new Student("peter",40,20);
10        Student s2=new Student("angel",28,5);
11        Student s3=new Student("tom",35,18);
12        Student s4=new Student("Aom",35,18);
13        Student s5=new Student("Zom",35,18);
14        //将对象添加到List中
15        List<Student> arrayList=new ArrayList<Student>();
16        arrayList.add(s1);
17        arrayList.add(s2);
18        arrayList.add(s3);
19        arrayList.add(s4);
20        arrayList.add(s5);
21        //输出排序前的数据
22        System.out.println("按名字排序前：");
23        for(Student student:arrayList){
24            System.out.println(student);
25        }
26         //排序
27        Collections.sort(arrayList,new NameComparator());
28        
29        //第一种方式输出排序后的数据1
30        System.out.println("按名字排序后：");
31        for(Student student:arrayList){
32            System.out.println(student);
33        }
34           //第二种方式输出排序后的数据
35        System.out.println("按名字排序后：");
36        Iterator<Student> it = arrayList.iterator();
37        while(it.hasNext()){
38            System.out.println(it.next() + " ");
39        }
40    }
41}
42

1按名字排序前：
2【学号：40，年龄：20，姓名：peter】
3【学号：28，年龄：5，姓名：angel】
4【学号：35，年龄：18，姓名：tom】
5【学号：35，年龄：18，姓名：Aom】
6【学号：35，年龄：18，姓名：Zom】
7按名字排序后：
8【学号：35，年龄：18，姓名：Aom】
9【学号：35，年龄：18，姓名：Zom】
10【学号：28，年龄：5，姓名：angel】
11【学号：40，年龄：20，姓名：peter】
12【学号：35，年龄：18，姓名：tom】
13按名字排序后：
14【学号：35，年龄：18，姓名：Aom】 
15【学号：35，年龄：18，姓名：Zom】 
16【学号：28，年龄：5，姓名：angel】 
17【学号：40，年龄：20，姓名：peter】 
18【学号：35，年龄：18，姓名：tom】 
19

3.3 案例-对学生按年龄升序排序

将compare方法中返回改为return o1.getAge()-o2.getAge()；

4. Comparable接口

4.1 Comparable接口简单介绍

此接口强行对实现它的每个类的对象进行整体排序，这种排序别称为类的自然排序，类的compareTo方法被称为它的自然比较方法。
int compareTo(T o)方法该对象（实现接口的类的对象）小于、等于或大于指定对象，则分别返回负整数、零或正整数。

4.2 对商品价格进行降序排序

1package person.xsc.practice;
2public class Goods implements Comparable<Goods>{
3	private String id;
4	private String name;
5	private double price;
6	public Goods() {
7		
8	}
9	public Goods(String id,String name,double price) {
10		this.id=id;
11		this.name=name;
12		this.price=price;
13	}
14	public String getId() {
15		return id;
16	}
17	public void setId(String id) {
18		this.id = id;
19	}
20	public String getName() {
21		return name;
22	}
23	public void setName(String name) {
24		this.name = name;
25	}
26	public double getPrice() {
27		return price;
28	}
29	public void setPrice(double price) {
30		this.price = price;
31	}
32	@Override
33	public String toString() {
34		return "Goods [id=" + id + ", name=" + name + ", price=" + price + "]";
35	}
36
37	@Override
38	public int compareTo(Goods o) {
39		// TODO Auto-generated method stub
40		return new Double(o.getPrice()-this.getPrice()).intValue();
41	}
42	
43}
44

1package person.xsc.practice;
2import java.util.*;
3public class GoodsTets2 {
4	public static void main(String[] args) {
5		// TODO Auto-generated method stub
6		Goods g1=new Goods("s00001","手机",2000);
7        Goods g2=new Goods("s00002","冰箱",5000);
8        Goods g3=new Goods("s00003","电视机",3000);
9        List<Goods> goodsList=new ArrayList<Goods>();
10        goodsList.add(g1);
11        goodsList.add(g2);
12        goodsList.add(g3);
13        //排序前
14        System.out.println("排序前:");
15        for(Goods  goods:goodsList){
16            System.out.println(goods);
17        }
18        Collections.sort(goodsList);
19        System.out.println("排序后:");
20        for(Goods  goods:goodsList){
21            System.out.println(goods);
22        }
23	}
24
25}
26

1排序前:
2Goods [id=s00001, name=手机, price=2000.0]
3Goods [id=s00002, name=冰箱, price=5000.0]
4Goods [id=s00003, name=电视机, price=3000.0]
5排序后:
6Goods [id=s00002, name=冰箱, price=5000.0]
7Goods [id=s00003, name=电视机, price=3000.0]
8Goods [id=s00001, name=手机, price=2000.0]
9

5. Comparator接口与Comparable接口区别

都是java的一个接口, 并且是用来对自定义的类进行大小比较
Comparator属于java.util包，Compatable属于java.lang包
Comparator，要比较的类需要在外部实现改接口，Comparable，在要比较的类里实现该接口
Comparator调用sort方法时，要指定Compatator的实现类（sort.（集合名，new 实现类（）），Comparable调用sort(）方法时，只需指定集合名即可 sort.（集合名）
由于Comparator的特性，所以Comparator可以实现多种比较方式（创建多个实现类即可），而Comparable只能实现一种比较方式（因为要在被比较的类中实现）。

6. 案例实现

商场正在搞活动，活动规则如下：一楼到十楼的每层电梯门口都放有一束花，花束大小不一，参与者乘坐电梯从一楼到十楼，每层楼电梯门都会打开一次，手里只能拿一束花，小慕特别想要那束最大的花，如何拿到最大的那束花呢？

1package person.xsc.practice;
2
3public class Flower implements Comparable<Flower>{
4	private String name;
5	private double size;
6	private int floor;
7	public Flower() {}
8	public Flower(String name, double size,int floor) {
9		this.name = name;
10		this.size = size;
11		this.floor=floor;
12	}
13	
14	public int getFloor() {
15		return floor;
16	}
17	public void setFloor(int floor) {
18		this.floor = floor;
19	}
20	public String getName() {
21		return name;
22	}
23
24	public void setName(String name) {
25		this.name = name;
26	}
27
28	public double getSize() {
29		return size;
30	}
31
32	public void setSize(double size) {
33		this.size = size;
34	}
35	
36	@Override
37	public String toString() {
38		return "Flower [name=" + name + ", size=" + size + ", floor=" + floor + "]";
39	}
40
41	@Override
42	public int compareTo(Flower o) {
43		// TODO Auto-generated method stub
44		return  new Double(o.getSize()-this.getSize()).intValue();
45	}
46
47}
48

1package person.xsc.practice;
2import java.util.*;
3public class FlowerTest {
4
5	public static void main(String[] args) {
6		// TODO Auto-generated method stub
7		List<Flower> list = new ArrayList<>();
8		list.add(new Flower("菊    花",30.6,1));
9		list.add(new Flower("太阳花",13.5,2));
10		list.add(new Flower("满天星",16.5,3));
11		list.add(new Flower("玫瑰花",13.5,4));
12		list.add(new Flower("玫瑰花",19.5,5));
13		list.add(new Flower("紫罗兰",16.5,6));
14		list.add(new Flower("曼陀罗",17.3,7));
15		list.add(new Flower("康乃馨",14.2,8));
16		list.add(new Flower("玫瑰花",35.5,9));
17		list.add(new Flower("玫瑰花",50.5,10));
18		Collections.sort(list);
19		System.out.println("最大的花是第"+list.get(0).getFloor()+"层的"+list.get(0).getName()+"，大小是"+list.get(0).getSize());
20	}
21
22}
23输出：最大的花是第10层的玫瑰花，大小是50.5

6. 关于集合排序的面试问题

Comparable和Comparator接口是干什么的？列出它们的区别。

Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。 Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

List集合中根据对象的某一属性排序【手写代码】

Java中集合排序常用的方式