Java集合排序 学习

思维导图

导学

在之前的集合课程中都没有涉及到集合的排序问题，本节课中，我们将来学习集合排序的问题。
那么，集合如何进行排序呢？首先我们要回忆一下数组是如何进行排序的：

int[] arr = new int{1,8,91,3,7,6,2,9};
Arrays.sort(arr);//数组排序

其实集合排序也会使用到sort(List<T> list)方法。只是这个sort(List<T> list)方法，存在于Collections类中。
注意Collections类和Collection接口
因为在集合中，List集合才是有序的。所以，集合排序通常是针对List集合而言。
小结：

• 使用Collections类中sort(List<T> list)方法对List集合进行排序
• sort(List<T> list)方法根据元素的自然顺序对指定列表按升序进行排序，比如字符串或者字符数据按照Ascall码值进行排序

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

对整型排序

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+"    ");
		}

	}
}

小结：

1. 泛型中的数据类型不能使用基本数据类型要使用包装类，因为List不同与数组，参数是Object类型，都是对象，所以泛型的时候要用包装类。不能使用int，应该使用List<Integer>list = new ArrayList<Integer>();
2. 集合中使用了泛型统一,则输出时候可以用for-each循环
3. 使用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<o2，返回整数、如果o1=o2，返回0、如果o1>o2，返回正整数
• 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);
		}

	}
}

排序接口区别

区别：

1. 现了java.lang.Comparable的对象直接就可以成为一个可以比较的对象，不过得在类中进行方法定义；
2. java.util.Comparator在对象外比较，不修改实体类；
3. 实现了Comparable的意思是我可以把自己和另一个对象进行比较；而实现了Comparator的意思是我可以比较其他两个对象；也就是说Comparable是一个可比较的对象可以将自己与另一个对象进行比较；而Comparator是比较两个不同的对象。
4. 使用Comparable需要修改原先的实体类，是属于一种自然排序。而Comparator则不用修改原先类。即使修改了Comparable实体类，Comparable也仅有一种比较规则。而Comparator可以实现多个，来提供多个比较规则。

使用场景：
一般情况下如果对某个类进行排序，比如Cat类，如果使用Comparable接口的方式，那么Cat类需要实现Comparable接口。如果Cat类通过Comparable接口的方式实现排序，比如通过name排序了。那么我们还希望通过age进行排序，这时不希望修改Cat类，那此时就需要使用Comparator接口了
因此，Comparable接口可以作为实现类的默认排序算法，Comparator接口则用于一个类的扩展排序