`

Collections.sort Comparator排序

 
阅读更多

 

【转】java List 排序 Collections.sort



java List 排序 Collections.sort


用Collections.sort方法对list排序有两种方法 
第一种是list中的对象实现Comparable接口，如下： 

代码: Java代码

  1. /** 
  2. * 根据order对User排序 
  3. */   
  4. public class User implements Comparable<User>{    
  5.     private String name;    
  6.     private Integer order;    
  7.     public String getName() {    
  8.         return name;    
  9.      }    
  10.     public void setName(String name) {    
  11.         this.name = name;    
  12.      }    
  13.     public Integer getOrder() {    
  14.         return order;    
  15.      }    
  16.     public void setOrder(Integer order) {    
  17.         this.order = order;    
  18.      }    
  19.     public int compareTo(User arg0) {    
  20.         return this.getOrder().compareTo(arg0.getOrder());    
  21.      }    
  22. }    
  23.    
  24.    
  25.    
  26. public class Test{    
  27.     public static void main(String[] args) {    
  28.           User user1 = new User();    
  29.           user1.setName("a"); user1.setOrder(1);    
  30.           User user2 = new User(); user2.setName("b");    
  31.           user2.setOrder(2);    
  32.           List<User> list = new ArrayList<User>();    
  33.         //此处add user2再add user1    
  34.          list.add(user2); list.add(user1);    
  35.          Collections.sort(list);    
  36.         for(User u : list){    
  37.              System.out.println(u.getName());    
  38.          }    
  39.      }    
  40. }
复制代码

Java代码

  1. <span style="">/**  
  2. * 根据order对User排序  
  3. */   
  4. public class User implements Comparable<User>{   
  5.     private String name;   
  6.     private Integer order;   
  7.     public String getName() {   
  8.         return name;   
  9.     }   
  10.     public void setName(String name) {   
  11.         this.name = name;   
  12.     }   
  13.     public Integer getOrder() {   
  14.         return order;   
  15.     }   
  16.     public void setOrder(Integer order) {   
  17.         this.order = order;   
  18.     }   
  19.     public int compareTo(User arg0) {   
  20.         return this.getOrder().compareTo(arg0.getOrder());   
  21.     }   
  22. }   
  23.    
  24. public class Test{   
  25.     public static void main(String[] args) {   
  26.          User user1 = new User();   
  27.          user1.setName("a"); user1.setOrder(1);    
  28.          User user2 = new User(); user2.setName("b");   
  29.          user2.setOrder(2);    
  30.          List<User> list = new ArrayList<User>();    
  31.         //此处add user2再add user1    
  32.         list.add(user2); list.add(user1);    
  33.         Collections.sort(list);    
  34.         for(User u : list){    
  35.             System.out.println(u.getName());    
  36.         }    
  37.     }    
  38. }   
  39.    
  40. </span>   
复制代码

输出结果如下 
a 
b 
第二种方法是根据Collections.sort重载方法来实现，例如： 

代码: Java代码

  1. /** 
  2. * 根据order对User排序 */    
  3. public class User {    
  4. //此处无需实现Comparable接口    
  5.     private String name;    
  6.     private Integer order;    
  7.     public String getName() {    
  8.          return name;    
  9.      }    
  10.     public void setName(String name) {    
  11.         this.name = name;    
  12.      }    
  13.     public Integer getOrder() {    
  14.         return order;    
  15.      }    
  16.     public void setOrder(Integer order) {    
  17.        this.order = order;    
  18.      }    
  19. }    
  20.    
  21.    
  22.    
  23.    
  24. public class Test{    
  25.     public static void main(String[] args) {    
  26.         User user1 = new User();    
  27.         user1.setName("a");    
  28.         user1.setOrder(1);    
  29.         User user2 = new User();    
  30.         user2.setName("b");    
  31.         user2.setOrder(2);    
  32.         List<User> list = new ArrayList<User>();    
  33.         list.add(user2);    
  34.         list.add(user1);    
  35.         Collections.sort(list,new Comparator<User>(){    
  36.            public int compare(User arg0, User arg1) {    
  37.                return arg0.getOrder().compareTo(arg1.getOrder());    
  38.             }    
  39.         });    
  40.        for(User u : list){    
  41.            System.out.println(u.getName());    
  42.         }    
  43.      }    
  44. }   
复制代码

最简单的就是上面红色的字。。。。。。。。。。。 
默认为升序，将。return arg0.getOrder().compareTo(arg1.getOrder());    改为：

return arg1.getOrder().compareTo(arg0.getOrder());   

就成倒序的了。。

 

 

 


本文章为转载,在做对List排序的时候搜索的.
 

import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

class User {
 String name;
 String age;
 
 public User(String name,String age){
  this.name=name;
  this.age=age;
 }
 public String getAge() {
  return age;
 }
 public void setAge(String age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 } 
}

class ComparatorUser implements Comparator{

 public int compare(Object arg0, Object arg1) {
  User user0=(User)arg0;
  User user1=(User)arg1;
  //首先比较年龄，如果年龄相同，则比较名字

  int flag=user0.getAge().compareTo(user1.getAge());
  if(flag==0){
   return user0.getName().compareTo(user1.getName());
  }else{
   return flag;
  } 
 }
 
}

public class SortTest {

 
 public static void main(String[] args){
  List userlist=new ArrayList();
  userlist.add(new User("dd","4"));
  userlist.add(new User("aa","1"));
  userlist.add(new User("ee","5"));
  userlist.add(new User("bb","2")); 
  userlist.add(new User("ff","5"));
  userlist.add(new User("cc","3"));
  userlist.add(new User("gg","6"));
  
  ComparatorUser comparator=new ComparatorUser();
  Collections.sort(userlist, comparator);
   
  for (int i=0;i<userlist.size();i++){
   User user_temp=(User)userlist.get(i);
      System.out.println(user_temp.getAge()+","+user_temp.getName()); 
  }
  
 }
}

 //首先比较年龄，如果年龄相同，则比较名字


结果:
   1, aa
   2, bb
   3, cc
   4, dd
   5, ee
   5, ff
   6, gg
分享到：
| How do I open the GWT samples in eclipse ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java List 排序 Collections.sort

    如果需要自定义排序规则，可以提供一个`Comparator`实例给`Collections.sort()`方法。`Comparator`是一个接口，定义了`compare()`方法用于比较两个对象。例如，我们创建一个`ComparatorPerson`类来根据姓名排序： `...

    java中Collections.sort排序详解

    Java中Collections.sort排序详解 Java中的Collections.sort排序是Java.util....通过示例代码，展示了如何使用Collections.sort()方法对列表进行排序，并定义了一个Comparator接口的实现类来比较书籍的价格。

    Java Collections.sort()实现List排序的默认方法和自定义方法

    Java Collections.sort()实现List排序的默认方法和自定义方法 Java Collections.sort()是Java语言中用于对List进行排序的方法，通过使用这个方法可以对List进行默认排序，也可以根据需要实现自定义的排序规则。 ...

    java中Collections.sort排序函数用法详解

    `Collections.sort()` 可以根据元素的自然顺序或者自定义的比较器（Comparator）进行排序。 ### 1. 自然顺序排序 如果列表中的元素实现了 `Comparable` 接口，那么 `Collections.sort()` 会使用元素的自然顺序进行...

    Java Collections.sort()排序代码案例

    Java Collections.sort() 排序代码案例 ... Java Collections.sort() 排序代码案例可以对列表进行自然排序，也可以根据 Comparator 对象对列表进行自定义排序。该方法非常重要，广泛应用于实际开发中。

    JAVA对list集合进行排序Collections.sort()

    在Java编程语言中，`Collections.sort()` 方法是一个非常重要的工具，用于对List接口实现的集合进行排序。这个方法使得开发者能够方便地按照指定的顺序排列集合中的元素。本篇文章将详细探讨如何使用 `Collections....

    详解Java中Collections.sort排序

    `Collections.sort()`有两种主要的排序方式：一种是基于元素的自然顺序，另一种是通过自定义比较器`Comparator`。 首先，我们来详细讲解`Collections.sort()`的默认排序机制。当传入的列表元素实现了`Comparable`...

    详解java Collections.sort的两种用法

    Collections.sort 方法的第二个参数形式是 public static &lt;T&gt; void sort(List&lt;T&gt; list, Comparator&lt;? super T&gt; c)，该方法允许我们通过实现 Comparator 接口的 compare 方法来完成自定义排序。 下面是一个使用...

    用Java集合中的Collections.sort方法如何对list排序(两种方法)

    下面是使用Comparator排序的代码： ```java public class User { // No need to implement Comparable interface private String name; private Integer order; // getters and setters... } public class ...

    Comparator 排序器

    - 使用`Collections.sort()`方法对列表进行排序，传入相应的`Comparator`实例作为参数。 - 在本例中，我们使用`OrderName`对列表进行排序，然后使用`Collections.reverse()`方法对列表进行反转，以便按降序显示...

    listview按序排列显示

    在这个场景下，我们使用`Collections.sort()`函数对一个包含Map对象的List进行排序，然后将排序后的数据适配到ListView中。以下是关于这个主题的详细解释。 **一、Map与List的关系** 在Java中，Map是一种键值对的...

    JAVA中Collections工具类sort()排序方法

    在Java编程中，Collections工具类提供了许多方便的集合操作，其中`sort()`方法是一个非常重要的功能，用于对List类型的集合进行排序。本文将详细介绍`Collections.sort()`方法的两种使用方式及其示例。 ### 一、...

    程序实现时间排序Comparator

    在`main()`方法中，`ComparatorObject`实例被传递给`Collections.sort()`方法，后者使用这个比较器对列表进行排序。排序完成后，通过遍历列表打印出每个`Map`的“orderRole”和“dateorder”字段，以验证排序结果。 ...

    arrayList排序

    2. 自定义Comparator排序： 如果ArrayList中的元素是自定义类，并且没有实现Comparable接口，或者需要按照非自然顺序进行排序，可以创建一个Comparator实例，并作为`Collections.sort()`方法的参数。例如，假设有一...

    List对象集合的排序：比较器Comparator（简单例子）

    在`List`对象集合中使用`Comparator`进行排序，通常需要调用`Collections.sort()`或`list.sort()`方法。例如，假设我们有一个`Person`类，其中包含`name`和`age`属性，我们想要根据年龄对`Person`对象列表进行排序：...

    java 使用Collections类对List的排序操作

    2. **定制排序**：如果需要自定义排序规则，可以使用 `Collections.sort()` 方法并传入一个实现了 `Comparator` 接口的实例。`Comparator` 接口定义了 `compare()` 方法，用于指定比较逻辑。 ```java List&lt;Person&gt; ...

    Collections

    * `Collections.sort(List&lt;T&gt; list, Comparator&lt;? super T&gt; c)`: 对列表进行自定义排序。 线程安全操作 Collections 中的线程安全操作方法包括同步和不可变集合。这些方法用于保证集合的线程安全。 * `...

    Collections集合工具类排序.docx

    总的来说，Collections工具类的`sort()`方法是Java集合排序的核心，结合Comparable接口和Comparator接口，可以满足各种复杂排序需求。无论是基本类型还是自定义类型，都能通过合理的比较策略实现有效的排序。在实际...

    比较器工具类

    `Comparator`接口位于`java.util`包下，通常与`Collections.sort()`方法一起使用，为自定义排序提供灵活性。下面将详细介绍`Comparator`接口的工作原理、常见用法以及如何自定义比较规则。 ### 1. `Comparator`接口...

    java集合排序方法总结共13页.pdf.zip

    Java集合排序涉及的知识点广泛，包括基本的`Collections.sort()`、自定义Comparator、Stream API、并行排序以及泛型等。理解这些概念并熟练运用，能显著提高代码质量和效率。在实际编程中，根据具体需求选择合适的...

Magicbox
Global site tag (gtag.js) - Google Analytics