AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java集合对象排序测试

2017-11-14 922
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
Java API针对集合类型排序提供了两种支持：
java.util.Collections.sort(java.util.List) 
java.util.Collections.sort(java.util.List, java.util.Comparator) 
 
第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。
第二个方法要求实现一个java.util.Comparator接口。
 
java.lang.Comparable接口和java.util.Comparator接口是Java对排序最提供最基本支持。这两个接口不但可以用于集合元素排序，还可以用于数组排序。
 
如果数组或集合元素是String类型，则可以利用Java API实现的Comparator<String>对象String.CASE_INSENSITIVE_ORDER为容器元素排序。
 
下面给出两个里测试，涵盖集合和数组的排序，并且还演示了数组和集合的相互转换：
 
例子一：实现Comparable接口排序
 
package collsort.comparable; 

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 22:21:19 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 要排序的元素对象 
*/ 
public  class Cat  implements Comparable<Cat> { 
     private  int age; 
     private String name; 

     public Cat( int age, String name) { 
         this.age = age; 
         this.name = name; 
    } 

     public  int getAge() { 
         return age; 
    } 

     public  void setAge( int age) { 
         this.age = age; 
    } 

     public String getName() { 
         return name; 
    } 

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


     public String toString() { 
         return  "Cat{" + 
                 "age=" + age + 
                 ", name='" + name + '\'' + 
                '}'; 
    } 

     public  int compareTo(Cat o) { 
         return  this.getAge() - o.getAge(); 
    } 
}

 
package collsort.comparable; 

import java.util.*; 

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 22:24:12 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 通过实现Comparable接口实现个性化排序测试 
*/ 
public  class TestComparable { 

     public  static String outCollection(Collection coll) { 
        StringBuffer sb =  new StringBuffer(); 
         for (Object obj : coll) { 
            sb.append(obj +  "\n"); 
        } 
        System.out.println(sb.toString()); 
         return sb.toString(); 
    } 

     public  static  void main(String args[]) { 
        test(); 
        test2(); 
    } 

     public  static  void test() { 
        System.out.println( "----------test()---------"); 
        System.out.println( "升序排序测试:"); 
        List<Cat> listCat =  new ArrayList<Cat>(); 
        Cat cat1 =  new Cat(34,  "hehe"); 
        Cat cat2 =  new Cat(12,  "haha"); 
//        Person catx = new Person(12, "lavasoft"); 
        Cat cat3 =  new Cat(23,  "leizhimin"); 
        Cat cat4 =  new Cat(13,  "lavasoft"); 

        listCat.add(cat1); 
        listCat.add(cat2); 
        listCat.add(cat3); 
//        listCat.add(catx); 

        System.out.println( "原集合为:"); 
        outCollection(listCat); 

        System.out.println( "调用Collections.sort(List<T> list)排序："); 
        Collections.sort(listCat); 
        outCollection(listCat); 
         
        System.out.println( "逆序排列元素:"); 
        Collections.sort(listCat, Collections.reverseOrder()); 
        outCollection(listCat); 

        System.out.println( "再次逆序排列元素:"); 
        Collections.reverse(listCat); 
        outCollection(listCat); 

        System.out.println( "添加一个元素后输出集合："); 
        listCat.add(cat4); 
        outCollection(listCat); 

        System.out.println( "排列后输出:"); 
        Collections.sort(listCat); 
        outCollection(listCat); 
    } 

     /** 
     * 针对数组的排序 
     */ 
     public  static  void test2(){ 
        String[] strArray =  new String[] { "z",  "a",  "C"}; 
        System.out.println( "-------------数组转换为列表-------------"); 
        List<String> list = Arrays.asList(strArray); 
        outCollection(list); 

        System.out.println( "-------------列表转换为数组(1)-------------"); 
        String[] strArrayNew1 = list.toArray(strArray); 
         for(String str:strArrayNew1){ 
            System.out.println(str); 
        } 
        System.out.println( "-------------列表转换为数组(2)-------------"); 
        String[] strArrayNew2 = (String[]) list.toArray(); 
         for(String str:strArrayNew2){ 
            System.out.println(str); 
        } 

        System.out.println( "-------------顺序排序列表-------------"); 
        Collections.sort(list); 
        outCollection(list); 

        System.out.println( "-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----"); 
        Collections.sort(list, String.CASE_INSENSITIVE_ORDER); 
        outCollection(list); 

        System.out.println( "-------------倒序排序列表-------------"); 
        Collections.sort(list, Collections.reverseOrder()); 
        outCollection(list); 

        System.out.println( "-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----"); 
        Collections.sort(list, String.CASE_INSENSITIVE_ORDER); 
        outCollection(list); 

        System.out.println( "-----反转列表元素的顺序------"); 
        Collections.reverse(list); 
        outCollection(list); 
    } 
}

 运行结果：
