java基础 comparable与comparator的作用以及区别

最新推荐文章于 2024-05-27 14:35:21 发布

小猪弟

最新推荐文章于 2024-05-27 14:35:21 发布

阅读量149

点赞数

分类专栏： Java基础文章标签： java 编程语言接口

本文链接：https://blog.csdn.net/u011863822/article/details/110697687

版权

Java基础专栏收录该内容

63 篇文章 0 订阅

订阅专栏

有时候调用arrays.sort()就会实现排序如下

public class Test  {

	public static void main(String[] args) {
       
		String[] arr= {"ad","ab","cd","ba"};
		System.out.println("排序前"+Arrays.toString(arr));
		Arrays.sort(arr);
		System.out.println("排序后"+Arrays.toString(arr));
		Integer[] arr1= {4,2,1,6};
		System.out.println("排序前"+Arrays.toString(arr1));
		Arrays.sort(arr1);
		System.out.println("排序后"+Arrays.toString(arr1));
	}
	
	}	
	
//输出
排序前[ad, ab, cd, ba]
排序后[ab, ad, ba, cd]
排序前[4, 2, 1, 6]
排序后[1, 2, 4, 6]

调用arrays.sort，方法后就会变得按照从小到大的顺序排列。那么我们自定义一个类，然后可以放在数组里面，可以排序吗？

public class Test  {

	public static void main(String[] args) {

	Person[] per= {new Person("lily"),new Person("andy")};
		System.out.println("排序前"+Arrays.toString(per));
		Arrays.sort(per);
		System.out.println("排序后"+Arrays.toString(per));
	}
	}	
	

class Person {
	String name;
	

	public Person(String name) {
	
		this.name = name;
	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}
// 输出
排序前[test.Person@7852e922, test.Person@4e25154f]
Exception in thread "main" java.lang.ClassCastException: test.Person cannot be cast to java.lang.Comparable
	at java.util.ComparableTimSort.countRunAndMakeAscending(Unknown Source)
	at java.util.ComparableTimSort.sort(Unknown Source)
	at java.util.Arrays.sort(Unknown Source)
	at test.Test.main(Test.java:61)

报错：Exception in thread “main” java.lang.ClassCastException: test.Person cannot be cast to java.lang.Comparable

这个是类型转换异常，而这个异常中出了要说的Comparable。

可以看一下string类的是如何创建的，因为它使用arrays.sort() 没有报错，看起与comparable是什么关系

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

可以看出comparable是一个接口。

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

在这里插入图片描述

可以看出接口只有一个方法，那就是compareto方法，当然我们可以先看一下

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

通过这个方法可以看出，对比两个数据之间的大小，然后返回-1，0，1.

这样的话我们可以试一下，如果我们在自己建立的类中继承comparable接口是否可以呢？那就先试代码。

public class Test  {

	public static void main(String[] args) {
		

	Person[] per= {new Person("lily"),new Person("andy")};
		System.out.println("排序前"+Arrays.toString(per));
		Arrays.sort(per);
		System.out.println("排序后"+Arrays.toString(per));
	}
	}	
	

class Person  implements Comparable<Person>{
	String name;
	

	public Person(String name) {
	
		this.name = name;
	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public int compareTo(Person o) {
		
		return this.name.compareTo(o.name);// 因为string本身就有这个方法，我们直接使用字符串compareto方法
	}

	
}
// 输出
排序前[test.Person@7852e922, test.Person@4e25154f]
排序后[test.Person@4e25154f, test.Person@7852e922]

可以看出可以按照person中的名字根据字符串的排序对person对象进行了排序。所以可以看出arrays.sort()排序数组，需要数组中的对象实现comparable接口。

如果需要排序需要从大到小的话，如何解决？

public class Test  {

	public static void main(String[] args) {
		

	Person[] per= {new Person("lily"),new Person("andy")};
		System.out.println("排序前"+Arrays.toString(per));
		Arrays.sort(per);
		System.out.println("排序后"+Arrays.toString(per));
	}
	}	
	

class Person  implements Comparable<Person>{
	String name;
	

	public Person(String name) {
	
		this.name = name;
	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public int compareTo(Person o) {
		
		return -this.name.compareTo(o.name);// 修改器返回的正负即可修改array.sort()排序的模式
	}

	
}
// 输出
排序前[test.Person@7852e922, test.Person@4e25154f]
排序后[test.Person@7852e922, test.Person@4e25154f]

如果对象的名字相同，就以年龄进行排序。这个如何写

public class Test  {

	public static void main(String[] args) {
		

	Person[] per= {new Person("lily",20),new Person("andy",32),new Person("andy",21)};
		System.out.println("排序前"+Arrays.toString(per));
		Arrays.sort(per);
		System.out.println("排序后"+Arrays.toString(per));
	}
	}	
	

class Person  implements Comparable<Person>{
	String name;
	int age;
	

	public Person(String name,int age) {
	
		this.name = name;
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public int compareTo(Person o) {
		
		int flag= this.name.compareTo(o.name);// 因为string本身就有这个方法，我们直接使用字符串compareto方法
		if(flag==0) {
			
			if(this.age<o.age) {
				flag=-1;
			}else if (this.age>o.age) {
				flag=1;
			}
			
			return flag;
		}
		else{
			return flag;
			}
	}
}
//输出
排序前[test.Person@7852e922, test.Person@4e25154f, test.Person@70dea4e]
排序后[test.Person@70dea4e, test.Person@4e25154f, test.Person@7852e922]

但是这个会有一个问题，那就是如果对象没有实现comparable接口，在开发中我们可能根据要求无法修改对象类。同时使用的排序也就是使用一两次而已，那个时候就需要使用Comparator接口。

public class Test  {

	public static void main(String[] args) {
		

	Person[] per= {new Person("lily",20),new Person("andy",32),new Person("andy",21)};
		System.out.println("排序前"+Arrays.toString(per));
		Arrays.sort(per,new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {

				int flag= o1.name.compareTo(o2.name);// 因为string本身就有这个方法，我们直接使用字符串compareto方法
				if(flag==0) {
					
					if(o1.age<o2.age) {
						flag=-1;
					}else if (o1.age>o2.age) {
						flag=1;
					}
					
					return flag;
				}
				else{
					return flag;
					}
			}
		});
		System.out.println("排序后"+Arrays.toString(per));
	}
	}	
	

class Person  {
	String name;
	int age;
	

	public Person(String name,int age) {
	
		this.name = name;
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//输出
排序前[test.Person@7852e922, test.Person@4e25154f, test.Person@70dea4e]
排序后[test.Person@70dea4e, test.Person@4e25154f, test.Person@7852e922]

总结：

在使用arrays.sort()排序数组的时候，要不数组中的数据实现了comparable接口，要不就是在arrays.sort()方法中通过实现comparator接口内部类才可。
comparable与comparator区别
- comparable在创建类的时候会多次使用排序，所以需要实现comparable接口。
- 如果使用较少或者是使用较少而对象类不能修改的时候，可以考虑实现comparator接口的内部类进行排序。