使用Comparable/Comparator，匿名内部类以及lambda表达式进行排序

Comparable/Comparator以及lambda表达式

继承Comparable接口进行排序

这两个接口是为了和类比较大小的

class Goods implements Comparable<Goods> {
    //实现Comparable接口必须要进行ComparaTo方法重写
    
    private String name;//商品名称
    private double price;//商品价格

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

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

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override //指定规则
    public int compareTo(Goods o) {
       1. //字符串用comparaTo(String自带方法)
        //return this.name.compareTo(o.name);(如果字符串首字母有A，就进行排序)
        2.//是哪一种类型，就用哪一种类型的封装类
        //return Double.compare(this.price,o.price);
           
        3.//用比较进行排序，如果this>o，返回1则为升序
        if (this.price > o.price) {
            return 1;
        } else if (this.price == o.price) {
            return 0;
        } else {
            return -1;
        }
    }
}

public class TestAAA {
        public static void main(String[] args) {
            Goods[] arr = new Goods[4];
            arr[0] = new Goods("红楼梦D", 40);
            arr[1] = new Goods("西游记B", 20);
            arr[2] = new Goods("三国A", 60);
            arr[3] = new Goods("水浒C", 10);

            Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        }
}

Comparator接口的3种排序方法

Comparator是对ComparaTo方法内的比较算法不满意，自己在重新定义排序，

一般实现在一个新的类中，然后在排序Sort时，进行new 新类(Arrays.Sort(arr, new narr))

class Sot implements Comparator<Goods> {

    @Override
    public int compare(Goods o1, Goods o2) {
        //如果需要倒叙，给Doule前面加负号
        return -Double.compare(o1.getPrice(), o2.getPrice());
    }
}

public class TestAAA {
        public static void main(String[] args) {
            Goods[] arr = new Goods[4];
            arr[0] = new Goods("红楼梦D", 40);
            arr[1] = new Goods("西游记B", 20);
            arr[2] = new Goods("三国A", 60);
            arr[3] = new Goods("水浒C", 10);

            1.//新new一个类进行排序(Sot实现Comparator接口)
            Arrays.sort(arr, new Sot());
       
            2.//使用匿名内部类
              //和匿名对象一样，通常使用在只使用一次的时候，方便、简单
           Arrays.sort(arr, new Comparator<Goods>() {
                @Override
                public int compare(Goods o1, Goods o2) {
              	return Double.compare(o1.getPrice(), o2.getPrice());
                    	//o1.compareTo(o2);(默认排序ABCD)
                }
            });     
            
            3.lambda表达式
                            Arrays.sort(arr, (o1, o2) -> {
            return o1.getName().compareTo(o2.getName());
                                
//            return o1.compareTo(o2);(因为Goods实现了Comparable)
//            return Double.compare(o1.getPrice(),o2.getPrice());
//            if (o1.getPrice() > o2.getPrice()){
//                return 1;
//            }else if (o1.getPrice() == o2.getPrice()){
//                return 0;
//            }else {
//                return -1;
//            }
//        });
        }
}

创建一个类实现comparator

定义排序规则

//不能改源码的情况下，使用comparator(传入数组和实现类)

3种实现：直接o1比o2（comparaTo）comparable的

2String:o1.comparaTo

3Double.compare(int x, int y)

4手动比较进行排序