java 类排序

参考文档:Java排序: Comparator vs Comparable 入门

java类经常面临排序问题,据我所知:java提供comparable和comparator两种比较方式:

1. comparable方法需要排序的类继承comparable接口,重写compareTo函数,但是只能实现一种对比方法(重写compareTo一次),例如:

类定义如下:

class Student implements Comparable<Student> {
    private String name;
    private String key;
    private float score;
    private int age;

    public Student(String key, String name, float score, int age) {
        this.key = key;
        this.name = name;
        this.score = score;
        this.age = age;
    }

    @Override
    /*
    public int compareTo(Student ano) {
        if (this.score < ano.score)
            return -1;
        if (this.score > ano.score)
            return 1;
        else {
            if (this.age > ano.age)
                return 1;
            if (this.age < ano.age)
                return -1;
            else
                return 0;
        }//else
    }//compareTo
    */
    public int compareTo(Student ano){
        return (int)(this.score - ano.score);
    }
}

可以看到compareTo被我们重写,接下来我们可以运行排序,然后观察运行结果:

        Student stus[] = {new Student("lee","9527",22,80)
                ,new Student("zhang","1839",23,83)
                ,new Student("zhao","1284",21,80)};
        print(stus);
        Arrays.sort(stus);
        System.out.println("after sorted:");
        print(stus);

运行结果如下:

Student{name=‘9527‘, key=‘lee‘, score=22.0, age=80}
Student{name=‘1839‘, key=‘zhang‘, score=23.0, age=83}
Student{name=‘1284‘, key=‘zhao‘, score=21.0, age=80}
after sorted:
Student{name=‘1284‘, key=‘zhao‘, score=21.0, age=80}
Student{name=‘9527‘, key=‘lee‘, score=22.0, age=80}
Student{name=‘1839‘, key=‘zhang‘, score=23.0, age=83}

扩展:对元素是自定义类的List进行排序,自定List定义如下:

   public static List<Student> getStudents(){

        List<Student> col = new ArrayList<Student>();

        Random rand = new Random();
        String valkey;
        int valAge, valScore;
        String valName;
        for (int i = 0; i < 10; i++) {
            valkey = UUID.randomUUID().toString();
            valName = RandomStringUtils.random(10, 20, 110, true, true);
            valAge = rand.nextInt(80);
            valScore = rand.nextInt(80);
            col.add(new Student(valkey,valName, valAge, valScore));
        }

        return col;
    }

通过Collections.sort(List)方法进行排序:

     List<Student> grade = Student.getStudents();
        Iterator<Student> iter = grade.iterator();
        Collections.sort(grade);
        while(iter.hasNext()) {
            //iter.next();
            System.out.println(iter.next().toString());
        }

2. 有时候我们需要对多种关键字进行排序,那么我们需要通过实现java.util.Comparator来实现,我们可以对类Student任何字段进行排序。我们不需要改变类Student,类本身不用实现java.lang.Comparable或者是java.util.Comparator接口,代码如下:

class studSortByName implements Comparator<Student> {
    public int compare(Student st1, Student st2){
        return st1.getName().compareTo(st2.getName());
    }
}

接下来我们通过排序进行测验,我们必须使用Collections.sort(List, Comparator)这个方法而不是Collections.sort(List)方法:

public class ClassSort {
    public static void main(String []args) {
        //Student stu1 = new Student("wen", 90, 17);
        //Student stu2 = new Student("mike", 90, 18);
        //System.out.print("res:" + stu1.compareTo(stu2));
        List<Student> grade = Student.getStudents();
        Iterator<Student> iter = grade.iterator();
        //Collections.sort(grade);
        Collections.sort(grade,new StudSortByName());
        while(iter.hasNext()) {
            //iter.next();
            System.out.println(iter.next().toString());
        }

        /*Student stus[] = {new Student("lee","9527",22,80)
                ,new Student("zhang","1839",23,83)
                ,new Student("zhao","1284",21,80)};
        print(stus);
        Arrays.sort(stus);
        System.out.println("after sorted:");
        print(stus);
        */

    }