----------test()--------- 
升序排序测试: 
原集合为: 
Cat{age=34, name='hehe'} 
Cat{age=12, name='haha'} 
Cat{age=23, name='leizhimin'} 

调用Collections.sort(List<T> list)排序： 
Cat{age=12, name='haha'} 
Cat{age=23, name='leizhimin'} 
Cat{age=34, name='hehe'} 

逆序排列元素: 
Cat{age=34, name='hehe'} 
Cat{age=23, name='leizhimin'} 
Cat{age=12, name='haha'} 

再次逆序排列元素: 
Cat{age=12, name='haha'} 
Cat{age=23, name='leizhimin'} 
Cat{age=34, name='hehe'} 

添加一个元素后输出集合： 
Cat{age=12, name='haha'} 
Cat{age=23, name='leizhimin'} 
Cat{age=34, name='hehe'} 
Cat{age=13, name='lavasoft'} 

排列后输出: 
Cat{age=12, name='haha'} 
Cat{age=13, name='lavasoft'} 
Cat{age=23, name='leizhimin'} 
Cat{age=34, name='hehe'} 

-------------数组转换为列表------------- 
z 
a 
C 

-------------列表转换为数组(1)------------- 
z 
a 
C 
-------------列表转换为数组(2)------------- 
z 
a 
C 
-------------顺序排序列表------------- 
C 
a 
z 

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序---- 
a 
C 
z 

-------------倒序排序列表------------- 
z 
a 
C 

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序---- 
a 
C 
z 

-----反转列表元素的顺序------ 
z 
C 
a 


Process finished with exit code 0 
 
例子一：实现Comparator接口排序
package collsort.compare; 

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:28:29 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 要排序的元素对象 
*/ 
public  class Person { 
     private  int age; 
     private String name; 

     public Person( int age, String name) { 
         this.age = age; 
         this.name = name; 
    } 

     public  int getAge() { 
         return age; 
    } 

     public  void setAge( int age) { 
         this.age = age; 
    } 

     public String getName() { 
         return name; 
    } 

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

     public String toString() { 
         return  "Person{" + 
                 "age=" + age + 
                 ", name='" + name + '\'' + 
                '}'; 
    } 
}
 
package collsort.compare; 

import java.util.Comparator; 

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:29:35 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* Person类的排序接口 
*/ 
public  class PersonComparator  implements Comparator<Person> { 
     /** 
     * 排序接口算法实现 
     * 
     * @param o1 
     * @param o2 
     * @return 比较结果的大小 
     */ 
     public  int compare(Person o1, Person o2) { 
         return o1.getAge() - o2.getAge(); 
    } 
}
 
package collsort.compare; 

import collsort.compare.Person; 

import java.util.*; 

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:30:49 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 通过Comparator接口实现个性化排序测试 
* 结论:Comparator接口是一个为集合对象排序的基本算法,其中的compare方法是比较两个元素对象的比较方式.Java Collection框架利用这个算法实现了不同集合类型对象排序方式的统一.<br> 
* 排序针对的是确切的集合对象,当集合对象的元素发生变化时,集合内的元素不会自动重新排序. 
*/ 
public  class TestComparator { 
     public  static String outCollection(Collection coll) { 
        StringBuffer sb =  new StringBuffer(); 
         for (Object obj : coll) { 
            sb.append(obj +  "\n"); 
        } 
        System.out.println(sb.toString()); 
         return sb.toString(); 
    } 

     public  static  void main(String args[]) { 
        test1(); 
    } 

