内部排序与外部排序

1.内部排序

Comparable接口。若一个类实现了Comparable接口，表明该类具有天然的可比较特性。（和其它类比）

int compareTo() 
=0，表示两对象相等；
>0，表示当前对象大于目标对象；
<0，表示当前对象小于目标对象。

内部比较代码示例：

package com.xunpu.a_7_29;
//内部排序
// 内部比较器 该类继承Comparable接口并覆写了compare(o)
//对Person类按照年龄升序排序
class Person implements Comparable{
    private int age;
    private String name;

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Person p= (Person) o;
        return Integer.compare(this.age,p.age);
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

public class TestCompare {
    //内部排序工具类
    public static void sort(Object[] obj){
        //传入一个对象数组，对对象进行排序
        Comparable[] ce= (Comparable[]) obj;
        for(int i=0;i<ce.length-1;i++){
            for(int j=0;j<ce.length-i-1;j++){
                if(ce[j].compareTo(ce[j+1])>0){
                    //交换位置
                    Comparable temp=ce[j];
                    ce[j]=ce[j+1];
                    ce[j+1]=temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Person[] parr=new Person[4];
        parr[0]=new Person(19,"张三");
        parr[1]=new Person(20,"李四");
        parr[2]=new Person(5,"王五");
        parr[3]=new Person(10,"史诗");
        sort(parr);
        for(Person p:parr){
            System.out.println(p.toString());
        }
    }

}

2.外部排序（推荐）

Comparator接口。该类本身不具备天然的比较特性，专门有一个类来比较两个Person对象的大小关系（Person的比较器）。

int compare(Object o1,Object o2)
-1：o1>o2（降序）
1：o1<o2（升序）
0：两个对象相等。

外部比较代码示例：

package com.xunpu.a_7_29;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

//外部排序
//专门定义一个比较对象的类并且该类实现Comparator接口，覆写compare()比较两个对象。
class Student {
    private int age;
    private String class_name;
    
    public int getAge() {
        return age;
    }
    public Student(int age, String class_name) {
        this.age = age;
        this.class_name = class_name;
    }
    public String getClass_name() {
        return class_name;

    }


    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", class_name='" + class_name + '\'' +
                '}';
    }

}
//定义Student的比较器  按照年龄升序、班级降序排序
class StuCompare implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        Student p1= (Student) o1;
        Student p2= (Student) o2;
        int ageRes=Integer.compare(p1.getAge(),p2.getAge());
        if(ageRes!=0){
            return ageRes;
        }else{
            return -1*p1.getClass_name().compareTo(p2.getClass_name());
        }
    }
}
public class TestOutCompare {
    public static void main(String[] args) {
        //第一种写法
        Student[] students=new Student[5];
        students[0]=new Student(12,"class1");
        students[1]=new Student(3,"class2");
        students[2]=new Student(20,"class3");
        students[3]=new Student(16,"class2");
        students[4]=new Student(12,"class4");

        Arrays.sort(students,new StuCompare());
        for(Student s:students){
            System.out.println(s);
        }
        System.out.println("=========================");
//第二种写法，使用TreeSet：
        Set<Student> set=new TreeSet<>(new StuCompare());
        for(int i=0;i<5;i++){
            set.add(students[i]);
        }
        for(Student s:set){
            System.out.println(s);
        }
    }
}