java list排序的两种方式（实现Comparable接口和Collections.sort重载方法）

最新推荐文章于 2024-03-28 12:36:07 发布

qq_31459039

最新推荐文章于 2024-03-28 12:36:07 发布

阅读量1.2k

点赞数 2

分类专栏： JAVA编程相关

JAVA编程相关专栏收录该内容

66 篇文章

订阅专栏

本文详细介绍了在Java中使用Collections.sort方法对List进行排序的两种主要方法：通过实现Comparable接口进行内部排序，以及利用Comparator接口进行外部排序。同时，对比了这两种方法的优缺点，并提供了示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载自：http://blog.youkuaiyun.com/zxy_snow/article/details/7232035

用Collections.sort方法对list排序有两种方法

第一种是list中的对象实现Comparable接口，Comparable可以认为是一个内比较器(排序接口)，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口,实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序 如下：

public class User implements Comparable<User>{
    private String name;
    private Integer order;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getOrder() {
        return order;
    }
    public void setOrder(Integer order) {
        this.order = order;
    }

    //根据多个字段排序
    @Override
    public int compareTo(User arg0) {
        //升序(大的在后面),this.getOrder()是右边的元素,arg0是左边的对象
        int i = this.getOrder().compareTo(arg0.getOrder());
        return i==0?this.getName().compareTo(arg0.getName()):i;
    }

    public static void main(String[] args){
        User user1 = new User();
        user1.setName("a");
        user1.setOrder(1);
        User user2 = new User();
        user2.setName("b");
        user2.setOrder(2);
        List<User> list = new ArrayList<>();
        //此处add user2再add user1
        list.add(user2);
        list.add(user1);
        Collections.sort(list);
        for(User u : list){
            System.out.println(u.getName());
        }
    }

}

第二种方法是根据Collections.sort重载方法来实现

Comparator可以认为是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：
1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较
2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式
Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int

/** 
 * 根据order对User排序 
*/  
public class User { //此处无需实现Comparable接口  
    private String name;  
     private Integer order;  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
     public Integer getOrder() {  
         return order;  
     }  
     public void setOrder(Integer order) {  
         this.order = order;  
     }

    @Override
    public String toString() {
        return "User{" + "name='" +name + '\'' + ",order=" + order + '}';
    }
        
    //主类中这样写即可(HastSet——>List——>sort进行排序)：  	
	public static void main(String[] args) {  
        User user1 = new User();  
        user1.setName("a");  
        user1.setPrice(11);  
        User user2 = new User();  
        user2.setName("b");  
        user2.setPrice(2);  
  
        Set<User> Hset = new HashSet<User>();  
        Hset.add(user2);  
        Hset.add(user1);  
  
        List<User> list = new ArrayList<User>();  
        list.addAll(Hset);  
  
  
        Collections.sort(list,new Comparator<User>(){  
            public int compare(User arg2, User arg1) {
                //arg2是右边的元素,arg1是左边的元素
                return arg2.getPrice().compareTo(arg1.getPrice());  
            }  
        });  
        System.err.println(list);
    } 
 
 }

总结

总结一下，两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法

2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator 接口的方式后面会写到就是一种典型的策略模式。

当然，这不是鼓励用Comparator，意思是开发者还是要在具体场景下选择最合适的那种比较器而已。

注意: TreeMap 允许value为null key不能为null 否则空指针

final int compare(Object k1, Object k2) {
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
            : comparator.compare((K)k1, (K)k2);
}

当两种比较器Comparable和Comparator共存时以Comparator排序优先!!! 以下是TreeMap 添加元素时源码

    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

//先看comparator外比较器是否存在 如果不存在则查看是否实现了Comparable接口 如果两者都没有 则会报实体类转换异常(java.lang.ClassCastException: cannot be cast to java.lang.Comparable)
 final int compare(Object k1, Object k2) {
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
            : comparator.compare((K)k1, (K)k2);
    }

以下转载至 https://blog.youkuaiyun.com/qq_29742677/article/details/84255720

在Collections.sort()的源码中有这样的一段代码：

       /**
         * var3.compare(var0[var4++], var0[var1]) 这个就是调用我们自定义的Compare方法，
         */
        if (var3.compare(var0[var4++], var0[var1]) >= 0) {
            /**
             * 如果返回值 >=0 , 并不会做任何有关排序的处理
             */
            while(var4 < var2 && var3.compare(var0[var4], var0[var4 - 1]) >= 0) {
                ++var4;
            }
        } else {
            /**
             * 如果返回值 < 0 , 会执行——reverseRange(var0, var1, var4)交换顺序
             */
            while(var4 < var2 && var3.compare(var0[var4], var0[var4 - 1]) < 0) {
                ++var4;
            }
            reverseRange(var0, var1, var4);
        }

结论

当compare的返回值小于0时，会将 t2 和 t1 （compare()中的两个参数）交换顺序，大于等于0不会变换顺序；

可根据具体的排序需求来决定是否让他们交换顺序