java300集-Comparable接口-引用类型的比较（内置类比较）

最新推荐文章于 2025-06-23 16:08:45 发布

Carmen_W

最新推荐文章于 2025-06-23 16:08:45 发布

阅读量192

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA基础

本文链接：https://blog.youkuaiyun.com/xw_Summer/article/details/84972124

JAVA基础专栏收录该内容

38 篇文章

订阅专栏

本文探讨了内置引用数据类型的比较方法，包括整型、字符型、字符串和日期的比较规则。通过具体示例，展示了如何使用Java的Comparable接口进行字符串和日期的排序，以及如何自定义排序规则实现复杂数据类型的排序。

内置引用数据类型(常用)的比较

package com.bjsxt.sort.innerType;
/**
 * 内置引用数据类型(常用)的比较
 * @author Administrator
 *
 */
public class Demo01 {

	/**
	 * @param args
	 */
	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 ;  //根据日期的长整形数比较
	}

}


结果：-4
1

用冒泡排序字符串数组

package com.bjsxt.sort.innerType;

import java.util.Arrays;

public class Demo02 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String[] arr ={"a","abcd","abc","def"};  //字符串不能直接比较大小，要用到Comparable接口
		//从大到小排序 降序
		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){   //比较
					String temp = arr[i];
					arr[i] =arr[i+1];
					arr[i+1] =temp;
					sorted =false; //假定失败
				}
			}
			if(sorted){ //减少趟数  ，n个对象排，并不一定需要n-1趟
				break;
			}
		}
		
		System.out.println(Arrays.toString(arr));
	}

}

冒泡排序日期数组

package com.bjsxt.sort.innerType;

import java.util.Arrays;
import java.util.Date;

public class Demo03 {

	/**
	 * @param args
	 */
	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);
		//降序
		
		//从大到小排序 降序
			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){
						Date temp = arr[i];
						arr[i] =arr[i+1];
						arr[i+1] =temp;
						sorted =false; //假定失败
					}
				}
				if(sorted){ //减少趟数
					break;
				}
			}
			
			System.out.println(Arrays.toString(arr));//将日期转换为字符串
	}

}

升级版：
定义工具类：

package com.bjsxt.sort.innerType;

import java.util.Comparator;
import java.util.List;



/**
 * 排序
 * @author Administrator
 *
 */
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;
			}
		}
		
	}
	
	
}

自定义排序规则的比较类：

package com.bjsxt.sort.innerType;
/**
 * 排序规则的业务类（实现了java.util包中的Comparator接口，重写了compare方法）
 * @author Administrator
 *
 */
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);  //定义升序或降序
	}
	

}

package com.bjsxt.sort.innerType;

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

public class Demo04 {

	/**
	 * @param args
	 */
	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);
		
	}

}

Collections工具类用于容器的比较

package com.bjsxt.sort.innerType;

import java.util.ArrayList;
import java.util.Collections;  //这里使用了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)
 * @author Administrator
 *
 */
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);//不指定排序规则，则使用默认规则
		System.out.println(list);  //默认升序
		
		
	}

}