comparetor（Java中Comparator接口的用法）

本文目录

• Java中Comparator接口的用法
• comparable和comparative的区别comparable和comparator
• java Comparator中的返回值和排序有什么关系啊，求解释！！！！！
• java中comparable接口与comparator接口的区别，&&请求代码示例，非常谢谢
• Comparable和Comparator接口是干什么的它们的区别是什么
• java中Comparable和Comparator两种比较器的区别
• comparable和Comparator的区别
• Comparable 和 Comparator 有什么区别

Java中Comparator接口的用法

在java编程中，如果要对集合对象或数组对象进行排序，需要实现Comparator接口以达到目标，用法如下（模拟下在集合对象中对日期属性进行排序）：

一、实体类Step

package com.ljq.entity;
/**
 * 运号单流程
 * 
 * @author Administrator
 * 
 */
public class Step{
    /** 处理时间 */
    private String acceptTime = "";
    /** 快件所在地点 */
    private String acceptAddress = "";
    public Step() {
        super();
    }
    public Step(String acceptTime, String acceptAddress) {
        super();
        this.acceptTime = acceptTime;
        this.acceptAddress = acceptAddress;
    }
    public String getAcceptTime() {
        return acceptTime;
    }
    public void setAcceptTime(String acceptTime) {
        this.acceptTime = acceptTime;
    }
    public String getAcceptAddress() {
        return acceptAddress;
    }
    public void setAcceptAddress(String acceptAddress) {
        this.acceptAddress = acceptAddress;
    }
}

二、实现Comparator接口

package com.ljq.entity;
import java.util.Comparator;
import java.util.Date;
import com.ljq.util.UtilTool;
/**
 * 对Step类进行排序
 * 
 * @author Administrator
 *
 */
public class StepComparator implements Comparator《Step》{
    /**
     * 如果o1小于o2,返回一个负数;如果o1大于o2，返回一个正数;如果他们相等，则返回0;
     */
    @Override
    public int compare(Step o1, Step o2) {
        Date acceptTime1=UtilTool.strToDate(o1.getAcceptTime(), null);
        Date acceptTime2=UtilTool.strToDate(o2.getAcceptTime(), null);
        //对日期字段进行升序，如果欲降序可采用before方法
        if(acceptTime1.after(acceptTime2)) return 1;
        return -1;
    }
}

三、代码测试

package junit;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
public class StepComparatorTest {
    @Test
    public void sort() throws Exception{
        List《Step》 steps=new ArrayList《Step》;
        //对集合对象进行排序
         StepComparator comparator=new StepComparator();
        Collections.sort(steps, comparator);
        if(steps!=null&&steps.size()》0){
            for(Step step:steps){
               System.out.println(step.getAcceptAddress());
               System.out.println(step.getAcceptTime());
            }
        }
    }
}

comparable和comparative的区别comparable和comparator

　　侧重点不同：comparable表示可比性，comparative强调相对性。比较事物数量不同：comparable“可比较的”、“比得上的”，表示两者在某一点或几点上有相似之处，可以进行比较的。具体词性不同：comparable是形容词，意为“类似的；同等的”。comparative即是形容词，也是名词。作形容词时意为“比较的；相当的”，作名词时意为“比较级；对手”。
　　例句：TheAntarcticiscomparabletospace：It’sextremelycolddownthereandyouspendalotoftimeindoors。南极洲和太空有一定的可比性：那里千里冰封、万里雪飘，人们大部时间都躲在室内。
　　Thisisthelargestsuchdeficitsincecomparablerecordsbeganin1998。这是自1998年以来可比数据中逆差最大的一次。
　　Thisisyourcomparativeadvantage。这是你们的比较优势。Whydon’twedosomecomparativeadvertising？我们为什么不能做一些对比广告呢？

java Comparator中的返回值和排序有什么关系啊，求解释！！！！！

负数代表左值小于右值，排在上面
正数代表左值大于右值，排在下面
0代表左值等于右值，排在上面
可以这样理解：排序就是比较谁大谁小，将小的放在前面，大的放在后面。例如当返回负数的时候，表明第一个数应该排在第二个数的上面。

java中comparable接口与comparator接口的区别，&&请求代码示例，非常谢谢

数值用比较运算符》 《 ==等来比较大小，字符串用equals比较内容是否相等。但是对象怎么比较大小呢？用这两接口Comparator和Comparable
两者区别：
Comparator接口在java.util包下，用于提供比较的规则，常和Arrays.sort(对象数组，比较规则);或Collections.sort(集合，比较规则);搭配使用。前面的数组或集合按照后面的比较规则来排序。比较规则是Comparator接口类型的对象，可创建类实现该接口，重写compare方法，在方法体自定义比较规则，价格重量点击率都可以，对参数中传入的两个对象比较，根据返回值o1》o1默认升序排列
Comparable接口在java.lang包下，实现compareTo方法对对象排序，该方法只有一个参数
public int compareTo(Object obj)
对象.obj ==0 对象==obj
对象.obj ==正数 对象》obj
对象.obj ==负数 对象《obj
综上所述：
Comparator常用于提供比较规则，需搭配使用
Comparable：要比较的对象直接实现该接口
例子：使用Comparator接口
package shwg.action;
import java.util.Arrays;
import java.util.Comparator;
//按字符串长度比较对象大小
public class Demo {
public static void main(String args) {
String names = {"Tom","Jerry","Andy","Lee"};
Arrays.sort(names, new ByLength());
System.out.println(Arrays.toString(names));
}
}
class ByLength implements Comparator《String》{
//只需两个随机对象o1 o2间比较，若compare方法返回正数，
// 会按升序排列（长度由小到大排）
public int compare(String o1, String o2) {
int r = o1.length() - o2.length();
if (r == 0) {
//若长度相等，根据字符串首字母大小比，加上符号是为了首字母按字典顺序排
return -(o1.charAt(0) - o2.charAt(0));
}
return r;
}
}
例子2：使用Comparable接口
package shwg.action;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
//注意：只要实现Comparable接口里面的compareTo方法，那么该方法会被自动调用
public class Name implements Comparable{
private String firstName, lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String toString() {return firstName + " " + lastName;}
//同一个类型的对象比较才有意义，可以用泛型《》约定
public int compareTo(Object o) {
Name a = (Name)o;
//lastName是String类型，已实现Comparable接口，可直接调compareTo方法
//比较时，从首字母往后一个个字母比ASCII值得大小排序
int lastCmp = lastName.compareTo(a.lastName);
//lastName相同比较firstName，将整型值返回
return lastCmp !=0 ? lastCmp : firstName.compareTo(a.firstName);
}
//测试
public static void main(String args) {
List l = new LinkedList();
l.add(new Name("Karl", "M"));
l.add(new Name("Steven", "Lee"));
l.add(new Name("Jhon", "O"));
Collections.sort(l);
System.out.println(l);
}
}
我一个一个字打的希望采纳，你可以拿去程序中运行比较。