    public static void print(Student [] stus){
        for (int i = 0; i < stus.length; i++) {
            System.out.println(stus[i].toString());
        }
    }

}

附注可执行代码如下:

package comparable;

import java.util.*;

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.builder.Diff;

/**
 * Created by carl on 11/7/15.
 */
class Student implements Comparable<Student> {
    private String name;
    private String key;
    private float score;
    private int age;

    public Student(String key, String name, float score, int age) {
        this.key = key;
        this.name = name;
        this.score = score;
        this.age = age;
    }

    @Override
    /*
    public int compareTo(Student ano) {
        if (this.score < ano.score)
            return -1;
        if (this.score > ano.score)
            return 1;
        else {
            if (this.age > ano.age)
                return 1;
            if (this.age < ano.age)
                return -1;
            else
                return 0;
        }//else
    }//compareTo
    */
    public int compareTo(Student ano){
        return (int)(this.score - ano.score);
    }

    public static List<Student> getStudents(){

        List<Student> col = new ArrayList<Student>();

        Random rand = new Random();
        String valkey;
        int valAge, valScore;
        String valName;
        for (int i = 0; i < 10; i++) {
            valkey = UUID.randomUUID().toString();
            valName = RandomStringUtils.random(10, 20, 110, true, true);
            valAge = rand.nextInt(80);
            valScore = rand.nextInt(80);
            col.add(new Student(valkey,valName, valAge, valScore));
        }

        return col;
    }

    public String getName(){
        return name;
    }

    public float getScore() {
        return score;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=‘" + name + ‘\‘‘ +
                ", key=‘" + key + ‘\‘‘ +
                ", score=" + score +
                ", age=" + age +
                ‘}‘;
    }
}//Student

class StudSortByName implements Comparator<Student> {
    public int compare(Student st1, Student st2){
        return st1.getName().compareTo(st2.getName());
    }
}

public class ClassSort {
    public static void main(String []args) {
        //Student stu1 = new Student("wen", 90, 17);
        //Student stu2 = new Student("mike", 90, 18);
        //System.out.print("res:" + stu1.compareTo(stu2));
        List<Student> grade = Student.getStudents();
        Iterator<Student> iter = grade.iterator();
        //Collections.sort(grade);
        Collections.sort(grade,new StudSortByName());
        while(iter.hasNext()) {
            //iter.next();
            System.out.println(iter.next().toString());
        }

        /*Student stus[] = {new Student("lee","9527",22,80)
                ,new Student("zhang","1839",23,83)
                ,new Student("zhao","1284",21,80)};
        print(stus);
        Arrays.sort(stus);
        System.out.println("after sorted:");
        print(stus);
        */

    }

    public static void print(Student [] stus){
        for (int i = 0; i < stus.length; i++) {
            System.out.println(stus[i].toString());
        }
    }

}
时间: 2024-10-10 02:52:39

java 类排序的相关文章

SDUT 1196-排序问题(java类排序)

排序问题 Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 输入10个整数,将它们从小到大排序后输出,并给出现在每个元素在原来序列中的位置. 输入 输入数据有一行,包含10个整数,用空格分开. 输出 输出数据有两行,第一行为排序后的序列,第二行为排序后各个元素在原来序列中的位置. 示例输入 1 2 3 5 4 6 8 9 10 7 示例输出 1 2 3 4 5 6 7 8 9 10 1 2 3 5 4 6 10 7 8 9 Ar

Java 数组工具类排序,最大值最小值等

