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

Java集合对象排序测试

2017-11-14 998
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
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排序
集合测试
技术小阿哥
目录
相关文章
BigFour
|
5月前
|
设计模式 网络协议 数据可视化
Java 设计模式之状态模式：让对象的行为随状态优雅变化
状态模式通过封装对象的状态，使行为随状态变化而改变。以订单为例，将待支付、已支付等状态独立成类，消除冗长条件判断，提升代码可维护性与扩展性，适用于状态多、转换复杂的场景。
BigFour
756 157
一缕微风绕指柔
|
6月前
|
Java 大数据 API
Java Stream API：现代集合处理与函数式编程
Java Stream API：现代集合处理与函数式编程
一缕微风绕指柔
346 100
一缕微风绕指柔
|
6月前
|
Java API 数据处理
Java Stream API：现代集合处理新方式
Java Stream API：现代集合处理新方式
一缕微风绕指柔
355 101
啦啦啦191
|
7月前
|
算法 IDE Java
Java 项目实战之实际代码实现与测试调试全过程详解
本文详细讲解了Java项目的实战开发流程，涵盖项目创建、代码实现（如计算器与汉诺塔问题）、单元测试（使用JUnit）及调试技巧（如断点调试与异常排查），帮助开发者掌握从编码到测试调试的完整技能，提升Java开发实战能力。
啦啦啦191
684 0
游客cxuvnylemktao
|
6月前
|
算法 Java
50道java集合面试题
50道 java 集合面试题
游客cxuvnylemktao
385 72
蓝易云
|
5月前
|
存储 算法 安全
Java集合框架：理解类型多样性与限制
总之，在 Java 题材中正确地应对多样化与约束条件要求开发人员深入理解面向对象原则、范式编程思想以及JVM工作机理等核心知识点。通过精心设计与周密规划能够有效地利用 Java 高级特征打造出既健壮又灵活易维护系统软件产品。
蓝易云
161 7
艾伦~耶格尔
|
7月前
|
存储 缓存 安全
Java集合框架（二）：Set接口与哈希表原理
本文深入解析Java中Set集合的工作原理及其实现机制，涵盖HashSet、LinkedHashSet和TreeSet三大实现类。从Set接口的特性出发，对比List理解去重机制，并详解哈希表原理、hashCode与equals方法的作用。进一步剖析HashSet的底层HashMap实现、LinkedHashSet的双向链表维护顺序特性，以及TreeSet基于红黑树的排序功能。文章还包含性能对比、自定义对象去重、集合运算实战和线程安全方案，帮助读者全面掌握Set的应用与选择策略。
艾伦~耶格尔
646 23
Aron_NeAr
|
6月前
|
存储 Java Go
对比Java学习Go——函数、集合和OOP
Go语言的函数支持声明与调用，具备多返回值、命名返回值等特性，结合`func`关键字与类型后置语法，使函数定义简洁直观。函数可作为一等公民传递、赋值或作为参数，支持匿名函数与闭包。Go通过组合与接口实现面向对象编程，结构体定义数据，方法定义行为，接口实现多态，体现了Go语言的简洁与高效设计。
Aron_NeAr
180 4
蓝易云
|
7月前
|
安全 Java 开发者
Java集合框架：详解Deque接口的栈操作方法全集
理解和掌握这些方法对于实现像浏览器后退功能这样的栈操作来说至关重要，它们能够帮助开发者编写既高效又稳定的应用程序。此外，在多线程环境中想保证线程安全，可以考虑使用ConcurrentLinkedDeque，它是Deque的线程安全版本，尽管它并未直接实现栈操作的方法，但是Deque的接口方法可以相对应地使用。
蓝易云
401 12
艾伦~耶格尔
|
7月前
|
存储 缓存 安全
Java集合框架（三）：Map体系与ConcurrentHashMap
本文深入解析Java中Map接口体系及其实现类，包括HashMap、ConcurrentHashMap等的工作原理与线程安全机制。内容涵盖哈希冲突解决、扩容策略、并发优化，以及不同Map实现的适用场景，助你掌握高并发编程核心技巧。
艾伦~耶格尔
490 6

热门文章

最新文章

  • 1
    Java中线程池，你真的会用吗？
  • 2
    【Java数据结构】搜索二叉树——对节点的插入、查找、删除 操作
  • 3
    深入研究java.lang.Class类
  • 4
    java源码-BufferedReader
  • 5
    解决Bug：java.lang.NoSuchMethodError
  • 6
    【Java并发基础】使用“等待—通知”机制优化死锁中占用且等待解决方案
  • 7
    java finally深入探究
  • 8
    java中支持多个线程同时运作！
  • 9
    java关于随机数和方法重构
  • 10
    java的制作&quot;时间账本&quot;
  • 1
    测试金字塔：别再只盯着UI自动化了
    557
  • 2
    测试金字塔：构建高效自动化测试策略的基石
    425
  • 3
    测试金字塔：构建高效自动化测试策略的基石
    449
  • 4
    测试之道：重构你的测试策略 - 测试金字塔模型
    489
  • 5
    测试的艺术：掌握测试金字塔，构建高效测试策略
    350
  • 6
    告别脆弱：构建稳定UI自动化测试的3个核心策略
    552
  • 7
    告别蛮力：让测试数据生成变得智能而高效
    556
  • 8
    Cypress 插件实战：让测试更稳定，不再“偶尔掉链子”
    292
  • 9
    面试性能测试总被刷？学员真实遇到的高频问题全解析！
    397
  • 10
    从0到1：天猫AI测试用例生成的实践与突破
    2133

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    云安全中心：病毒查杀