JAVA笔记40——引用类型比较1：内置数据类型比较+comparable接口+comparator接口

最近在看JAVA教学的视频，觉得老师讲的很好，同时借用源代码还有笔记来撰写本系列博客，记录自己的学习内容，同时也供看到的人学习。

本篇和下一篇介绍一下JAVA里面的引用数据类型比较的方法。

首先来介绍一下java里面常见的内置引用类型，像是String、Integer、Date类型是如何进行比较的：

/**
 * 内置引用数据类型(常用)的比较
 */
public class Demo01 {
	public static void main(String[] args) {
		Integer  a ; //根据基本数据类型大小
		Character ch; //根据Unicode编码顺序
		String str="abc"; //如果其中一个是另外一个起始开始的子串，返回长度之差
		String str2 ="abcd123";  //否则返回第一个不相等的unicode码之差
		System.out.println(str.compareTo(str2));
		str ="abc";
		str2 ="aad";
		System.out.println(str.compareTo(str2));
		java.util.Date d ;  //如果是Date类型则根据日期的长整形数比较
	}
}

接下来我们看看标题里面提到的那两个接口的含义与区别：

再来看看comparator接口的作用与分析：

从上面的截图内容可以看出，两个常用接口的区别在于：Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

除此之外还有JDK提供的一种工具类collections也可以实现这种排序功能：

下面是实例代码：

NO.1：对于各种情况下的内容进行排序

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class Demo04 {
	public static void main(String[] args) {
		Date[] arr =new Date[3];
		arr[0] =new Date();
		arr[1] =new Date(System.currentTimeMillis()-1000*60*60);
		arr[2] =new Date(System.currentTimeMillis()+1000*60*60);
		Utils.sort(arr); //降序
		System.out.println(Arrays.toString(arr));
		//字符串
		String[] arr2 ={"a","abcd","abc","def"};
		Utils.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		System.out.println("==========List排序===========");
		//存放容器中
		List<String> list =new ArrayList<String>();
		list.add("a");
		list.add("abcd");
		list.add("abc");
		list.add("def");
		Utils.sort(list);
		System.out.println(list);
		System.out.println("==========使用Comparator 排序数组===============");
		arr2 =new String[]{"a","abcd","abc","def"};
		Utils.sort(arr2,new StringComp());
		System.out.println(Arrays.toString(arr2));
		System.out.println("==========List排序+比较器===========");
		list =new ArrayList<String>();
		list.add("a");
		list.add("abcd");
		list.add("abc");
		list.add("def");
		Utils.sort(list,new StringComp());
		System.out.println(list);
	}
}

NO.2：相应的排序方法的实现（模拟JDK的排序工具类）：

import java.util.Comparator;
import java.util.List;
/**
 * 排序，自己实现了一个工具类，类似JDK里面的collections
 */
public class Utils {
	/**
	 * List的排序+比较器
	 * @param list
	 * @param com
	 */
	public static  <T> void sort(List<T> list,Comparator<T> com){
		//第一步:转成数组
		Object[] arr =list.toArray();
		sort(arr,com);
		//第二步:改变容器中对应的值
		for(int i=0;i<arr.length;i++){
			list.set(i, (T)(arr[i]));
		}
	}
	/**
	 * 数组的排序 （降序）+Comparator接口
	 * @param arr
	 */
	public static <T> void sort(Object[] arr,Comparator<T> com){
		//从大到小排序 降序
			boolean sorted= true;
			int len =arr.length;
			for(int j=0;j<len-1;j++){ //趟数
				sorted =true; //假定有序
				for(int i=0;i<len-1-j;i++){ //次数
					if(com.compare((T)arr[i], (T)arr[i+1])<0){
						Object temp = arr[i];
						arr[i] =arr[i+1];
						arr[i+1] =temp;
						sorted =false; //假定失败
					}
				}
				if(sorted){ //减少趟数
					break;
				}
			}
	}
	/**
	 * 容器排序 (使用泛型方法)
	 */
	public static <T extends Comparable<T>> void sort(List<T> list){
		//第一步:转成数组
		Object[] arr =list.toArray();
		sort(arr);
		//第二步:改变容器中对应的值
		for(int i=0;i<arr.length;i++){
			list.set(i, (T)(arr[i]));
		}
	}
	/**
	 * 数组排序 (使用泛型方法)
	 */
	public static <T extends Comparable<T>> void sort(T[] arr){
		//从大到小排序 降序
		boolean sorted= true;
		int len =arr.length;
		for(int j=0;j<len-1;j++){ //趟数
			sorted =true; //假定有序
			for(int i=0;i<len-1-j;i++){ //次数
				if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
					T temp = arr[i];
					arr[i] =arr[i+1];
					arr[i+1] =temp;
					sorted =false; //假定失败
				}
			}
			if(sorted){ //减少趟数
				break;
			}
		}
	}	
	/**
	 * 数组的排序 （降序）
	 * @param arr
	 */
	public static void sort(Object[] arr){
		//从大到小排序 降序
		boolean sorted= true;
		int len =arr.length;
		for(int j=0;j<len-1;j++){ //趟数
			sorted =true; //假定有序
			for(int i=0;i<len-1-j;i++){ //次数
				if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
					Object temp = arr[i];
					arr[i] =arr[i+1];
					arr[i+1] =temp;
					sorted =false; //假定失败
				}
			}
			if(sorted){ //减少趟数
				break;
			}
		}
	}
}

/**
 * 排序规则的业务类
 */
public class StringComp  implements java.util.Comparator<String>{
	/**
	 * 按长度比较大小 
	 * 正数 >
	 * 负数 <
	 * 0 ==
	 */
	@Override
	public int compare(String o1, String o2) {
		int len1 =o1.length();
		int len2 =o2.length();		
		return -(len1-len2);  //加负号实现降序
	}
}

NO.3：用collections工具类的sort方法去进行排序：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
 * 使用Collections对容器的比较
 * 1、 public static <T> void sort(List<T> list, Comparator<? super T> c)  
 * 2、public static <T extends Comparable<? super T>> void sort(List<T> list)  
 * void sort(List<T> list)
 */
public class Demo05 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		List<String> list =new ArrayList<String>();
		list.add("a");
		list.add("abcd");
		list.add("abc");
		list.add("def");
		Collections.sort(list,new StringComp());  //用刚才写的比较器
		System.out.println(list);
		
		list =new ArrayList<String>();
		list.add("a");
		list.add("abcd");
		list.add("abc");
		list.add("def");
		Collections.sort(list);  //直接调用JDK的工具类
		System.out.println(list);
	}
}