Java基础篇(三):浅谈常用的集合类以及集合的排序问题 - 简书
Java基础篇(三):浅谈常用的集合类以及集合的排序问题
终于出差回来了，出差期间网络流量非常吃紧，加之上下班特别折腾，所以就停了几天，现在继续...
老规矩，推荐链接——
Set、List、Map.png
Java中常用的集合类
对于集合，大家都不陌生了，常见的集合接口Set、List、Map等，其中Set和List继承自Collection。
Collection是一组对象的集合，而Map存储的方式不一样，他是以键值对的形式存放多个对象的。
Set和List又有区别，Set中的元素无序且不重复，而List中的元素则是有序且允许重复的。
Set、List、Map都是接口类，定义的是规范，具体使用时，还是需要其实现类的实例。一般我们见得比较多的就是HashSet、TreeSet、ArrayList、LinkedList、HashMap等，另外还有Vector、HashTable什么的，这个涉及了多线程中的线程安全以及性能问题，现在出场率比较低了。
Set：HashSet、TreeSet
说实话，就个人经历而言，Set的使用比较少，仅在对Map使用Entry的方式进行遍历的时候，用到过Set的实现类。
关于去重：Set的中判断放入元素是否重复，都是基于对象的equals()方法的返回值来实现的。
关于顺序和排序：其实作为无序的Set，本身应该是不具备排序功能的，因为根本就没有顺序。
HashSet对于元素的存储位置是取决放入对象的HashCode，是散列形式的；另外，还有一个名叫LinkedHashSet的实现类，除了使用HashCode来决定元素位置之外，同时还是用了链表来维护元素的次序(Linked)，因此对其插入元素时，看起来是有序的；
TreeSet，这个实现类没有接触过，以下资料为网络摘抄：
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。
向TreeSet中加入的应该是同一个类的对象。TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0。
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。
比较大小的2个接口.jpg
从上面的引文可以看出，对于集合的排序可以使用元素本身比较大小的方法(前提是实现了Comparable接口的对象)；或者去实现Comparator接口的compare()方法来自定义一套比较大小的逻辑。
List：ArrayList、LinkedList
这2个应该是很常见的集合实现类了，一个是基于数组的原理存储元素，一个是使用链表的形式存储元素，具体的区别不在赘述。
总之，List是有顺序的，因此List肯定是可以排序的。考虑到这一点，Java创造者们早就给我们准备好了趁手的工具——Collections，长得有点像Set和List的お父さん(父亲)，其实根本不是一个世界的人(类)；
关于Collections
这是官方提供的一个处理集合的工具方法的集合，本人最熟悉的就是他的sort()方法，对，就是这个排序用的方法，下面我们就来仔细看看这个便利的方法吧。
sort()方法排序的本质其实也是借助Comparable接口和Comparator接口的实现，一般有2种用法：
1、直接将需要排序的list作为参数传入，此时list中的对象必须实现了Comparable接口，然后sort会按升序的形式对元素进行排序；
2、传入list作为第一个参数，同时追加一个Comparator的实现类作为第二个参数，然后sort方法会根据Comparator接口的实现类的逻辑，按升序进行排序；
这里可能有朋友会问，为什么都是升序没有降序。
其实所谓升或者降都是你自己规定的，sort()方法只是将比较结果为-1的放前面，0的放中间，1的放后面；如果你想实现降序排列，那就在Comparator方法的实现类中，逆转compare的返回结果就行了。
Map：HashMap
看到前面的Set和List的实现类里面前缀都有Array(数组实现)，Hash(哈希)，Linked(链表)这几种存储方式的实现，我脑洞了一下Map是不是也有ArrayMap呢？
没有直接百度，而是直接在IDE中去new ArrayMap&K,V&()，发现编译通不过，看来1.7的JDK是不支持了。
然后开启度娘模式发现，居然Android里面有提到，看来我也不算脑洞了。
HashMap算是开发中使用得最多的了，很方法的键值对形式(内在是一个一个散列分布的Entry&K，V&，因此可是使用Set&Entry&K，V&&的方式遍历)；
本人对于HashMap基本上遍历多，排序少，从其前缀的Hash可以看出，其键值对的存放应该也是根据key的HashCode进行存放；因此，HashMap本身应该是无法排序的，所以跟Set一样，官方也没有提供对应的排序方法。
不过，我们可以进行DIY，譬如把HashMap中的key存入可排序的list，进行排序，然后遍历的时候，通过list或许到key之后，再从Map获取值这样就按照key进行排序了。
如果要按照value进行排序就复杂一点，可以把Entry对象放进list，然后自己实现比较器，根据value进行排序。
嗯，还有更多更快更优的方法，大家都可以发散思维。
另外提一嘴，Map中还有TreeMap和LinkedHashMap，其特点就跟Set中的那两位一样一样的。
写在文尾的体会
不管是Set、List还是Map，根据其不同的特性，有不同的应用场景。
对于排序的问题，根据各种实现类的前缀，了解实现中的元素存储方式，可以知道是有序还是无序。由此，可以知道排序是使用官方工具，还是需要自行实现对应的方法。
不论官方还是DIY，总之要继续排序的基本原理都是借助Comparable接口和Comparator接口的实现，那么不论待处理的集合是怎样的，我们都有办法应对了。.
下一篇——ArrayList和LinkedList内部的实现大致是怎样的？他们之间的区别和各自适应的场景是什么？
九年义务教育、三年高中、四年大学、两年酱油、三年物流……
现在是一名码农。
集合类简介 为什么出现集合类？面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。 集合与数组数组虽然也可以存储对象，但长度是固定的...
百战程序员_ Java1573题 QQ群：034603 掌握80%年薪20万掌握50%年薪10万 全程项目穿插, 从易到难，含17个项目视频和资料持续更新，请关注www.itbaizhan.com 国内最牛七星级团队马士兵、高淇等11位十年开发经验专...
以下资料是在学习中总结出来的，希望对你有所帮助。如果需要请转载，谢谢。 1. StringBuffer 线程安全，StringBuilder 线程不安全 效率稍高些 集(Set)：集里的对象不按任何特定的方式排列，按索引值来操作数据，不能有重复的元素 列表(List)：序列...
3.3 集合 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。 Java 集合类可以用于存储数量不等的多个...
1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，io的语法，虚拟机方面的语法。 1、一个&.java&源文件中是否可以包括多个类（不是内部类）？有什么限制？ 可以有多个类，但只能有一个publ...
我的祖国是一个繁荣的国家，是一个强大的国家，那就是――中国
从古至今我的祖国有很多英雄豪杰，他们有奋勇杀敌，他们有的忍辱负重，而这些人就因为他们的平凡，做出了不平凡的事。
有血战沙场的花木兰，她替父从军的孝心和她的身手成功的书写了谁说女子不如男;还...
新乡140平三室装修，混搭风格，既有现代风格的时尚又有美式乡村的韵味，整体效果很有魅力，让心舒适不已。 装修风格：混搭风格 装修套餐：528套餐+个性化造型 小区面积：140平方 套餐造价：12万 沙发区 客餐厅 餐厅 客厅一角 柜子 电视墙 主卧室 儿童房 旧房装修找e修...
一不小心，我们头碰到了头！ 美丽的时间差，微笑而过。 突然想起刚才路过的凉亭其实挺美！ 于是匆匆赶回却未看到压在心底的身影！ 独自站在亭里！ 恨恨的说！你一点也不美！ 转过头，要走，却不愿抬起头！ 希望奇迹出现，时光倒流！ 模仿先前的画面！ 一个人在亭边，来回…
面对具有共享基因的分布式光伏，光伏电站检测在互联网+的政策驱动下，平台俨然成为了最热的“风口”。 无论是大而全的万能平台，还是小而美的专业服务，需要的不仅是平台的核心竞争力，更是开放的心态，因为在这一领域，企业与平台之间的幻灭已司空见惯，正所谓：分分合合寻常事，难靠一家打天...
在初高中的年龄，大家最爱看的杂志要数是《意林》、《读者》这一类的心灵老鸭汤，一本新书在班上传来传去，最后约莫都要变成老酸菜，受欢迎的程度可见一斑。 那个时候家庭条件一般，没有出过国，网络也不是特别发达，所以，大家对国外的了解基本上都来源于《读者》、《意林》中各位作者对国外的...博客分类：
个人blog原文地址：
距离上次写博客有一个月了， 反省下。今天先写篇简单点的，算是热热身吧。
写在前面
我想几乎每个找过工作的程序员都曾经在面试的时候遇到过如何求topN的问题，而且多数都能不假思索的回答：求topN大用小顶堆，求topN小用大顶堆（觉得反了的同学请去面壁。。。），但是应该也有一部分同学和我之前一样，一直只是把它作为一道面试题而已。
思路
说来不怕丢人，我真的是最近才遇到需要求top N大的场景，囧。。。当时的第一反应是要自己实现一个固定大小的二叉堆，因为印象中常用的Java工具类里并没有现成的实现，但是从头开始实现一个基础工具类是件挺麻烦的事情，别的不说，单是测试就得耗费不少功夫，网上虽然有很多现有实现，但是都不见得那么靠谱。于是想了一个折中的办法就是，对现有的成熟的Java工具类做封装，以达到想要的功能。
代码实现
JDK里有一个现成的工具类叫PriorityQueue，顾名思义，实现的是优先队列的功能，它能够保证每次插入新元素后，队列首位始终是优先级最高的元素，这正是我们想要的，但是它并没有对队列的容量做限制，因此只要对这一点做些许改造，就能达到我们期望的效果。代码如下：
//固定容量的优先队列，模拟大顶堆，用于解决求topN小的问题
public static class FixSizedPriorityQueue&{
private PriorityQ
private int
maxS //堆的最大容量
public FixSizedPriorityQueue(int maxSize){
if(maxSize &= 0) throw new IllegalArgumentException();
this.maxSize = maxS
this.queue = new PriorityQueue(maxSize, new Comparator() {
public int compare(E o1, E o2) {
return o2.compareTo(o1);
public void add(E e){
if(queue.size() & maxSize){ //未达到最大容量，直接添加
queue.add(e);
}else{ //队列已满
E peek = queue.peek();
if(e.compareTo(peek) & 0){ //将新元素与当前堆顶元素比较，保留较小的元素
queue.poll();
queue.add(e);
public List sortedList(){
List list = new ArrayList(queue);
Collections.sort(list); //PriorityQueue本身的遍历是无序的，最终需要对队列中的元素进行排序
注意一下构造PriorityQueue时用到的Comparator，这里面有个比较tricky的地方，因为代码本身是想实现一个大顶堆来解决求topN小的问题，而PriorityQueue的优先级定义是元素越小优先级越高，这与我们的期望相反，因此我们需要自定义PriorityQueue的Comparator，反转元素大小的定义，这样就能保证队列首位的元素是当前队列中最大的。而在比较新元素和队列首位元素的大小时，则是按照正常的元素大小定义做比较。
结尾
在需要快速实现需求的时候，我们可能没有足够的时间把代码写得很完美，如何写最少的代码实现想要的功能，也是我们日常工作中需要考虑的问题。
PS：文中若有纰漏之处，敬请拍砖。
最后一点不明白，为什么每次还要对队列进行排序，循环N次，调用poll方法每次取得都是当前队列最大的数字了。你说的方法也是可以的，我当时应该是想保留queue里的数据，所以做了一份copy。
浏览: 112134 次
来自: 北京
whxiyi100829 写道使用import pyhdfs没 ...
luxury_zh 写道最后一点不明白，为什么每次还要对队列进 ...
最后一点不明白，为什么每次还要对队列进行排序，循环N次，调用p ...
楼主这种探索精神值得学习
我想请问一下楼主，如果不遵守robot.txt协议。那势必会找 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'【java】求助怎么把一个数组元素随机打乱顺序，谢谢~~~_百度知道
【java】求助怎么把一个数组元素随机打乱顺序，谢谢~~~
现有一个长度为10000的数组a,怎么把a中的数组元素重新打乱顺序(随机打乱)？比如5长度的数组x={1,2,3,4,5}打乱顺序后譬如变成x={2,3,5,1,4}？效率要尽量高。谢谢~...
现有一个长度为10000的数组a, 怎么把a中的数组元素重新打乱顺序(随机打乱)？比如5长度的数组x = { 1, 2, 3, 4, 5} 打乱顺序后譬如变成 x = {2, 3, 5, 1, 4}？ 效率要尽量高。谢谢~
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
采纳数：397
获赞数：1272
晕.不用那么麻烦.先转化为list（为什么不一开始就用List呢？）例：String[] arr = new String[] {&1&, &2&};List list = Arrays.asList(arr);直接调用shuffle，就是随机排序 例：Collections.shuffle(list);直接输出就是你想要的结果
采纳数：368
获赞数：852
随机生成10000个整数(可以是6位的), 以这些随机数为键值, 以原有数组的值存到一个新数组, 当然随机出来的键值需要判断重复, 然后按键值顺序输出新数组 我只能给个思路, 没用过Java, 说的不对的地方请见谅
lizhao860618
lizhao860618
采纳数：39
获赞数：105
import java.util.ArrayLimport java.util.Limport java.util.Rpublic class Test { public static void main(String [] args){
int [] x={1,2,3,4,5};
List list=new ArrayList();
for(int i=0;i&x.i++){
list.add(x[i]);
Random r=new Random();
for(int i=0;i&x.i++){
int j=r.nextInt(list.size());
x[i]=Integer.valueOf(list.get(j).toString());
list.remove(j);
for(int i=0;i&x.i++){
System.out.println(x[i]);
采纳数：218
获赞数：1006
楼上正解Collections本来就是集合的帮助类做运算
用它再合适不过了··
wenroulang123
wenroulang123
采纳数：23
获赞数：44
new一个长度为10000的键值对,数组a做健,值为随机数,用值排序输出.排序的时候重复的按原顺序,实际还是随机
其他2条回答
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。扫一扫体验手机阅读
Java集合对象排序测试
&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. /** * Created by IntelliJ IDEA. * User: leizhimin * Date:
22:21:19 * Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) * 要排序的元素对象 */ public class Cat implements Comparable&Cat& { &&&&private int &&&&private S &&&&public Cat(int age, String name) { &&&&&&&&this.age = &&&&&&&&this.name = &&&&} &&&&public int getAge() { &&&&&&&&return &&&&} &&&&public void setAge(int age) { &&&&&&&&this.age = &&&&} &&&&public String getName() { &&&&&&&&return &&&&} &&&&public void setName(String name) { &&&&&&&&this.name = &&&&} &&&&public String toString() { &&&&&&&&return "Cat{" + &&&&&&&&&&&&&&&&"age=" + age + &&&&&&&&&&&&&&&&", name='" + name + '\'' + &&&&&&&&&&&&&&&&'}'; &&&&} &&&&public int compareTo(Cat o) { &&&&&&&&return this.getAge() - o.getAge(); &&&&} }
package collsort. import java.util.*; /** * Created by IntelliJ IDEA. * User: leizhimin * Date:
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. /** * Created by IntelliJ IDEA. * User: leizhimin * Date:
13:28:29 * Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) * 要排序的元素对象 */ public class Person { &&&&private int &&&&private S &&&&public Person(int age, String name) { &&&&&&&&this.age = &&&&&&&&this.name = &&&&} &&&&public int getAge() { &&&&&&&&return &&&&} &&&&public void setAge(int age) { &&&&&&&&this.age = &&&&} &&&&public String getName() { &&&&&&&&return &&&&} &&&&public void setName(String name) { &&&&&&&&this.name = &&&&} &&&&public String toString() { &&&&&&&&return "Person{" + &&&&&&&&&&&&&&&&"age=" + age + &&&&&&&&&&&&&&&&", name='" + name + '\'' + &&&&&&&&&&&&&&&&'}'; &&&&} }
package collsort. import java.util.C /** * Created by IntelliJ IDEA. * User: leizhimin * Date:
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. import collsort.compare.P import java.util.*; /** * Created by IntelliJ IDEA. * User: leizhimin * Date:
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这样处理排序目的就是对容器元素排序有一个统一的方式，以简化编程。
当然也可以自己通过别的算法进行元素排序，在此不做讨论。
674篇文章，4071W+人气，77粉丝
运维开发全攻略
￥51.0054人订阅
大数据时代的微服务之路
￥51.00526人订阅