集合排序Comparator和Comparable

傷城~ 2022-10-15 00:42 194阅读 0赞

### 1.Comparator ###

**理论整理：**  
1.Comparator接口位于java.util包下  
2.要在比较类外部实现接口  
3.在调用sort()方法时，要指定Comparator的实现类，比如我们Cat类进行比较，那么这里就是两个要比较的Cat类的对象，所以可以有一个单独的类实现Comparator  
**代码实现**

**比较类**

public class Cat {
        
            private String name;//名字
            private int month;//年龄
            private String specise;//品种
    
            //构造方法
            public Cat(String name, int month, String specise) {
        
                this.name = name;
                this.month = month;
                this.specise = specise;
            }
    
            public String getName() {
        
                return name;
            }
    
            public void setName(String name) {
        
                this.name = name;
            }
    
            public int getMonth() {
        
                return month;
            }
    
            public void setMonth(int month) {
        
                this.month = month;
            }
    
            public String getSpecise() {
        
                return specise;
            }
    
            public void setSpecise(String specise) {
        
                this.specise = specise;
            }
    
            @Override
            public String toString() {
        
                return "Cat{" +
                        "名字='" + name + '\'' +
                        ", 年龄=" + month +
                        ", 品种='" + specise + '\'' +
                        '}';
            }
    }

**接口类，这里有两个接口，按两种属性进行排序**

import java.util.Comparator;
    //按名字字母升序排序
    //这里需要注意，接口后面需加上泛型
    public class NameComparator implements Comparator<Cat> {
        
        @Override
        public int compare(Cat o1, Cat o2) {
        
            String Name1 = o1.getName();
            String Name2 = o2.getName();
            //先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推，直至得到最终结果或者其
            //Name1>Name2返回正整数，相等时返回0，<时返回负整数
            int n =Name1.compareTo(Name2);
            return n;
        }
    }

import java.util.Comparator;
    
    public class AgeComparator implements Comparator<Cat> {
        
        //按年龄降序排序
        @Override
        public int compare(Cat o1, Cat o2) {
        
            int age1 = o1.getMonth();
            int age2 = o2.getMonth();
            return age2-age1;
        }
    }

**测试类**

import java.util.*;
    
    public class CompartorText {
        
        public static void main(String[] args) {
        
            //创建三个猫对象
            Cat huahua = new Cat("aomi",5,"英国短毛猫");
            Cat aryary = new Cat("aimi",6,"三花猫");
            Cat wang = new Cat("aiai",3,"蓝猫");
            List<Cat> list = new ArrayList<Cat>();
            list.add(huahua);
            list.add(aryary);
            list.add(wang);
            System.out.println("未排序的顺序：");
            for(Cat n:list){
        
                System.out.println(n);
            }
            System.out.println("***********");
            System.out.println("按名字升序排序后的顺序为");
            //指定Comparator的实现类，按名字排序的类
            Collections.sort(list,new NameComparator());
            for(Cat n:list){
        
                System.out.println(n);
            }
            System.out.println("**********");
            System.out.println("按年龄降序排序");
            Collections.sort(list,new AgeComparator());
            for(Cat n:list){
        
                System.out.println(n);
            }
        }
    }

### 2.Comparable ###

**理论整理**  
1.位于java.lang包  
2.要在比较类上实现该接口  
3.调用sort方法只需指定集合名即可

**代码实例**

比较类

//比较类
    public class Goods implements Comparable<Goods> {
        
        private String id;
        private String name;
        private double price;
        //构造方法
        public Goods(String id,String name ,double price){
        
            this.id = id;
            this.name = name;
            this.price = price;
        }
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public double getPrice() {
        
            return price;
        }
    
        public void setPrice(double price) {
        
            this.price = price;
        }
    
        @Override
        public String toString() {
        
            return "商品编号："+id+",商品名字："+name+",商品价格:"+price;
        }
        //比较中实现该接口
        @Override
        public int compareTo(Goods o) {
        
            //按商品价格降序排序
            double price1 = this.price;
            double price2 = o.price;
            int n =new Double(price2-price1).intValue();
            return n;
        }
    }

**测试类**

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.List;
    
    //按商品价格降序排序
    public class GoodsText {
        
        public static void main(String[] args) {
        
            //创建商品对象
            Goods goods1 = new Goods("sooo1","冰箱",3000);
            Goods goods2 = new Goods("sooo2","电视",7000);
            Goods goods3 = new Goods("sooo3","电脑",4000);
            List list = new ArrayList();
            list.add(goods1);
            list.add(goods2);
            list.add(goods3);
            System.out.println("未排序前的顺序为：");
            Iterator<Goods> it = list.iterator();
            while (it.hasNext()){
        
                System.out.println(it.next());
            }
            System.out.println("排序后的顺序为：");
    
            Collections.sort(list);
            it= list.iterator();
            while (it.hasNext()){
        
                System.out.println(it.next());
            }
    
        }
    }

> 于应用场景  
> 一般情况下如果对某个类进行排序，比如Cat类，如果使用Comparable接口的方式，那么Cat类需要实现Comparable接口。  
> 如果Cat类通过Comparable接口的方式实现排序，比如通过name排序了。那么我们还希望通过age进行排序，这时不希望修改Cat类，那此时就需要使Comparator接口了  
> 因此，Comparable接口可以作为实现类的默认排序算法，Comparator接口则用于一个类的扩展排序