亲宝软件园·资讯

展开

Java集合之Comparable和Comparator接口详解

从未止步.. 人气:0

java提供了Comparable接口与Compatator接口,它们为数组或集合中的元素提供了排序逻辑,实现此接口的对象数组或集合可以通过Arrays.sort或Collections.sort进行自动排序

Comparable接口

一个类实现了Comparable接口,则表明这个类对象之间是可以互相比较的,这个类对象组成的集合元素就可以直接使用sort()方法进行排序, 假设“有一个List列表(或数组),里面的元素是实现了Comparable接口的类”则该List列表(或数组)可以通过 Collections.sort(或 Arrays.sort)进行排序

类A实现接口Comparable,并实现compareTo()方法

调用Collections.sort(lists)即可实现排序

该接口定义了compareTo方法:

int compareTo(T obj);//将当前对象与参数obj进行比较

//如果当前对象this>形参对象obj,则返回正整数

//如果当前对象this<形参对象obj,则返回负整数

//如果当前对象this=参数对象obj,则返回0

Comparable接口简单应用

自定义person类:

实现将数据封装成对象,以及不同对象之间的排序算法。

package Collections;
import java.util.Comparator;
//若一个类实现了Comparable接口,就意味着“该类支持排序”
public class person implements java.lang.Comparable<person> {
    String name;
    int age;
    String sex;
    String city;

    public person(String name, int age, String sex, String city) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.city = city;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", city='" + city + '\'' +
                '}';
    }

    @Override
    public int compareTo(person person) {//排序规则-----属性值的比较顺序:先年龄再名字再城市
        if (this.age > person.age)
            return 1;
        else if (this.age < person.age)
            return -1;
        else {
            if (this.name.compareTo(person.name) > 0)
                return 1;
            else if (this.name.compareTo(person.name) < 0)
                return -1;
            else
                return this.city.compareTo(person.city);
        }
    }
}

注意:调用toArray()方法返回的数组是新生成的一个数组,多次运行toArray()方法会获得不同的数组对象,但这些数组对象中内容一样的,toArray()返回的数组是安全的,可以对它进行任意的修改,其原因就是List不会维持一个对该返回的数组的引用

测试类:

package Collections;
import java.util.*;
public class Comparable {
    public static void main(String[]args){
        List<person> personList=new ArrayList<>();
        personList.add(new person("王俊凯",24,"男","重庆"));
        personList.add(new person("王源",23,"男","重庆"));
        personList.add(new person("易烊千玺",23,"男","湖南"));
        System.out.println("排序之前,集合中的元素有:");
        for(int i=0;i<personList.size();i++){
            System.out.println(personList.get(i));
        }
        //toArray()方法会返回List中所有元素构成的数组,并且数组类型是Object[]
        Object[] objects=personList.toArray();
        Arrays.sort(objects);//对一个数组的所有元素进行排序,并且是按从小到大的顺序
        System.out.println("排序之后,数组中的元素是:");
        for(int i=0;i<personList.size();i++){
            System.out.println(objects[i]);
        }
        System.out.println("--------------------");
        Collections.sort(personList);
        System.out.println("排序之后,集合中的元素是:");
        for(int i=0;i<personList.size();i++){
            System.out.println(personList.get(i));
        }
    }
}

输出:

排序之前,集合中的元素有:
person{name='王俊凯', age=24, sex='男', city='重庆'}
person{name='王源', age=23, sex='男', city='重庆'}
person{name='易烊千玺', age=23, sex='男', city='湖南'}
排序之后,数组中的元素是:
person{name='易烊千玺', age=23, sex='男', city='湖南'}
person{name='王源', age=23, sex='男', city='重庆'}
person{name='王俊凯', age=24, sex='男', city='重庆'}
--------------------
排序之后,集合中的元素是:
person{name='易烊千玺', age=23, sex='男', city='湖南'}
person{name='王源', age=23, sex='男', city='重庆'}
person{name='王俊凯', age=24, sex='男', city='重庆'}

Comparator接口

Comparator接口定义了如下方法:

int Compare(T o1,T o2);
// 如果方法返回正整数,则表示o1>o2;
//如果返回0,表示相等
//如果返回负整数,表示o1<o2

Comparator接口可以看成一种对象比较算法的实现,它将算法和数据分离,Comparator接口常用于以下两种环境:

1:开发人员在进行类的设计时没有考虑到比较问题,因而没有实现Comparable接口,

可以通过Comparator比较算法来实现排序而不必改变对象本身

2:对象排序时要用多种排序标准,如升序,降序等,

只要在执行sort()方法时用不同的Comparator比较,算法就可以适应变化。

Comparator接口简单应用

自定义person类:

实现将数据封装成对象。

package Collections;
import java.util.Comparator;
public class person{
    String name;
    int age;
    String sex;
    String city;

    public person(String name, int age, String sex, String city) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.city = city;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

Sorted类实现不同对象排序算法:

package Collections;

import java.util.Comparator;

public class Sorted implements Comparator<person> {
    @Override
    public int compare(person o1, person o2) {
        if (o1.getAge() > o2.getAge())
            return 1;
        else if (o1.getAge() < o2.getAge())
            return -1;
        else {
            if (o1.getName().compareTo(o2.getName()) > 0)
                return 1;
            else if (o1.getName().compareTo(o2.getName()) < 0)
                return -1;
            else
                return o1.getCity().compareTo(o2.getCity());
        }
    }
}

测试类:

package Collections;
import java.util.*;
public class Comparable {
    public static void main(String[]args){
        List<person> personList=new ArrayList<>();
        personList.add(new person("王俊凯",24,"男","重庆"));
        personList.add(new person("王源",23,"男","重庆"));
        personList.add(new person("易烊千玺",23,"男","湖南"));
        System.out.println("排序之前,集合中的元素有:");
        for(int i=0;i<personList.size();i++){
            System.out.println(personList.get(i));
        }
        System.out.println("--------------------");
        Collections.sort(personList,new Sorted());
        System.out.println("排序之后,集合中的元素是:");
        for(int i=0;i<personList.size();i++){
            System.out.println(personList.get(i));
        }
    }
}

输出:

排序之前,集合中的元素有:
person{name='王俊凯', age=24, sex='男', city='重庆'}
person{name='王源', age=23, sex='男', city='重庆'}
person{name='易烊千玺', age=23, sex='男', city='湖南'}
--------------------
排序之后,集合中的元素是:
person{name='易烊千玺', age=23, sex='男', city='湖南'}
person{name='王源', age=23, sex='男', city='重庆'}
person{name='王俊凯', age=24, sex='男', city='重庆'}

Comparator接口 VS Comparable接口

相同点:

不同点:

1:comparable 在java.lang包下,comparator在java.util包下

2:comparable接口实现该类接口不需要重新创建一个排序的类,只需要重写compareTo(T o)方法,而comparator接口实现该类接口需要重新创建一个排序的类,而且需要重写compare(T o1,T o2)方法

3:Comparator与Comparable同时存在的情况下,比较器Comparator优先级高

4:comparable 在类定义时已经实现,表明这个类具备排序的功能,而comparator是在类没有实现comparable接口或对实现的排序不能满足需求时在类的外部实现

总结

由于Comparator将算法和数据分离,因此comparator更加灵活,它可以定义某个类的多个比较器,从而在排序时根据实际场景自由调用,而Comparable接口的算法和数据在同一个类中,因此实现后便不能改动,并且使用Comparable需要修改原先的实体类,而Comparator 不用修改原先的类直接去实现一个新的比较器 ,因此Comparator实际应用更加广泛

加载全部内容

相关教程
猜你喜欢
用户评论