java容器的排序

转载 2013年12月03日 12:20:00

在项目开发中,经常回用到容器排序,而它们的写法比较固定,今天就来总结一下.

pojo类如下:

Java代码  收藏代码
  1. package com.ldh;  
  2.   
  3. public class Student implements Comparable<Student> {  
  4.     private int    id;  
  5.     private String name;  
  6.     private int    age;  
  7.   
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.       
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.   
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.   
  20.     public void setName(String name) {  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public int getAge() {  
  25.         return age;  
  26.     }  
  27.   
  28.     public void setAge(int age) {  
  29.         this.age = age;  
  30.     }  
  31.       
  32.     @Override  
  33.     public int compareTo(Student o) {  
  34.         return new Integer(age).compareTo(new Integer(o.getAge()));  
  35.     }  
  36. }  

    再创建四个Student对象:

    

Java代码  收藏代码
  1. Student st1 = new Student();  
  2.  st1.setName("zhangsan1");  
  3.  st1.setId(1);  
  4.  st1.setAge(30);  
  5.    
  6.  Student st2 = new Student();  
  7.  st2.setName("zhangsan2");  
  8.  st2.setId(2);  
  9.  st2.setAge(20);  
  10.    
  11.  Student st3 = new Student();  
  12.  st3.setName("zhangsan3");  
  13.  st3.setId(3);  
  14.  st3.setAge(10);  
  15.    
  16.  Student st4 = new Student();  
  17.  st4.setName("zhangsan4");  
  18.  st4.setId(4);  
  19.  st4.setAge(10);  
    用TreeSet对上述四个Student对象排序并打印出结果:
Java代码  收藏代码
  1. Set<Student> set = new TreeSet<Student>();  
  2.  set.add(st1);  
  3.  set.add(st2);  
  4.  set.add(st3);  
  5.  set.add(st4);  
  6.    
  7.  for(Student st : set){  
  8.      System.out.println(st.getAge());  
  9.  }  
  10.  System.out.println(set.size());  

 

打印出的结果如下:

 10

 20

 30

 3

TreeSet底层排序算法是二叉树,如果两个元素比较的结果为0,就被视为同一个元素.如果 Student没有实现Comparable接口,也可以通过以下方式实现排序:

 

Java代码  收藏代码
  1. Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {  
  2.         @Override  
  3.         public int compare(Student o1, Student o2) {  
  4.              return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge())                  );  
  5.         }  
  6.     });  
        最终打印出的结果和实现Comparable接口一样.TreeSet的底层实现结构是TreeMap,TreeSet就是value都相同的TreeMap,因此TreeMap也有上述两种排序方式.

 

    再看来看一下List的排序,同样是上面的四个对象,都实现Comparable接口.
Java代码  收藏代码
  1. List<Student> slist = new LinkedList<Student>();  
  2. slist.add(st1);  
  3. slist.add(st2);  
  4. slist.add(st3);  
  5. slist.add(st4);  
  6. Collections.sort(slist);  
  7. for(Student st : slist){  
  8.     System.out.println(st.getAge());  
  9. }  
  10. System.out.println(slist.size());  
     上面这段代码打印的结果是
      10
      10
       20
       30
        4
       通过上面的结果可以看到,List排序四个元素都打印出来,并且按正序排序,如果想按倒序排序,只需要
Java代码  收藏代码
  1. @Override  
  2.    public int compareTo(Student o) {  
  3.        return -new Integer(age).compareTo(new Integer(o.getAge()));  
  4.    }  
        在原来的基础上加一个"-"负号就可以了.
        同样List也可以用实现Comparator接口进行排序,如下:
       