     public  static  void test1() { 
        System.out.println( "----------test1()---------"); 
        System.out.println( "升序排序测试:"); 
        List<Person> listPerson =  new ArrayList<Person>(); 
        Person person1 =  new Person(34,  "lavasoft"); 
        Person person2 =  new Person(12,  "lavasoft"); 
//        Person personx = new Person(12, "lavasoft"); 
        Person person3 =  new Person(23,  "leizhimin"); 
        Person person4 =  new Person(13,  "sdg"); 

        listPerson.add(person1); 
        listPerson.add(person2); 
        listPerson.add(person3); 
//        listPerson.add(personx); 

        Comparator<Person> ascComparator =  new PersonComparator(); 

        System.out.println( "原集合为:"); 
        outCollection(listPerson); 

        System.out.println( "排序后集合为:"); 
         //利用Collections类静态工具方法对集合List进行排序 
        Collections.sort(listPerson, ascComparator); 
        outCollection(listPerson); 

        System.out.println( "在继续添加一个Person对象,集合为:"); 
        listPerson.add(person4); 
        outCollection(listPerson); 

        System.out.println( "添加一个对象后,重新排序输出:"); 
        Collections.sort(listPerson, ascComparator); 
        outCollection(listPerson); 

        System.out.println( "\n降序排序测试:"); 
         //从升序排序对象产生一个反转(降序)的排序对象 
        Comparator<Person> descComparator = Collections.reverseOrder(ascComparator); 
        System.out.println( "利用反转后的排序接口对象对集合List排序并输出:"); 
        Collections.sort(listPerson, descComparator); 
        outCollection(listPerson); 

        System.out.println( "\n求最大最小元素测试:"); 
        Person p_max = Collections.max(listPerson, ascComparator); 
        Person p_min = Collections.min(listPerson, ascComparator); 
        System.out.println( "最大元素为:" + p_max.toString()); 
        System.out.println( "最小元素为:" + p_min.toString()); 
    } 
}
 
运行结果：
----------test1()--------- 
升序排序测试: 
原集合为: 
Person{age=34, name='lavasoft'} 
Person{age=12, name='lavasoft'} 
Person{age=23, name='leizhimin'} 

排序后集合为: 
Person{age=12, name='lavasoft'} 
Person{age=23, name='leizhimin'} 
Person{age=34, name='lavasoft'} 

在继续添加一个Person对象,集合为: 
Person{age=12, name='lavasoft'} 
Person{age=23, name='leizhimin'} 
Person{age=34, name='lavasoft'} 
Person{age=13, name='sdg'} 

添加一个对象后,重新排序输出: 
Person{age=12, name='lavasoft'} 
Person{age=13, name='sdg'} 
Person{age=23, name='leizhimin'} 
Person{age=34, name='lavasoft'} 


降序排序测试: 
利用反转后的排序接口对象对集合List排序并输出: 
Person{age=34, name='lavasoft'} 
Person{age=23, name='leizhimin'} 
Person{age=13, name='sdg'} 
Person{age=12, name='lavasoft'} 


求最大最小元素测试: 
最大元素为:Person{age=34, name='lavasoft'} 
最小元素为:Person{age=12, name='lavasoft'} 

Process finished with exit code 0 
 
 
最后说明一下，Java如何通过所实现接口的方法进行排序是API内部的事情，Java这样处理排序目的就是对容器元素排序有一个统一的方式，以简化编程。
 
当然也可以自己通过别的算法进行元素排序，在此不做讨论。