Comparable和Comparator接口是干什么的它们的区别是什么

【答案】：Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。
Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

java中Comparable和Comparator两种比较器的区别

Comparable和Comparator接口都是为了对类进行比较，众所周知，诸如Integer，double等基本数据类型，java可以对他们进行比较，而对于类的比较，需要人工定义比较用到的字段比较逻辑。可以把Comparable理解为内部比较器，而Comparator是外部比较器，基本的写法如下：
class Apple implements Comparable《Apple》{
int id;
double price;
public Apple(int id, double price) {
this.id = id;
this.price = price;
}
public int compareTo(Apple o) {
//return Double.compare(this.getPrice(),o.getPrice());
if (Math.abs(this.price-o.price)《0.001)
return 0;
else
return (o.price-this.price)》0?1:-1;
}
@Override
public String toString() {
return "Apple{" +
"id=" + id +
", price=" + price +
’}’;
}
}
class AESComparator implements Comparator《Apple》{
public int compare(Apple o1, Apple o2) {
if (Math.abs(o1.price-o2.price)《0.001)
return 0;
else{
return (o1.price-o2.price)》0?1:-1;
}
}
}
实现了Comparable接口的类需要实现compareTo()方法，传入一个外部参数进行比对，实现了Comparator接口的方法需要实现compare()方法，对外部传入的两个类进行比较，从而让外部方法在比较时调用。
两者的区别是实现Comparator接口代码更加灵活，可以定义某个类的多个比较器，从而在排序时根据实际场景自由调用，而Comparable接口实现后便不能改动。两种接口的调用方式如下：
class AESComparator implements Comparator《Apple》{
public int compare(Apple o1, Apple o2) {
if (Math.abs(o1.price-o2.price)《0.001)
return 0;
else{
return (o1.price-o2.price)》0?1:-1;
}
}
}
class DESComparator implements Comparator《Apple》{
public int compare(Apple o1, Apple o2) {
if (Math.abs(o1.price-o2.price)《0.001)
return 0;
else {
return (o1.price-o2.price)》0?-1:1;
}
}
}
public static void main(String args) {
Apple apple1 = new Apple(1,4.8);
Apple apple2 = new Apple(2,5.9);
Apple apple3 = new Apple(3,8.5);
List《Apple》 list = new ArrayList《Apple》();
list.add(apple1);
list.add(apple3);
list.add(apple2);
System.out.println("Comparable==========");
System.out.printf("this list of apples: %s\n",list);
Collections.sort(list);
System.out.printf("this list of apples: %s\n",list);
System.out.println("Comparator==========");
System.out.printf("this list of apples: %s\n",list);
Collections.sort(list,new DESComparator());
System.out.printf("this list of apples: %s\n",list);
Collections.sort(list,new AESComparator());
System.out.printf("this list of apples: %s\n",list);
}
}
上述代码存在的问题，不能在比较器中进行double类型的减法操作，因为对于值比较大的double，减法操作容易导致值的溢出，java7对每一种包装类型的比较新增了compare()方法，改造后的代码如下：
class Apple implements Comparable《Apple》{
int id;
double price;
public Apple(int id, double price) {
this.id = id;
this.price = price;
}
public int compareTo(Apple o) {
return Double.compare(this.price,o.price);
}
@Override
public String toString() {
return "Apple{" +
"id=" + id +
", price=" + price +
’}’;
}
}
class AESComparator implements Comparator《Apple》{
public int compare(Apple o1, Apple o2) {
return Double.compare(o1.price,o2.price);
}
}
class DESComparator implements Comparator《Apple》{
public int compare(Apple o1, Apple o2) {
return Double.compare(o2.price,o1.price);
}
}
查看Double.compare的源码如下
public static int compare(double d1, double d2) {
if (d1 《 d2)
return -1; // Neither val is NaN, thisVal is smaller
if (d1 》 d2)
return 1; // Neither val is NaN, thisVal is larger
// Cannot use doubleToRawLongBits because of possibility of NaNs.
long thisBits = Double.doubleToLongBits(d1);
long anotherBits = Double.doubleToLongBits(d2);
return (thisBits == anotherBits ? 0 : // Values are equal
(thisBits 《 anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
1)); // (0.0, -0.0) or (NaN, !NaN)
}

comparable和Comparator的区别

comparable&Comparator都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如StringInteger自己就可以完成比较大小操作）
而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

Comparable 和 Comparator 有什么区别

区别：comparable是形容词，指可比较的；comparator是名词，指比较器、比较装置。联系：它们都是由动词compare（比较）派生出来的单词。