java spark 实现value排序 java compare排序

目录

• 一、内置引用类型比较

• 1.实现Comparable接口，重写compareTo方法
• 2.自定义排序类，实现Comparator接口，重写compare方法

• 二、自定义引用类型

• 1.实现Comparable接口，重写compareTo方法
• 2.自定义排序类，实现Comparator接口，重写compare方法

• 三、比较

一、内置引用类型比较

1.实现Comparable接口，重写compareTo方法

(1) 先以Integer的源码为例，可以看出两个数进行比较时，先是调用compareTo方法，再跳到compare中去比较两个数的大小，返回值有三种，分别为-1,0,1。

(2)再以String类的源码为例，这里的排序规则在CompareTo方法中完成的。

总结：

1. Integer、Float、Double等直接比较基本数据类型的大小。
     2. Character会比较unicode码之差。
     3. 字符串比较，如果其中一个字符串是另一个字符串开始的子串，那么会返回两个字符串长度之差；
        否则，返回第一个不相等字符的unique码之差。
     4.Date类型比较会根据长整数型进行比较。

2.自定义排序类，实现Comparator接口，重写compare方法

(1) 我们先使用jdk中自带的排序工具Collections.sort(List list)方法，测试list集合进行排序后的情况

代码：

实验结果：

(2)我们自定义排序类，排序规则如下，正好和Integer中的排序逻辑相反(如果忘记可以上文中图片)

此时，我们使用Collections.sort(List list, Comparator<? super T> c)方法，对集合进行排序。

代码：

实验结果：

二、自定义引用类型

1.实现Comparable接口，重写compareTo方法

自定义引用类型-淘宝商品的代码如下：

import java.util.Date;

/**
 * 淘宝商品
 */
public class Item implements Comparable<Item> {
    private int sales;      //销量
    private double price;   //价格
    private Date  date;     //上架时间

    @Override
    public int compareTo(Item o) {
        //定义如下排序规则
        //首先根据销量从大到小排序，再根据上架时间从最新到最旧排序，最后根据价格从低到高排序
        if (this.sales > o.sales)
            return 1;
        else if(this.sales == o.sales){
            if (this.date.compareTo(o.date) > 0)
                return 1;
            else if (this.date == o.date){
                if (this.price > o.price)
                    return -1;
                else if (this.price == o.price)
                    return 0;
                else
                    return 1;
            }
            else
                return -1;
        }
        else
            return -1;
    }

    public int getSales() {
        return sales;
    }

    public void setSales(int sales) {
        this.sales = sales;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public Item(int sales, double price, Date date) {
        this.sales = sales;
        this.price = price;
        this.date = date;
    }

    @Override
    public String toString() {
        return "商品的详细信息如下：" +
                "销量;" + sales +
                ", 价格:" + price +
                ", 上架时间；" + date;
    }
}

代码：

实验结果：

2.自定义排序类，实现Comparator接口，重写compare方法

import java.util.Comparator;

public class RedefinedSort implements Comparator<Item> {
    @Override
    public int compare(Item o1, Item o2) {
        //定义如下排序规则
        //首先根据销量从大到小排序，再根据上架时间从最新到最旧排序，最后根据价格从低到高排序
        if (o1.getSales() > o2.getSales())
            return 1;
        else if(o1.getSales() == o2.getSales()){
            if (o1.getDate().compareTo(o2.getDate()) > 0)
                return 1;
            else if (o1.getDate() == o2.getDate()){
                if (o1.getPrice() > o2.getPrice())
                    return -1;
                else if (o1.getPrice() == o2.getPrice())
                    return 0;
                else
                    return 1;
            }
            else
                return -1;
        }
        else
            return -1;
    }
}

代码：

实验结果与上一个相同。

三、比较

Comparator相比于Comparable的优势

1. 解耦：独立于实体类，新定义完成排序规则
2. 灵活：应对各种排序规则