本文转自 leizhimin 51CTO博客，原文链接：http://blog.51cto.com/lavasoft/68380，如需转载请自行联系原作者
文章标签：
Java
测试技术
算法
API
关键词：
Java对象
Java集合
集合测试
Java测试
Java排序
技术小阿哥
目录
相关文章
软件求生
|
9天前
|
存储 安全 Java
Java 集合框架中的老炮与新秀：HashTable 和 HashMap 谁更胜一筹？
嗨，大家好，我是技术伙伴小米。今天通过讲故事的方式，详细介绍 Java 中 HashMap 和 HashTable 的区别。从版本、线程安全、null 值支持、性能及迭代器行为等方面对比，帮助你轻松应对面试中的经典问题。HashMap 更高效灵活，适合单线程或需手动处理线程安全的场景；HashTable 较古老，线程安全但性能不佳。现代项目推荐使用 ConcurrentHashMap。关注我的公众号“软件求生”，获取更多技术干货！
软件求生
31 3
cafehaus
|
1天前
|
Java
java代码优化：判断内聚到实体对象中和构造上下文对象传递参数
通过两个常见的java后端实例场景探讨代码优化，代码不是优化出来的，而是设计出来的，我们永远不可能有专门的时间去做代码优化，优化和设计在平时
cafehaus
22 15
追逐时光者
|
10天前
|
开发框架 .NET Java
C#集合数据去重的5种方式及其性能对比测试分析
C#集合数据去重的5种方式及其性能对比测试分析
追逐时光者
27 11
追逐时光者
|
11天前
|
开发框架 .NET Java
C#集合数据去重的5种方式及其性能对比测试分析
C#集合数据去重的5种方式及其性能对比测试分析
追逐时光者
41 10
软件求生
|
26天前
|
存储 缓存 安全
Java 集合江湖：底层数据结构的大揭秘！
小米是一位热爱技术分享的程序员，本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类，还深入探讨了各自的使用场景和面试技巧，帮助读者更好地理解和应对相关问题。
软件求生
44 5
Java开发者
|
2月前
|
存储 缓存 安全
Java 集合框架优化：从基础到高级应用
《Java集合框架优化：从基础到高级应用》深入解析Java集合框架的核心原理与优化技巧，涵盖列表、集合、映射等常用数据结构，结合实际案例，指导开发者高效使用和优化Java集合。
Java开发者
47 4
智物科技库
|
2月前
|
安全 Java 编译器
Java对象一定分配在堆上吗？
本文探讨了Java对象的内存分配问题，重点介绍了JVM的逃逸分析技术及其优化策略。逃逸分析能判断对象是否会在作用域外被访问，从而决定对象是否需要分配到堆上。文章详细讲解了栈上分配、标量替换和同步消除三种优化策略，并通过示例代码说明了这些技术的应用场景。
智物科技库
66 4
Java对象一定分配在堆上吗？
众所周知
|
2月前
|
Java
Java 8 引入的 Streams 功能强大，提供了一种简洁高效的处理数据集合的方式
Java 8 引入的 Streams 功能强大，提供了一种简洁高效的处理数据集合的方式。本文介绍了 Streams 的基本概念和使用方法，包括创建 Streams、中间操作和终端操作，并通过多个案例详细解析了过滤、映射、归并、排序、分组和并行处理等操作，帮助读者更好地理解和掌握这一重要特性。
众所周知
40 2
大树营养快线
|
2月前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
57 7
2G冲浪词条
|
2月前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
47 1

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java多线程并发编程：同步机制与实践应用
  • 5
    Java中的异常处理：从基础到高级
  • 6
    深入理解Java异常处理机制
  • 7
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 8
    Java爬虫：深入解析商品详情的利器
  • 9
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 10
    Java 异常处理：机制、策略与最佳实践
  • 1
    LabVIEW MEMS电容式压力传感器测试系统
    87
  • 2
    热敏电阻怎么进行性能测试？并以LabVIEW为例进行说明
    93
  • 3
    论文介绍：MACHIAVELLI基准测试：衡量奖励与道德行为之间的权衡
    95
  • 4
    LabVIEW无人机大气数据智能测试系统
    67
  • 5
    LabVIEW高温摩擦磨损测试系统
    50
  • 6
    LabVIEW伺服阀动静态测试系统
    63
  • 7
    容器技术：优化软件测试流程的利器
    123
  • 8
    LabVIEW开发自动读取指针式仪表测试系统
    72
  • 9
    LabVIEW开发新型电化学性能测试设备
    71
  • 10
    LabVIEW与Tektronix示波器实现电源测试自动化
    87

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 移动互联网测试到质量的转变
  • 给ITer的技术实战进阶课-阿里CIO学院独家教材（四）
  • F2etest — 多浏览器兼容性测试整体解决方案

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 灵活弹性的PolarDB Serverless确保数据业务持续在线
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    DataWorks智能交互式数据开发与分析之旅