1. 集合排序概述
1.1 集合排序的主要内容：
集合中的级别数据类型排序
集合中的字符串排序
Comparator接口
Comparable接口
1.2 数组排序回顾
int[] arr={12,25,22,17,89,22}; Arrays.sort(arr); 输出： 12,17,22,22,25,89Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。也可以调用sort对数组指定部分进行排序，Arrays.sort(int[] a, int fromIndex, int toIndex)【左闭右开】：
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a, 0, 3); for(int i = 0; i < a.length; i ++) { System.out.print(a[i] + " "); } 输出： 7 8 9 2 3 4 1 0 6 5 （只是把 9 8 7排列成了7 8 9）1.3 集合如何去排序？
也是使用sort方法，但不是Array类中的，而是使用Collections类的sort()方法。
sort(List
list)* :根据元素的自然顺序对指定列表按升序进行排序。（数值元素按数值大小进行升序。字符按ASCII码值进行升序。）
注：可以去API文档中去了解一下https://www.matools.com/api/java8*
2. 对基本数据类型和字符类型进行排序
2.1 对整型进行排序
package person.xsc.practice; import java.util.*; public class IntSort { public static void main(String[] args) { // TODO Auto-generated method stub //对存储在List中的整型数据进行排序 List<Integer> list=new ArrayList<Integer>(); list.add(5); list.add(8); list.add(3); list.add(1); list.add(12); System.out.println("排序前:"); for(int n:list){ System.out.print(n+" "); } System.out.println(); //对List中的数据进行排序 Collections.sort(list); System.out.println("排序后:"); for(int n:list){ System.out.print(n+" "); } } } 输出： 排序前: 5 8 3 1 12 排序后: 1 3 5 8 122.2 对字符串进行排序
package person.xsc.practice; import java.util.*; public class StringSort { public static void main(String[] args) { // TODO Auto-generated method stub //对存放在List中的字符串进行排序 List<String> list=new ArrayList<String>(); list.add("orange"); list.add("blue"); list.add("yellow"); list.add("gray"); System.out.println("排序前:"); for(String s:list){ System.out.print(s+" "); } System.out.println(); Collections.sort(list); System.out.println("排序后:"); for(String s:list){ System.out.print(s+" "); } } } 输出： 排序前: orange blue yellow gray 排序后: blue gray orange yellow3. 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 案例-对学生按姓名升序排序
package person.xsc.practice; public class Student { //成员变量 private int id; private int age; private String name; //构造方法 public Student(){} public Student(String name,int id,int age){ this.id=id; this.age=age; this.name=name; } //getter和setter方法 public int getId(){ return id; } public void setId(int id){ this.id=id; } public int getAge(){ return age; } public void setAge(int age){ this.age=age; } public String getName(){ return name; } public void setName(String name){ this.name=name; } //toString()方法 public String toString(){ return "【学号：" + this.getId() + "，年龄：" + this.getAge() + "，姓名：" + this.getName() + "】"; } }package person.xsc.practice; import java.util.Comparator; public class NameComparator implements Comparator<Student> { @Override public int compare(Student o1, Student o2) { // TODO Auto-generated method stub return o1.getName().toLowerCase().compareTo(o2.getName().toLowerCase()); }
}
package person.xsc.practice;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class StudentTest{
public static void main(String[] args){
//定义Student类的对象
Student s1=new Student("peter",40,20);
Student s2=new Student("angel",28,5);
Student s3=new Student("tom",35,18);
Student s4=new Student("Aom",35,18);
Student s5=new Student("Zom",35,18);
//将对象添加到List中
List
//第一种方式输出排序后的数据1
System.out.println("按名字排序后：");
for(Student student:arrayList){
System.out.println(student);
}
//第二种方式输出排序后的数据
System.out.println("按名字排序后：");
Iterator<Student> it = arrayList.iterator();
while(it.hasNext()){
System.out.println(it.next() + " ");
}
}}
按名字排序前： 【学号：40，年龄：20，姓名：peter】 【学号：28，年龄：5，姓名：angel】 【学号：35，年龄：18，姓名：tom】 【学号：35，年龄：18，姓名：Aom】 【学号：35，年龄：18，姓名：Zom】 按名字排序后： 【学号：35，年龄：18，姓名：Aom】 【学号：35，年龄：18，姓名：Zom】 【学号：28，年龄：5，姓名：angel】 【学号：40，年龄：20，姓名：peter】 【学号：35，年龄：18，姓名：tom】 按名字排序后： 【学号：35，年龄：18，姓名：Aom】 【学号：35，年龄：18，姓名：Zom】 【学号：28，年龄：5，姓名：angel】 【学号：40，年龄：20，姓名：peter】 【学号：35，年龄：18，姓名：tom】
## 3.3 案例-对学生按年龄升序排序
将compare方法中返回改为return o1.getAge()-o2.getAge()；
# 4. Comparable接口
## 4.1 Comparable接口简单介绍
- 此接口强行对实现它的每个类的对象进行整体排序，这种排序别称为类的自然排序，类的compareTo方法被称为它的自然比较方法。
- int compareTo(T o)方法
该对象（实现接口的类的对象）小于、等于或大于指定对象，则分别返回负整数、零或正整数。
## 4.2 对商品价格进行降序排序package person.xsc.practice;
public class Goods implements Comparable
}
public Goods(String id,String name,double price) {
this.id=id;
this.name=name;
this.price=price;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Goods [id=" + id + ", name=" + name + ", price=" + price + "]";
}
@Override
public int compareTo(Goods o) {
// TODO Auto-generated method stub
return new Double(o.getPrice()-this.getPrice()).intValue();
}}
package person.xsc.practice;
import java.util.*;
public class GoodsTets2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Goods g1=new Goods("s00001","手机",2000);
Goods g2=new Goods("s00002","冰箱",5000);
Goods g3=new Goods("s00003","电视机",3000);
List
}
排序前: Goods [id=s00001, name=手机, price=2000.0] Goods [id=s00002, name=冰箱, price=5000.0] Goods [id=s00003, name=电视机, price=3000.0] 排序后: Goods [id=s00002, name=冰箱, price=5000.0] Goods [id=s00003, name=电视机, price=3000.0] Goods [id=s00001, name=手机, price=2000.0]
# 5. Comparator接口与Comparable接口区别
- 都是java的一个接口, 并且是用来对自定义的类进行大小比较
- Comparator属于java.util包，Compatable属于java.lang包
- Comparator，要比较的类需要在外部实现改接口，Comparable，在要比较的类里实现该接口
- Comparator调用sort方法时，要指定Compatator的实现类（sort.（集合名 ，new 实现类（）），Comparable调用sort(）方法时，只需指定集合名即可 sort.（集合名）
- 由于Comparator的特性，所以Comparator可以实现多种比较方式（创建多个实现类即可），而Comparable只能实现一种比较方式（因为要在被比较的类中实现）。
# 6. 案例实现
商场正在搞活动，活动规则如下：一楼到十楼的每层电梯门口都放有一束花，花束大小不一，参与者乘坐电梯从一楼到十楼，每层楼电梯门都会打开一次，手里只能拿一束花，小慕特别想要那束最大的花，如何拿到最大的那束花呢？ package person.xsc.practice;
public class Flower implements Comparable
public int getFloor() {
return floor;
}
public void setFloor(int floor) {
this.floor = floor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
@Override
public String toString() {
return "Flower [name=" + name + ", size=" + size + ", floor=" + floor + "]";
}
@Override
public int compareTo(Flower o) {
// TODO Auto-generated method stub
return new Double(o.getSize()-this.getSize()).intValue();
}}
package person.xsc.practice; import java.util.*; public class FlowerTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Flower> list = new ArrayList<>();
list.add(new Flower("菊 花",30.6,1));
list.add(new Flower("太阳花",13.5,2));
list.add(new Flower("满天星",16.5,3));
list.add(new Flower("玫瑰花",13.5,4));
list.add(new Flower("玫瑰花",19.5,5));
list.add(new Flower("紫罗兰",16.5,6));
list.add(new Flower("曼陀罗",17.3,7));
list.add(new Flower("康乃馨",14.2,8));
list.add(new Flower("玫瑰花",35.5,9));
list.add(new Flower("玫瑰花",50.5,10));
Collections.sort(list);
System.out.println("最大的花是第"+list.get(0).getFloor()+"层的"+list.get(0).getName()+"，大小是"+list.get(0).getSize());
}} 输出：最大的花是第10层的玫瑰花，大小是50.5
# 6. 关于集合排序的面试问题
- **Comparable和Comparator接口是干什么的？列出它们的区别。**
Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。
Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。
- **List集合中根据对象的某一属性排序【手写代码】**