public class ArrayUtils{ /** * 返回数组最大值 * * @param a * @return */ public static int max(int[] a){ // 返回数组最大值 int x; int aa[]=new int[a.length]; System.arraycopy(a,0,aa,0,a.length); x=aa[0]; for(int i=1;i<aa.length;i++){ if(aa[i]>x){ x=aa[i]; } } retu

最最常用的 100 个 Java 类(转)

大部分的 Java 软件开发都会使用到各种不同的库.近日我们从一万个开源的 Java 项目中进行分析,从中提取出最常用的 Java 类,这些类有来自于 Java 的标准库,也有第三方库.每个类在同一个项目中只计数一次,下面的列表中显示前 100 名的类. 以下列表中按使用最多的类进行排序,第三个数值表示 10000 个项目里使用到该类的项目数,而完整的列表请看 here. java.util.ArrayList(6958) java.io.IOException(6866) java.util.

最常用的 100 个 Java 类

大部分的 Java 软件开发都会使用到各种不同的库.近日我们从一万个开源的 Java 项目中进行分析,从中提取出最常用的 Java 类,这些类有来自于 Java 的标准库,也有第三方库.每个类在同一个项目中只计数一次,下面的列表中显示前 100 名的类. 以下列表中按使用最多的类进行排序,第三个数值表示 10000 个项目里使用到该类的项目数,而完整的列表请看 here. java.util.ArrayList(6958) java.io.IOException(6866) java.util.

详谈排序算法之选择类排序(两种方法实现堆排序)

   今天我们再来讨论一下选择类排序,选择类排序分为:简单排序,树形选择排序和堆排序.但我们主要说的是简单和堆排序两个,因为树形选择排序使用了较多的辅助空间,以及和∞进行多余比较,为弥补树型选择排序的这些缺点, J.W.J.Williams 在 1964 年提出了进一步的改进方法,即堆排序.对于我个人而言..一开始并不是很理解它的算法思想,纠结了许久.在网上查找资料的时候发现这位大神的文章思路十分清晰,而且把创建堆以及堆化数组的算法讲解的十分详细.如果有不明白堆排序思路的,可以先看看这篇文章~堆

java编程排序之自定义类型的集合,按业务需求排序

自定义引用类型放入集合中,按实际业务需求进行排序的两种思路 第一种思路: (1)自定义实体类实现java.lang.Comparable接口,重写public int compareTo(Object obj)方法.自定义业务比较规则 (2)利用java.util.Collections类的静态方法sort(List<自定义类型> list)进行排序(默认升序)或者.自己编写排序工具类.冒泡+compareTo(obj)方法 第二种思路 (1)自己编写业务比较规则类.实体类不用实现任何借口.业

使用JAVA进行排序

利用JAVA完成排序 当我们在进行数据库进行查询的时候,当需要按某个字段来进行排序的时候,可以使用SQL语句来完成排序,可以升序,也可以降序.JAVA中的Collections类也可以完成这种操作,SQL的用法和这种集合工具类的操作,可以用于不同的情况中,至于怎么用,可以根据业务场景来选择,下面我罗列出具体的代码,大家可以参考. 1)创建工程名为sort的JAVA工程 创建包结构: 创建User类: 1 package com.sunyard.bean; 2 3 /** 4 * <p> 5 *

Java类集(List,Vector,map……) (1)

1.1在介绍类集框架之前,先来思考这样一个问题,如果现在要保存一组对象,按照初级的做法只能使用对象数组,但是使用对象数组操作本身有一个限制,就是数组有长度的限制:而通过一些数据结构的操作,如链表,则可以完成动态对象数组的操作,但是这些如果全部由开发人员来做,肯定非常麻烦. 类集框架恰好解决了以上问题,所谓的类集就是一个动态的对象数组,是对一些实现好的数据结构进行了包装,这样在使用时就会非常方便,而且最重要的是类集框架本身不受对象数组长度的限制. 类集框架被设计成拥有以下几个特性: 1.这种框架是

Java集合排序及java集合类详解--(Collection, List, Set, Map)

1         集合框架 1.1         集合框架概述 1.1.1         容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情. 举例来说,假设要存储许多雇员,不同的雇员的区别仅在于雇员的身份证号.我们可以通过身份证号来顺序存储每个雇员,但是在内存中实现呢?是不是要准备足够的内存来存储1000个雇员,然后再将这些雇员逐一插入?如果已经插入了500条记录,这时需要插入一个身份证号较低的新雇员,该怎么办呢?是在内