比较器Comparable和Comparator

时间  2019-12-12
标签 比较器 comparable comparator 繁體版
原文   原文链接

  1. 做用java

  2. 区别数组

  3. Comparable使用ide

  4. Comparator的使用函数

  5. 总结测试

  • 做用

             Java的Comparable和Comparator当须要排序的集合或数组不是单纯的数字类型时，一般可使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。this

  • 区别

1、Comparable 
           强行对实现它的每一个类的对象进行总体排序，实现此接口的对象列表（和数组）能够经过Collections.sort或Arrays.sort进行自动排序。Comparable是一个内比较器，实现了Comparable接口。是能够和本身比较的。Comparable接口的类的比较，则依赖compareTo方法来实现，compareTo方法也被称为天然比较方法。若是add一个Collection的对象想时想要Collections的sort方自动进行排序的话，那么这个对象必须实现Comparable接口，并重写compareTo方法。compareTo方法有一个参数，返回值是int，有三种状况：spa

          一、新添加进来的对象实例大于已经存在的对象时，返回正整数 1 。表示不一样的实例对象，添加至已存在对象的后面。code

          二、新添加进来的对象实例等于已经存在的对象时，返回 0。表示重复对象实例，则不被添加。对象

          三、新添加进来的对象实例小于已经存在的对象时，返回负整数 -1。表示不一样的实例对象，添加至已存在对象的前面。排序

2、Comparator  

           强行对某个对象collection进行总体排序的比较函数，能够将Comparator传递给Collections.sort或Arrays.sort。Comparator是一个外比较器，它的比较则是经过重写compare方法来实现的。方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象,o1表示要添加的新的对象实例，o2表示已经添加进来的对象实例，返回值也是int,分三种状况：

          一、o1大于o2，返回正整数 1 。表示不一样的实例对象，添加至已存在对象的后面。

          二、o1等于o2，返回 0。表示重复对象实例，则不被添加。

          三、o1小于o3，返回负整数 -1。表示不一样的实例对象，添加至已存在对象的前面。

  • Comparable的使用

         定义一个类，并实现Comparable接口，重写compareTo方法，根据返回值编写本身的比较规则。

具体代码实现：

package com.vince;

public class Animal1 implements Comparable<Animal1>{
    private String name;
    private String color;
    private Float weight;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Float getWeight() {
        return weight;
    }
    public void setWeight(Float weight) {
        this.weight = weight;
    }
    public Animal1(String name, String color, Float weight) {
        super();
        this.name = name;
        this.color = color;
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "名字：" + name + "\t颜色：" + color + "\t体重：" + weight;
    }

//按照体重对动物升序排列
    @Override
    public int compareTo(Animal1 o) {
        // 判断对象是否为空，为空则不添加
        if(o == null) {
            return 0;
        }
        if(this.weight >= o.getWeight()) {
            return 1;// 对象不为空，若是体重大的则排到后面
        }else {
            return -1;// 对象不为空，若是体重小的则排到前面
        }
    }    
}

 

package test;
import java.util.Set;
import java.util.TreeSet;
import com.vince.Animal1;
public class Test2 {
    public static void main(String[] args) {
        // TODO
        Set<Animal1> animals = new TreeSet<>();
        animals.add(new Animal1("Monkey", "black", 90f));
        animals.add(new Animal1("Duck", "yellow", 5f));
        animals.add(new Animal1("Chicken", "white", 7f));
        animals.add(new Animal1("Goldfish", "golden", 2f));
        animals.add(new Animal1("Elephant", "gray", 250f));
        System.out.println("内部比较器升序排序后的结果为：");
        for (Animal1 animal : animals) {
            System.out.println(animal);
        }
    }
}

 

  • Comparator的使用

        匿名的方式实现Comparator：在建立一个类时，不直接在类当中去实现，而是在测试类中采用匿名内部类的方式，直接建立一个Comparator来实现comparable方法。

具体代码实现：

package com.vince;

