Java中Comparator接口和Comparable接口的使用

一般情况下在实现对对象元素的数组或集合进行排序的时候会用到Comparator和Comparable接口，通过在元素所在的类中实现这两个接口中的一个，然后对数组或集合调用Arrays.sort或者Collentions.sort方法即可实现对数组或集合的排序。就sort方法里面的参数来说，实现了不同的接口则传递的参数也不尽相同。对于实现了Comparator接口的类来说，sort方法需要接受的参数不仅包括数组或集合，还要包括实现了该接口的类对象；而对实现了Comparable接口的类来说，参数不仅包括数组或者集合，还要包括实现了该接口的类对象。具体怎么区别呢，其实很简单，因为看两个接口所实现的方法就知道，Comparator定义的方法为compare(Object o1, Object o2)，方法涉及两个类对象，所以需要在另外一个新的类来实现对数组元素的比较，所以在调用sort方法时需要传递这个额外的实现了Comparator接口的类对象；而实现了Comparable接口的类实在元素类的内部实现了排序的逻辑，所以调用sort方法时不需要传递额外的类对象。废话少说，直接上代码。

1.通过实现Comparator接口来实现对数组或集合的比较

class SortCat implements Comparator<Cat1>
{
    @Override
    public int compare(Cat1 o1, Cat1 o2)//实现了Comparator接口的compare方法
    {
        // TODO Auto-generated method stub
        int size1=o1.getSize(),size2=o2.getSize();
        if(size1!=size2)
            return size1-size2;
        return o1.getColor().compareTo(o2.getColor());
    }
}
class Cat1
{
    private String color;
    private int size;
    public  Cat1(String color,int size)
    {
        this.color=color;
        this.size=size;
    }
    public int getSize()
    {
        return size;
    }
    public String getColor()
    {
        return color;
    }
    public String toString()
    {
        return color+" cat,size = "+size;
    }

}
public class HashMapComparatorDemo
{

    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        String colorArr[]={"black","yellow","white","colorful","gray","brown","blue","orange"};
        int catSizeArr[]={5,3,7,9,6,4,1,8,2};
        Random random=new Random();
        Cat1 catArr[]=new Cat1[10];
        int sizeIndex=0,colorIndex=0;
        for(int i=0;i<10;i++)
        {
            sizeIndex=random.nextInt(catSizeArr.length);
            colorIndex=random.nextInt(colorArr.length);
            catArr[i]=new Cat1(colorArr[colorIndex], catSizeArr[sizeIndex]);
            System.out.println("Color:"+catArr[i].getColor()+",size:"+catArr[i].getSize());
        }
        System.out.println("\nAfter change the order....\n");
        Arrays.sort(catArr,new SortCat());//不仅要传递数组参数，还要传递实现了Comparator接口的类对象
        for(Cat1 cat:catArr)
            System.out.println("Color:"+cat.getColor()+",size:"+cat.getSize());

    }

}

结果：

Color:white,size:4
Color:colorful,size:4
Color:colorful,size:4
Color:gray,size:5
Color:yellow,size:7
Color:orange,size:6
Color:black,size:2
Color:colorful,size:8
Color:black,size:3
Color:yellow,size:2

After change the order....

Color:black,size:2
Color:yellow,size:2
Color:black,size:3
Color:colorful,size:4
Color:colorful,size:4
Color:white,size:4
Color:gray,size:5
Color:orange,size:6
Color:yellow,size:7
Color:colorful,size:8

2.通过实现Comparable接口来实现对数组或集合的比较

class Cat2  implements Comparable<Cat2>
{
    private String color;
    private int size;
    public  Cat2(String color,int size)
    {
        this.color=color;
        this.size=size;
    }
    public int getSize()
    {
        return size;
    }
    public String getColor()
    {
        return color;
    }
    public String toString()
    {
        return color+" cat,size = "+size;
    }
    @Override
    public int compareTo(Cat2 o)//在元素类里面实现comparable接口所定义的方法
    {
        // TODO Auto-generated method stub
        int size=o.getSize();
        if(this.size!=size)
            return this.size-size;
        return this.color.compareTo(o.getColor());
    }

}
public class HashMapComparatorDemo2
{

