Java集合对象排序

转载 2012年03月26日 10:41:51
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这样处理排序目的就是对容器元素排序有一个统一的方式,以简化编程。
 
当然也可以自己通过别的算法进行元素排序,在此不做讨论。

 

本文出自 “熔 岩” 博客,请务必保留此出处http://lavasoft.blog.51cto.com/62575/68380

java 集合中自定义对象的几种排序方法

java 集合中自定义对象的几种排序方法1. 通过实现Comparable接口,来对集合中的自定义对象排序代码:import java.util.*;//student类,并实现Comparable接...
  • ping1632743560
  • ping1632743560
  • 2016年07月14日 00:28
  • 6488

Java集合排序,对象属性值排序

package book; import java.util.Comparator; /** * 比较器类,比较两个参数的大小。一般用于集合或者Map的排序。 */ public clas...
  • ToSweetSmiles
  • ToSweetSmiles
  • 2016年09月24日 15:56
  • 915

Java集合对象的排序使用Collection.sort方法,先实现Comparable接口

Java API针对集合类型排序提供了两种支持: java.util.Collections.sort(java.util.List) java.util.Collections.sort(jav...
  • rootsongjc
  • rootsongjc
  • 2013年04月17日 16:20
  • 2173

JAVA之旅(二十)—HashSet,自定义存储对象,TreeSet,二叉树,实现Comparator方式排序,TreeSet小练习

JAVA之旅(二十)—HashSet,自定义存储对象,TreeSet,二叉树,实现Comparator方式排序,TreeSet小练习– 我们继续说一下集合框架Set:元素是无序(存入和取出的顺序不...
  • qq_26787115
  • qq_26787115
  • 2016年06月25日 20:54
  • 3097

List集合中的对象根据属性排序

集合类List存放的数据,默认是按照放入时的顺序存放的,比如依次放入A、B、C,则取得时候,则也是A、B、C的顺序,实际场景中,有时我们需要根据自定义的规则对List中的元素进行排序,该如何实现呢?看...
  • lifuxiangcaohui
  • lifuxiangcaohui
  • 2014年11月27日 11:11
  • 78861

java中对List中对象排序实现

package com.test; import java.util.ArrayList; import java.util.Collections; import java.util.Co...
  • 5iasp
  • 5iasp
  • 2013年05月29日 17:55
  • 21061

Java集合对象排序

TreeSet TreeMap 需要重新定义排序函数 其他Set,如HashSet 只需要重新定义hascode和equals函数,方便去重即可 Java API针对集合类型排序提供了两种支...
  • likika2012
  • likika2012
  • 2014年01月21日 11:04
  • 569

C#中List或其它集合对象排序方法的一点理解

因为这个是老生常谈的话题了吧,所以过多的其它代码粘贴或拷贝就不做太多,只谈谈这段时间为了解决项目特别功能而用到的基础排序知识!          在项目中进行数据排序是非常常见的,所以今天做个备注,...
  • jetsu
  • jetsu
  • 2017年03月10日 11:29
  • 635

java List集合中根据集合对象的属性值进行排序

//进行排序的实体对象 package com.compile; public class User {      String name;      String age;    ...
  • liqi_q
  • liqi_q
  • 2017年01月10日 16:05
  • 1901

Java集合对象排序测试

Java集合对象排序测试  Java API针对集合类型排序提供了两种支持:java.util.Collections.sort(java.util.List) java.util.Collectio...
  • andymu077
  • andymu077
  • 2009年01月13日 20:41
  • 1045
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java集合对象排序
举报原因:
原因补充:

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