Java中的排序

    Java的排序从“容器”类型来看，主要包括两种类型：一是数组排序；二是collection排序。

    从被排序的元素来看，又主要分为两类：一是基本数据类型的排序；而是自定义对象的排序。

    而对于自定义对象的排序，有两种实现方法：一是自定义一个比较器，即实现Comparator接口，不具有侵入性；二是让被排序对象实现Comparable接口，具有侵入性。

1 基本数据类型的数组排序

		String[]  strs={"Asd","DC","dc","sad","SAD","asdf"};
		Arrays.sort(strs);
		System.out.println(Arrays.toString(strs));
		//第二个参数是comparator
		Arrays.sort(strs,Collections.reverseOrder());
		System.out.println(Arrays.toString(strs));
		//忽略大小写
		Arrays.sort(strs, String.CASE_INSENSITIVE_ORDER);
		System.out.println(Arrays.toString(strs));
		
		Integer[] nums={4,12,3,1};
		Arrays.sort(nums);
		System.out.println(Arrays.toString(nums));
		//第二个参数是comparator
		Arrays.sort(nums, Collections.reverseOrder());
		System.out.println(Arrays.toString(nums));

运行结果：

[Asd, DC, SAD, asdf, dc, sad]
[sad, dc, asdf, SAD, DC, Asd]
[Asd, asdf, dc, DC, sad, SAD]
[1, 3, 4, 12]
[12, 4, 3, 1]

2 基本数据类型的Collection排序

		List<Integer> list=new ArrayList<Integer>();
		list.add(6);
		list.add(12);
		list.add(3);
		
		Collections.sort(list);
		System.out.println(list);
		//第二个参数是Comparator
		Collections.sort(list, Collections.reverseOrder());
		System.out.println(list);

运行结果：

[3, 6, 12]
[12, 6, 3]

3 自定义对象的排序

3.1 使用comparator接口，自定义比较器

被比较的对象：

public class Coffee {
	private int price;
	private String brand;
	public Coffee(int price,String brand) {
		// TODO Auto-generated constructor stub
		this.price=price;
		this.brand=brand;
	}
	public int getPrice() {
		return price;
	}
	public String getBrand() {
		return brand;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return brand+"  "+price;
	}
}

自定义比较器：

import java.util.Comparator;

public class CoffeeComparator implements Comparator<Coffee> {

	@Override
	public int compare(Coffee o1, Coffee o2) {
		// 先按照价格排序，从低到高，然后再按照名称排序，升序
		if (o1.getPrice()!=o2.getPrice()) {
			return o1.getPrice()-o2.getPrice();
		}else {
			return o1.getBrand().compareTo(o2.getBrand());
		}
	}

}

测试代码：

这种方法其实使用了策略模式的思想，通过传入不同的比较器，来实现不同的排序。

		List<Coffee> coffees=new ArrayList<Coffee>();
		Coffee mocha=new Coffee(12, "mocha");
		Coffee latte=new Coffee(10, "latte");
		Coffee capu=new Coffee(10, "copu");
		Coffee breve=new Coffee(15, "breve");
		coffees.add(breve);
		coffees.add(latte);
		coffees.add(mocha);
		coffees.add(capu);
		Collections.sort(coffees, new CoffeeComparator());
		System.out.println(coffees);

运行结果：

[copu  10, latte  10, mocha  12, breve  15]

3.2 实现comparable接口，具有一定侵入性

被比较对象：

public class Coffee implements Comparable<Coffee>{
	private int price;
	private String brand;
	public Coffee(int price,String brand) {
		// TODO Auto-generated constructor stub
		this.price=price;
		this.brand=brand;
	}
	public int getPrice() {
		return price;
	}
	public String getBrand() {
		return brand;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return brand+"  "+price;
	}
	@Override
	public int compareTo(Coffee o) {
		// TODO Auto-generated method stub
		if (this.getPrice()!=o.getPrice()) {
			return o.getPrice()-this.getPrice();
		}else {
			return this.getBrand().compareTo(o.getBrand());
		}
	}
}

测试代码：

		List<Coffee> coffees=new ArrayList<Coffee>();
		Coffee mocha=new Coffee(12, "mocha");
		Coffee latte=new Coffee(10, "latte");
		Coffee capu=new Coffee(10, "copu");
		Coffee breve=new Coffee(15, "breve");
		coffees.add(breve);
		coffees.add(latte);
		coffees.add(mocha);
		coffees.add(capu);
		
		Collections.sort(coffees);
		
		System.out.println(coffees);

运行结果：

[breve  15, mocha  12, copu  10, latte  10]