    public static void main(String[] args)
    {
        String colorArr[]={"black","yellow","white","colorful","gray","brown","blue","orange"};
        int catSizeArr[]={5,3,7,9,6,4,1,8,2};
        Random random=new Random();
        Cat2 catArr[]=new Cat2[10];
        int sizeIndex=0,colorIndex=0;
        for(int i=0;i<10;i++)
        {
            sizeIndex=random.nextInt(catSizeArr.length);
            colorIndex=random.nextInt(colorArr.length);
            catArr[i]=new Cat2(colorArr[colorIndex], catSizeArr[sizeIndex]);
            System.out.println("Color:"+catArr[i].getColor()+",size:"+catArr[i].getSize());
        }
        System.out.println("\nAfter change the order....\n");
        Arrays.sort(catArr);//仅需要传递数组或集合即可
        for(Cat2 cat:catArr)
            System.out.println("Color:"+cat.getColor()+",size:"+cat.getSize());

    }

}

结果：

Color:gray,size:7
Color:orange,size:9
Color:gray,size:3
Color:brown,size:5
Color:orange,size:1
Color:gray,size:8
Color:colorful,size:9
Color:white,size:1
Color:blue,size:7
Color:brown,size:1

After change the order....

Color:brown,size:1
Color:orange,size:1
Color:white,size:1
Color:gray,size:3
Color:brown,size:5
Color:blue,size:7
Color:gray,size:7
Color:gray,size:8
Color:colorful,size:9
Color:orange,size:9

3.另外，还可以用实现了对Comparable接口treeMap、treeSet进行排序，具体应用范围很广，包括求一个无重复无序数组的前k项元素就可以用treeSet或treeMap很好滴实现，循环建tree并维持一个大小为k的treeSet或treeMap即可，超出范围的话先插入一个元素，然后删除排在最后的元素即可。下面这段代码仅仅实现的是有序建树并将treeMap输出出来的功能。

class Cat implements Comparable<Cat>
{
    private String color;
    private int size;
    public  Cat(String color,int size)
    {
        this.color=color;
        this.size=size;
    }
    public int getSize()
    {
        return size;
    }
    public String getColor()
    {
        return color;
    }
    @Override
    public int compareTo(Cat o)
    {
//      //优先根据颜色排序
//      String color1=o.getColor();
//      if(this.color.compareTo(color1)!=0)
//          return this.color.compareTo(color1);
//      return this.size-o.size;
        //优先根据大小排序
        int size=o.getSize();
        if(this.size!=size)
            return this.size-size;
        return this.color.compareTo(o.getColor());
    }
    public String toString()
    {
        return "Color:"+color+",size = "+size;
    }
}
public class HashMapComparableDemo
{

    public static void main(String[] args)
    {
        SortedMap<Cat, Integer>map=new TreeMap();
        String colorArr[]={"black","yellow","white","colorful","gray","brown","blue","orange"};
        int catSizeArr[]={5,3,7,9,6,4,1,8,2};
        Random random=new Random();
        int sizeIndex=0,colorIndex=0,count=0;;
        int mapSize=10;
        for(int i=0;i<mapSize;i++)
        {
            sizeIndex=random.nextInt(catSizeArr.length);
            colorIndex=random.nextInt(colorArr.length);
            count=random.nextInt(20)+5;
            map.put(new Cat(colorArr[colorIndex], catSizeArr[sizeIndex]), count);
        }
        Iterator<Entry<Cat, Integer>>iterator=map.entrySet().iterator();
        Entry<Cat, Integer>entry;
        while(iterator.hasNext())
        {
            entry=iterator.next();
            System.out.println(entry.getKey().toString()+",Count:"+entry.getValue().toString());
        }

    }

}

结果：

Color:black,size = 1,Count:15
Color:black,size = 2,Count:12
Color:gray,size = 2,Count:24
Color:brown,size = 5,Count:24
Color:gray,size = 5,Count:14
Color:brown,size = 6,Count:13
Color:white,size = 6,Count:7
Color:yellow,size = 6,Count:12
Color:gray,size = 7,Count:9
Color:brown,size = 8,Count:17

