java 集合(5) 类对象排序 / 类实现Comparable 接口 / 调用Collections 类sort()

1. 数组排序( 基本类型 )

   int[ ] a ;
   Arrays.sort(a);

2. 数组排序( 类对象 )

    Object[ ] a;  // 这里Object 泛指所有类，此时Object 类需要实现Comparable 接口，重写其唯一方法compareTo(Object o)，从而定义比较规则，sort( )

   Arrays.sort(a);   // 函数才能实现排序

3. List 排序( 类对象 )

public class Iplong implements Comparable {  // Iplong 对象是List 中的元素，也是需要通过比较来排序的对象，所以这个类要实现Comparable 接口
	public String firstName;
	public String lastName;

	public static void main(String[] args)  {
		//Comparable 接口， 实现了这个接口的类他们之间的对象可以比较大小，这个接口中只有一个方法，compareTo
		List list = new ArrayList();
		list.add(new Iplong("di", "jia"));
		list.add(new Iplong("ci", "ji"));
		list.add(new Iplong("bia", "jia"));
		list.add(new Iplong("dia", "jia"));
		Collections.sort(list);//按照Iplong对象的大小来排序,没这句，不调用compareTo，而且没有这句则输出[di jia, ci ji, bia jia, dia jia]
		System.out.println(list);//有上面一句则输出排好序的 [bia jia, ci ji, di	jia, dia jia]
	}

	@Override
	public int compareTo(Object o) {
		Iplong iplong = (Iplong)o;
		int firstNameCompare = firstName.compareTo(iplong.firstName);
		return (firstNameCompare!=0)? firstNameCompare: lastName.compareTo(iplong.lastName);
	}
}

4.compareTo( ) 调用时机 / Collections.sort( ) 调用内涵

   Collections.sort( list ) ，底层实现是Object[] a = list.toArray();  Arrays.sort(a); ，也就是和上面的数组排序是一个道理。

   （1）每次需要比较两个元素，则调用a. compareTo( b ) 方法，bafcd，拿出来a 和b 比较( 拿出来 f 和a / b 比较)，则a 是调用方，b 是形参

   （2）排序结束后，再组装成有序的list，中间比较的过程，不改变原始数组 

     (3)  Arrays.sort( ) 这个排序是冒泡排序，里面经过了优化，具体看下面程序。

     具体代码：

public class Iplong implements Comparable {
	public String firstName;
	public String lastName;
	public static List list = new ArrayList();
	
	//排序sort()用法，List作为被排序集合
	public static void main(String[] args)  {
		list.add(new Iplong("g", ""));
		list.add(new Iplong("f", ""));
		list.add(new Iplong("h", ""));
		list.add(new Iplong("k", ""));
		list.add(new Iplong("l", ""));
		list.add(new Iplong("g", ""));
		list.add(new Iplong("t", ""));
		list.add(new Iplong("n", ""));
		list.add(new Iplong("o", ""));
		list.add(new Iplong("p", ""));
		Collections.sort(list);//按照Iplong对象的大小来排序,没这句，不调用compareTo，而且没有这句则输出[g, f, h, k, l, g, t, n<span style="white-space:pre">	</span>, o, p] 
		System.out.println(list);//有上面一句则输出排好序的 [f, g, g, h, k, l, n, o, p, t]  
	}
	
	@Override
	public int compareTo(Object o) {
		// Comparable 接口， 实现了这个接口的类他们之间的对象可以比较大小，这个接口中只有一个方法，compareTo
		Iplong iplong = (Iplong) o; //object 强转成具体类型
		int firstNameCompare = firstName.compareTo(iplong.firstName);
		System.out.println("-----\n第"+list.indexOf(this)+"个"+firstName +"和形参"+"第"+list.indexOf(iplong)+"个"+iplong.firstName+"相比较\n------");
		return (firstNameCompare != 0) ? firstNameCompare : lastName
				.compareTo(iplong.lastName);
	}
}

结果为：

[g	, f	, h	, k	, l	, g	, t	, n	, o	, p	]  原始数组

[f	, g	, g	, h	, k	, l	, n	, o	, p	, t	]  排序结果数组

-----
第1个f和形参第0个g相比较---结果 fg hklgtnop
------
-----
第2个h和形参第1个f相比较---结果  fgh klgtnop    看，没有都比较完，之前的每次比较，都不会改变原始数组，全都比较完，  
												一次性把数组改掉。这样免得数组元素插入/删除/移动，浪费效率。
------
-----
第2个h和形参第0个g相比较---结果  fgh klgtnop
------
-----
第3个k和形参第0个g相比较---结果  看k 只和gh比较，没和f比较，这个是优化 
------
-----
第3个k和形参第2个h相比较---结果  结果fghk lgtnop ，看k 只和gh比较，没和f比较，这个是优化 
------
-----
第4个l和形参第2个h相比较---结果     fghkl gtnop  看l只和h / k 比较了，和f/g 都没比较，这个是优化
------
-----
第4个l和形参第3个k相比较---结果
------
-----
第5个g和形参第2个h相比较    g先和h 比，再往前一格和g比，说明卡在中间，与其相比，较大的话，行为是往前比
------
-----
第5个g和形参第0个g相比较---结果   fgghkl tnop
------
-----
第6个t和形参第2个h相比较
------
-----
第6个t和形参第4个l相比较---结果   fgghklt nop  看，t只和h / l比较，连他俩中间的k 都被跳过了，优化明显
------
-----
第7个n和形参第2个h相比较
------
-----
第7个n和形参第4个l相比较
------
-----
第7个n和形参第6个t相比较---结果   fgghklnt op    n 和hlt比较，跳过了中间的k
------
-----
第8个o和形参第3个k相比较
------
-----
第8个o和形参第7个n相比较
------
-----
第8个o和形参第6个t相比较---结果   fgghklnot p  o和k / n / t 相比较，
------
-----
第9个p和形参第3个k相比较
------
-----
第9个p和形参第8个o相比较
------
-----
第9个p和形参第6个t相比较---结果	fgghklnopt p和k/ o/ t比较
------