区间调度（贪心+类的排序法则）

 分析：

1. 找出方案，要找出最佳策略就联想到贪心，进过找规律，可以看到，当每次选择最早结束项目的那个项目，那么最后项目总数就会越多。所以就要对类进行排序，按他的结束时间进行排序。
2. Arrays.sort()只有对整数字符串进行排序的规则（自带比较方法），对类的排序是不确定的，所以要实现接口，也就是他的排序规则。
3. 排序规则：当结束时间相等的时候就对按开始时间进行排序，否则就按截止时间有小到大排序。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static int n;
	public static int count = 0;;
	public static int a[];
	public static int b[];

	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		n = sca.nextInt();
		a = new int[n];
		b = new int[n];
		for(int i = 0; i < n; i ++) {
			a[i] = sca.nextInt();
		
		}
		for(int i = 0; i < n; i ++) {
			b[i] = sca.nextInt();
			
		}
        
		//将a,b数组中对应的数捆绑在一起，然后对其进行排序
		Job js[] = new Job[n];
		for(int i = 0; i < n; i ++) {
			js[i] = new Job(a[i], b[i]);
		}
	 
		//要对其接口进行实现，才可以让Arrays对他的排序规则识别并排序
		Arrays.sort(js);
		System.out.println("排序后：");
		for(int i = 0; i < n; i ++) {
			System.out.println(js[i].s + " " + js[i].e);
		}
		
		//找出最多能参加的工作个数
		int endTime = js[0].e;
		count ++;
		for(int i = 1; i < n; i ++) {
			 if(js[i].s > endTime) {
				 count ++;
				 endTime = js[i].e;
			 }
		}
		System.out.println("可选工作做多个数：");
		System.out.println(count);
	}
	
}
class Job implements Comparable  {
	int s;
	int e;
	//构造方法 
	public Job(int s, int e) {
	  this.s = s;
	  this.e = e;
	}
	public int compareTo(Job j) {
		int x = this.e - j.e;
		if(x == 0) {           //如果截止时间相等就按初始时间由大到小排序
			return this.s - j.s;
		}
		return x;	           //否则就按截止时间有小到大排序
	}
}

运行结果1： 

5
1 2 4 6 8
2 5 7 9 10
排序后：
1 2
2 5
4 7
6 9
8 10
可选工作做多个数：
3