另外：对某些对象建立treeMap或hashMap的时候还需要重写一下equals方法，防止发生插入相同元素的情况，因为默认情况下treeMap或HashMap是应该是以对象的引用作为各个对象元素的标志，而不是元素的值。

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-13 20:46:47

Java中Comparator接口和Comparable接口的使用的相关文章

java中的类实现comparable接口 用于排序

import java.util.Arrays; public class SortApp { public static void main(String[] args) { Student[] stus = new Student[3]; stus[0] = new Student(11, 99); stus[1] = new Student(13, 92); stus[2] = new Student(13, 89); Arrays.sort(stus); for (Student stu

Java中Comparator接口

Comparator位于java.util包下 public interface Comparator<T> 强行对某个对象 collection 进行整体排序 的比较函数.可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制.还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序. 当且仅当对于一组

关于java中任意对象强制转换为接口类型的问题

java中任意对象强转为接口类型都不会有编译错误 public class Apple implements Eatable{ public static void main(String args[]) { Drinkable drinkable = (Drinkable)new Apple(); } } interface Eatable{} interface Drinkable{} java中的类可以多实现接口,Java编译器无法判断该类是否实现了该接口所以不会有编译错误. 但是Java

跟王老师学集合（十一）java中Comparator的用法

Java中Comparator的用法 主讲人:王少华  QQ群号:483773664 在java中,如果要对集合对象或数组对象进行排序,需要实现Comparator接口以达到我们想要的目标. 接下来我们模拟下在集合对象中对日期属性进行排序 一.实体类 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 package chapter07_11; public class Person {     private int a

使用Java中Comparator接口实现自定义排序

一般情况下,自己动手写一个简单排序程序还是没有问题的,但是你能保证写出来的排序程序的时间复杂度吗?你能保证程序的正确性吗,鲁棒性呢,还有程序结构的清晰性,可维护性.......综上所述,学习一下排序接口来实现对复杂对象的排序还是很有必要的.Java中有两个用来实现排序的接口Comparator和Comparable接口,本人比较喜欢使用java的Comparator接口,在程序里实现Comparator接口里的compare(Object o1,Object o2)方法,然后在程序中通过调用Ar

关于comparator接口和comparable接口以及它们各自的方法compare()和compareTo()

在今天做的LeetCode的题中有两道都出现了利用接口实现对象的排序,两题的相关链接: 1.利用comparable接口对对象排序 2.利用comparator接口实现排序 由于之前都没接触过这两个接口,一时不能明白它们的作用,所以在网上查找了很多资料,现在大致弄清楚一些,现在记录下来,有什么欠缺,欢迎大家及时指正 1.Comparable<T>接口 在java API文档中描述此接口是强行将实现它的每一个类的对象进行整体排序-----称为该类的自然排序,实现此接口的对象列表和数组可以用Col

java中Comparator 和 Comparable的区别

1.Comparable的代码如下: public interface Comparable<T> { public int compareTo(T o); } 2.Comparator的代码如下 public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); // jdk1.8 后的方法 default Comparator<T> reversed() { re

comparator接口与Comparable接口的区别

1. Comparator 和 Comparable 相同的地方 他们都是java的一个接口, 并且是用来对自定义的class比较大小的, 什么是自定义class: 如 public class Person{ String name; int age }. 当我们有这么一个personList,里面包含了person1, person2, persion3....., 我们用Collections.sort( personList ), 是得不到预期的结果的. 这时肯定有人要问, 那为什么可以

SunnyAmy comparator接口与Comparable接口的区别

1. Comparator 和 Comparable 相同的地方 他们都是java的一个接口, 并且是用来对自定义的class比较大小的, 什么是自定义class: 如 public class Person{ String name; int age }. 当我们有这么一个personList,里面包含了person1, person2, persion3....., 我们用Collections.sort( personList ), 是得不到预期的结果的. 这时肯定有人要问, 那为什么可以