Java集合排序 学习
思维导图
导学
在之前的集合课程中都没有涉及到集合的排序问题，本节课中，我们将来学习集合排序的问题。
那么，集合如何进行排序呢？首先我们要回忆一下数组是如何进行排序的：
int[] arr = new int{1,8,91,3,7,6,2,9};
Arrays.sort(arr);//数组排序
其实集合排序也会使用到sort(List方法。只是这个sort(List方法，存在于Collections类中。
注意Collections类和Collection接口
因为在集合中，List集合才是有序的。所以，集合排序通常是针对List集合而言。
小结：
- 使用
Collections类中sort(List方法对List集合进行排序list) sort(List方法根据元素的自然顺序对指定列表按升序进行排序，比如字符串或者字符数据按照Ascall码值进行排序list)
对基本数据类型和字符串类型进行排序
对整型排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class IntSort {
public static void main(String[] args) {
// 对存储在List中的整型数据进行排序
List<Integer> list=new ArrayList<Integer>();
list.add(5);
list.add(9);
list.add(3);
list.add(1);
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+" ");
}
}
}
小结：
- 泛型中的数据类型不能使用基本数据类型要使用包装类，因为
List不同与数组，参数是Object类型，都是对象，所以泛型的时候要用包装类。不能使用int，应该使用Listlist = new ArrayList (); - 集合中使用了泛型统一,则输出时候可以用
for-each循环 - 使用
Collections.sort(list);方法对集合中的内容进行升序排序;
对字符串排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class StringSort {
public static void main(String[] args) {
// 对存放在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+" ");
}
}
}
小结：字符串是按照其首字母对应的ASCII码值进行排序的。
Comparator接口
- 强行对某个对象进行整体排序的比较函数。
- 可以将
Comparator接口作为参数，传递给sort方法（如Collections.sort或Arrays.sort） - 在
Comparator接口存在int compare(T o1, T o2)方法，比较用来排序的两个参数
对于其返回值，如果o1 Comparator接口中还存在boolean equals(Object obj)方法，指示某个其他对象是否“等于”此Comparator,此方法可以被Object类中的equals方法覆盖，不必重写。
案例：宠物猫排序
public class Cat {
private String name; //名字
private int month; //年龄
private String species;//品种
//构造方法
public Cat(String name, int month, String species) {
super();
this.name = name;
this.month = month;
this.species = species;
}
//getter与setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
@Override
public String toString() {
return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
}
}
import java.util.Comparator;
public class AgeComparator implements Comparator<Cat>{
@Override
public int compare(Cat o1, Cat o2) {
// 按年龄降序排序
int age1=o1.getMonth();
int age2=o2.getMonth();
return age2-age1;
}
}
import java.util.Comparator;
public class NameComparator implements Comparator<Cat> {
@Override
public int compare(Cat o1, Cat o2) {
// 按名字升序排序
String name1=o1.getName();
String name2=o2.getName();
int n=name1.compareTo(name2);
return n;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CatTest {
public static void main(String[] args) {
// 按名字升序排序
Cat huahua=new Cat("huahua",5,"英国短毛猫");
Cat fanfan=new Cat("fanfan",2,"中华田园猫");
Cat maomao=new Cat("maomao",3,"中华田园猫");
List<Cat> catList=new ArrayList<Cat>();
catList.add(huahua);
catList.add(fanfan);
catList.add(maomao);
//排序前
System.out.println("排序前：");
for(Cat cat:catList){
System.out.println(cat);
}
//按名字进行升序排序
Collections.sort(catList, new NameComparator());
System.out.println("按名字升序排序后：");
for(Cat cat:catList){
System.out.println(cat);
}
//按年龄进行降序排序
Collections.sort(catList, new AgeComparator());
System.out.println("按年龄降序排序后：");
for(Cat cat:catList){
System.out.println(cat);
}
}
}
Comparable接口
- 此接口强行对实现它的每个类别的对象进行整体排序；
- 这种排序被称为类的自然比较方法；
int compareTo（T o）方法——比较的其实是当前对象和参数对象，该对象（实现Comparable接口的对象）小于，等于或大于指定对象（compareTo方法中的参数对象）则分别返回负整数，零或正整数。
案例：商品排序
public class Goods implements Comparable<Goods> {
private String id;//商品编号
private String name;//商品名称
private double price;//商品价格
//构造方法
public Goods(String id,String name,double price){
this.id=id;
this.name=name;
this.price=price;
}
//getter和setter方法
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;
}
public String toString(){
return "商品编号："+id+",商品名称："+name+"，商品价格："+price;
}
@Override
public int compareTo(Goods o) {
// 取出商品价格
double price1=this.getPrice();
double price2=o.getPrice();
int n=new Double(price2-price1).intValue();
return n;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class GoodsTest {
public static void main(String[] args) {
Goods g1 = new Goods("s00001", "手机", 2000);
Goods g2 = new Goods("s00002", "冰箱", 5000);
Goods g3 = new Goods("s00003", "电视机", 3000);
List<Goods> goodsList = new ArrayList<Goods>();
goodsList.add(g1);
goodsList.add(g2);
goodsList.add(g3);
// 排序前
System.out.println("排序前：");
for (Goods goods : goodsList) {
System.out.println(goods);
}
Collections.sort(goodsList);
// 排序后
System.out.println("排序后：");
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
}
排序接口区别
区别：
- 现了
java.lang.Comparable的对象直接就可以成为一个可以比较的对象，不过得在类中进行方法定义； java.util.Comparator在对象外比较，不修改实体类；- 实现了
Comparable的意思是我可以把自己和另一个对象进行比较；而实现了Comparator的意思是我可以比较其他两个对象；也就是说Comparable是一个可比较的对象可以将自己与另一个对象进行比较；而Comparator是比较两个不同的对象。 - 使用
Comparable需要修改原先的实体类，是属于一种自然排序。而Comparator则不用修改原先类。即使修改了Comparable实体类，Comparable也仅有一种比较规则。而Comparator可以实现多个，来提供多个比较规则。
使用场景：
一般情况下如果对某个类进行排序，比如Cat类，如果使用Comparable接口的方式，那么Cat类需要实现Comparable接口。如果Cat类通过Comparable接口的方式实现排序，比如通过name排序了。那么我们还希望通过age进行排序，这时不希望修改Cat类，那此时就需要使用Comparator接口了
因此，Comparable接口可以作为实现类的默认排序算法，Comparator接口则用于一个类的扩展排序