`

java对象排序

    博客分类：
  • java
Java算法IDEACC++ 
阅读更多

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.comparable;

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-3-29 22:21:19
* Company: LavaSoft(http://lavasoft.blog.51cto.com )
* 要排序的元素对象
*/
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(http://lavasoft.blog.51cto.com )
* 通过实现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(http://lavasoft.blog.51cto.com )
* 要排序的元素对象
*/
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(http://lavasoft.blog.51cto.com )
* 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(http://lavasoft.blog.51cto.com )
* 通过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这样处理排序目的就是对容器元素排序有一个统一的方式，以简化编程。
 
当然也可以自己通过别的算法进行元素排序，在此不做讨论。


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/woshiliukui/archive/2009/07/27/4382866.aspx

分享到：
| java中对于复杂对象排序的模型及其实现
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 对象 排序

    总的来说，Java对象排序是通过实现`Comparable`接口或使用`Comparator`来完成的。理解这两个接口的用法，并熟练掌握`Collections.sort()`和`Arrays.sort()`的使用，是成为熟练Java开发者的必备技能。在实际编程中，...

    Java 对象排序详解.rar_java 对象排序_对象_排序

    在Java编程语言中，对象排序是一项关键操作，特别是在处理集合数据结构时。本文将深入探讨如何对ArrayList、HashSet、TreeSet以及数组中的对象进行排序。理解这些排序机制对于编写高效且可维护的代码至关重要。 ...

    java 按对象属性排序

    这里我们探讨的主题是如何根据对象的属性进行排序，结合提供的`Simple.java`和`User.java`文件，我们可以假设这是一个关于自定义对象排序的例子。下面将详细解释相关知识点。 1. **Comparable接口**： Java中的`...

    Java对象排序中文排序SortedSet排序使用和源码讲

    本主题将深入探讨如何使用SortedSet接口来实现Java对象的中文排序，并通过源码分析理解其工作原理。 首先，SortedSet是Java集合框架中的一个接口，它继承自Set接口并添加了排序的特性。SortedSet的主要实现类有...

    the-array-object-Java-sort.rar_java 对象排序

    总的来说，Java中的对象排序是一个核心技能，理解并掌握`Comparator`接口的使用对于提升代码的可读性和可维护性至关重要。通过上述小实例，你应该能掌握在Java中如何对对象数组进行降序排序，为今后的编程实践打下...

    java 中文姓氏 排序

    Java 对象排序（使用 Comparator） 如果我们需要对一个对象列表中的某个字段（如年龄）进行排序，可以创建一个 `Comparator` 实现。 ```java import java.util.*; import java.text.*; public class ...

    java对象排序需要导入的包

    commons-beanutils-1.8.3.jar commons-collections-3.2.1.jar commons-logging-1.1.3.jar这三个包都是从apache官网下的，含源码、api文档

    JAVA 对象数组按照多个属性进行排序

    总结一下，当需要对Java对象数组按多个属性排序时，我们可以： 1. 实现`Comparator`接口并自定义`compare()`方法。 2. 使用lambda表达式或方法引用来创建`Comparator`实例，使代码更加简洁。 3. 对于数组，使用`...

    java List中对象多属性排序及各属性排序设置

    本文将深入探讨如何在Java的List中对包含多个属性的对象进行排序，并且支持动态设置每个属性的排序方式。这个功能的实现是通过泛型和自定义比较器（Comparator）来完成的，对于复杂的数据排序需求具有很高的灵活性。...

    Java 对象属性map排序示例

    本示例将详细介绍如何对Java对象属性Map进行排序。 首先，了解Map的基本类型。Java提供了HashMap、TreeMap等实现Map接口的类。HashMap是非排序的，而TreeMap是基于红黑树数据结构，会按照键的自然顺序或者自定义...

    面向对象java排序包

    【面向对象Java排序包】是基于Java编程语言设计的一个专门用于处理排序问题的软件组件。这个包充分体现了面向对象的设计原则，将数据结构、算法和业务逻辑封装在独立的对象中，提高了代码的可读性和可维护性。它不仅...

    Java对象排序、中文排序、SortedSet排序使用和源码讲解

    在Java中，对象排序主要是通过对象实现`Comparable`接口或者使用自定义的`Comparator`来完成的。 1. **对象排序**： 当对象需要进行排序时，它应该实现`Comparable`接口。`Comparable`接口有一个`compareTo()`方法...

    java List 排序 Collections.sort

    对于大型数据集，`Collections.sort()`通常能提供很好的性能，但如果需要对大量不可变对象或已排序的列表进行排序，使用`TreeSet`或`LinkedHashSet`等集合类型可能会更高效，因为它们在底层实现了红黑树结构，插入和...

    Java面向对象思想的排序方法

    总的来说，Java中的面向对象思想为实现各种排序算法提供了灵活的结构和强大的功能。通过封装、继承和多态，我们可以构建出易于理解和维护的代码，同时适应不同的排序需求。在开发过程中，理解并熟练运用这些面向对象...

    java 集合分组与排序

    下面我们将深入探讨如何在Java中实现集合的分组与排序。 1. **集合分组**： 集合分组通常涉及到`GroupingBy`操作，这在Java 8引入的流（Stream）API中得到了很好的支持。`Collectors.groupingBy`方法允许我们将...

    Java实现二叉排序树

    在Java中实现二叉排序树，我们通常会定义一个`Node`类来表示树的节点，它包含键、值以及左右子节点的引用。例如： ```java class Node { int key; Object value; Node left, right; public Node(int item) { ...

    List对象排序通用方法

    List对象排序通用方法List对象排序通用方法List对象排序通用方法List对象排序通用方法

    JAVA冒泡排序和快速排序算法

    在JAVA中，实现这两种排序算法可以使用面向对象的特性，创建一个类如`MaopaoKuaisu.java`，在这个类中定义两个方法，分别实现冒泡排序和快速排序。类的结构可能如下： ```java public class MaopaoKuaisu { public...

    java常用代码

    16.CompareObj.java 对象排序实现 17.SetAndList.java set的简单操作极其hashcode应用 18.Singleton.java java设计模式之单例模式 19.Factory.java 设计模式之工厂模式 20.Swing.java 介绍了java的图形应用 ...

Magicbox
Global site tag (gtag.js) - Google Analytics