Java代码  收藏代码
  1. List<Integer> list = new LinkedList<Integer>();  
  2.  list.add(new Integer(5));  
  3.  list.add(new Integer(3));  
  4.  list.add(new Integer(4));  
  5.  list.add(new Integer(3));  
  6.  Collections.sort(list, new Comparator<Integer>() {  
  7.        @Override  
  8.        public int compare(Integer o1, Integer o2) {  
  9.            return o1 - o2;  
  10.        }  
  11.    });  
  12.    for(Integer letter : list){  
  13.        System.out.println(letter);  
  14.    }  
  15.    System.out.println(list.size());  
  16.      
    排序结果:
    3
    3
    4
    5
    4      
         List的实现ArrayList也同样可以上面的两种排序,LinkedList是链表结构,增加,删除效率高,但查找由于要移动指针,效率就低了.ArrayList底层的实现了基于动态数组的数据结构,查找效率高,但增加,删除由于涉及到数据移动,效率就没有LinkedList高了.实际项目具体用哪一个,看实际情况.
      对于容器排序是实现Comparable接口还是Comparator接口,我推荐Comparator接口,因为Comparator与原来的代码的耦合性低,比如刚开始的需求不需要排序,而后来又需要排序,但又想尽量少动原来的代码,Comparator接口就比较适合了.同时对于同一个对象,有的地方想这样排,另一个地方又想那样排,这是你发现还是Comparator比较好,多实现几个Comparator就行了.

转自:http://liudeh-009.iteye.com/blog/1847626

java-容器-collection的sort方法

Java中如果需要对一个collections排序,需要继承于Comparable或者comparator接口,那么使用的排序算法是什么呢,一般情况下,排序算法包括:插入排序、快速排序、合并排序、冒泡...
  • youdianjinjin
  • youdianjinjin
  • 2016年05月19日 22:16
  • 1789

java自定义容器排序的两种方法

首先说一下排序的返回值的含义。对于参与比较的两个Object,o1和o2,如果函数的返回值为正值,把o1排在o2后面;返回值为负值,把o1排在o2前面。如果返回值是0,按照容器之前的顺序排列。在com...
  • shirenfeigui
  • shirenfeigui
  • 2014年09月04日 14:19
  • 12868

Java容器排序的方法

转自:http://blog.csdn.net/shirenfeigui/article/details/39051741 首先说一下排序的返回值的含义。对于参与比较的两个Objec...
  • zhouxinyu1cp
  • zhouxinyu1cp
  • 2017年06月08日 08:16
  • 143

Java 容器类及遍历效率对比

Java 容器类及遍历效率对比 1)Collection Collection是最基本的集合接口,一个Collection代表一组Object,Java SDK不提供直接继承自Collectio...
  • jackchen95
  • jackchen95
  • 2013年10月29日 19:22
  • 1932

java容器的排序

在项目开发中,经常回用到容器排序,而它们的写法比较固定,今天就来总结一下. pojo类如下: Java代码   package com.ldh;      publi...
  • youyiweiqiuxuezhe
  • youyiweiqiuxuezhe
  • 2013年12月03日 12:20
  • 759

秘钥容器排序源代码JAVA

  • 2017年10月23日 12:11
  • 9KB
  • 下载

深入理解Java中的容器

1、容器的概念 在Java当中,如果有一个类专门用来存放其它类的对象,这个类就叫做容器,或者就叫做集合,集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体 2、容器与数组的关系 之所...
  • a2011480169
  • a2011480169
  • 2016年07月27日 17:25
  • 15089

【公开课】【阿里在线技术峰会】魏鹏:基于Java容器的多应用部署技术实践

对于公开课,可能目前用不上这些,但是往往能在以后想解决方案的时候帮助到我。以下是阿里对公开课的整理 摘要: 在首届阿里巴巴在线峰会上,阿里巴巴中间件技术部专家魏鹏为大家带来了题为《基于Java容器...
  • Jerome_s
  • Jerome_s
  • 2016年07月23日 08:38
  • 846

Java 关于对象之间的比较 , 容器中的数据的排序

Java对象排序基本类型排序 :* 就是按照数据的大小排序 * 有很多排序算法; 引用类型的排序 :1. 内置对象排序 : 已经有了该对象的排序规则 2. 自定义类的对象的排序 : 需要自己定义对...
  • DO_HACKER
  • DO_HACKER
  • 2017年09月23日 20:08
  • 229

Java-容器

Java集合类架构层次关系 集合指多个元素的聚集体。 Java中的集合类主要是由两个接口派生而出:     1):Collection接口: 存储一组对象,一次存一个元素, 是单列集合 ...
  • lzhat
  • lzhat
  • 2016年11月17日 08:55
  • 261
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java容器的排序
举报原因:
原因补充:

(最多只允许输入30个字)