public class Animal2 {
    private String name;
    private String color;
    private Float weight;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Float getWeight() {
        return weight;
    }

    public void setWeight(Float weight) {
        this.weight = weight;
    }

    public Animal2(String name, String color, Float weight) {
        super();
        this.name = name;
        this.color = color;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "名字：" + name + "\t颜色：" + color + "\t体重：" + weight;
    }
}
package test;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
import com.vince.Animal2;

public class Test3 {

    public static void main(String[] args) {
        // 匿名内部类的方式实现比较器降序排序
        Set<Animal2> animal2s = new TreeSet<Animal2>(new Comparator<Animal2>() {
            @Override
            public int compare(Animal2 o1, Animal2 o2) {
                // 若是对象都为空则不添加 
                if(o1 == null || o2 == null) {
                    return 0;
                }
                if(o1.getWeight() >= o2.getWeight()) {
                    return -1;//体重大的放前面
                }else {
                    return 1;//体重小的放前面
                }
            }
        });
        animal2s.add(new Animal2("Monkey", "black", 90f));
        animal2s.add(new Animal2("Duck", "yellow", 5f));
        animal2s.add(new Animal2("Chicken", "white", 7f));
        animal2s.add(new Animal2("Goldfish", "golden", 2f));
        animal2s.add(new Animal2("Elephant", "gray", 250f));
        System.out.println("外部比较器降序排列后的结果为：");
        for (Animal2 animal : animal2s) {
            System.out.println(animal);
        }       
    }

}

        自定义比较器Comparator：另外建立一个比较器类直接在类里面实现compare方法，在测试类直接new一个Comparator。

具体代码实现：

package com.vince;

public class Student {
        private Integer classNumber;
        private String name;
        private char sex;
        private Integer age;

        public Integer getClassNumber() {
            return classNumber;
        }
        public String getName() {
            return name;
        }
        public char getSex() {
            return sex;
        }
        public Integer getAge() {
            return age;
        }
        public Student(Integer classNumber, String name, char sex, Integer age) {
            super();
            this.classNumber = classNumber;
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
        @Override
        public String toString() {
            return "班级编号：" + getClassNumber() + "\t姓名：" + getName() + "\t性别：" + sex + "\t年龄：" + age;
        }
}

 

package comparator;

import java.util.Comparator;

import com.vince.Student;

public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        // TODO 
        if(o1.getAge() == o2.getAge()) {
            return 0;
        }
        if(o1.getAge() >= o2.getAge()) {
            return 1;
        }else {
            return -1;
        }
    }
}

 

package test;

import java.util.TreeSet;

import com.vince.Student;

import comparator.StudentComparator;

public class Test4 {
    public static void main(String[] args) {
        
        TreeSet<Student> treeSet = new TreeSet<>(new StudentComparator());
        treeSet.add(new Student(1,"小明",'男',22));
        treeSet.add(new Student(5,"小白",'男',20));
        treeSet.add(new Student(3,"木子",'女',45));
        treeSet.add(new Student(3,"木子",'女',45));
        treeSet.add(new Student(7,"小绿",'女',32));
        treeSet.add(new Student(1,"小明",'男',22));
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

 

  • 总结： 

        比较器是把集合或数组的元素强行按照指定方法进行排序的对象，它是实现了Comparator接口类的实例。若是一个集合元素是可比较的（实现了Comparable接口），那么就具备了默认排序方法，比较器则是强行改变它默认的比较方式来进行排序。或者有的集合元素不可比较（没有实现Comparable接口），则可用比较器来实现动态的排序。

        相同点：Comparable和Comparator能够按照指定方法，对对象实现动态的排序。他们实现排序的方法的返回值都是int类型，分为三种状况：一、0和-1。

        不一样点：Comparable的排序依赖的是compareTo方法，且参数只有一个。Comparator的排序依赖的是compare，传入参数有两个，能够经过匿名内部类或者单独实现。Comparator接口通常不会被集合元素类所实现，而是单独实现或者匿名内部类方式实现。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程