使用Arrays.sort、Comparable、Comparator实现对象数组排序

1.如何输出对象数组内容？

需要在对象的类中重写toString方法

//重写方法
    @Override
    public String toString() {
        ret![请添加图片描述](https://img-blog.csdnimg.cn/503f7f999cd845a7bae729fff4ba1699.png)
rn "test_Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }

然后在mian中使用Arrays.toString(students)输出

//Arrays.toString(students)输出的是对象数组的地址
        // 如果想要输出内容，需要在数组类中重写toString方法
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

2.如何对数组中的对象排序

• 1.方法一

让该对象的类实现Comparable（比较规则）接口，然后重写compareTo方法，自己来指定比较规则。

• ArraysTest类

package com.API1;

import java.util.Arrays;

public class test_ArraysTest2 {
    public static void main(String[] args) {
        //目标：掌握如何对数组中的对象进行排序
        test_Student[] students = new test_Student[3];
        students[0]=new test_Student("李蕾",169.5,21);
        students[2]=new test_Student("许嵩",182,32);
        students[1]=new test_Student("张晚意",181.9,27);

        Arrays.sort(students);

        //Arrays.toString(students)输出的是对象数组的地址
        // 如果想要输出内容，需要在数组类中重写toString方法
        System.out.println(Arrays.toString(students));
    }
}

• Student类

排序后，如果在ArraysTest类中输出Arrays.toString(students),出来的是各个地址的字符串类型，则需要在Student类中重写toString方法才能得到对象数组的内容字符串。

package com.API1;
//泛型接口
public class test_Student implements Comparable<test_Student>{
    private String name;
    private double height;
    private int age;

    //在这个重写方法中写比较方法
    @Override
    public int compareTo(test_Student o) {
        //约定1：左边对象 > 右边对象==》返回任意正整数
        //约定2：左边对象 < 右边对象==》返回任意负整数
        //约定3：左边对象 = 右边对象==》一定返回0


        //第一种形式
//        if(this.age > o.getAge())
//            return 1;
//        else if(this.age < o.getAge())
//            return -1;
//        else
//            return 0;

        //第二种形式
        //return this.age-o.getAge();//升序
        return o.getAge()-this.age;//降序
    }

    //重写方法
    @Override
    public String toString() {
        return "test_Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }

    public test_Student() {
    }

    public test_Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

• 2.方法二

使用下面这个sort方法，创建Comparator比较器接口的匿名内部类对象，然后自己制定比较规则。

使用：public static void sort(T[] arr,Comparator<? super T> c)；第二个参数是匿名内部类，compare是这个内部类中的抽样方法，重写这个方法，这个方法的作用是：将对象数组中的内容两两比较。

Arraystest类

package com.API1;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

public class test_ArraysTest2 {
    public static void main(String[] args) {
        //目标：掌握如何对数组中的对象进行排序
        test_Student[] students = new test_Student[3];
        students[0]=new test_Student("李蕾",169.5,21);
        students[2]=new test_Student("许嵩",182,32);
        students[1]=new test_Student("张晚意",181.9,27);

        //Arrays.sort(students);

        //Arrays.toString(students)输出的是对象数组的地址
        // 如果想要输出内容，需要在数组类中重写toString方法

        //public static <T> void sort(T[] arr,Comparator<? super T> c)
        //参数一：需要排序的数组
        //参数二：Comparator比较器对象（用来制定对象的比较规则）
        // comparator是接口类，而接口不能定义对象，所以第二个参数是器匿名内部类（本质就是一个类，并会立即创建一个子类对象）,compare是匿名内部类的抽象方法
        Arrays.sort(students, new Comparator<test_Student>() {
            @Override
            public int compare(test_Student o1, test_Student o2) {
                //比较规则：左边对象 o1   右边对象 o2
                //约定1：认为左边对象 大于 右边对象 请您返回正整数
                //约定2：认为左边对象 小于 右边对象 请您返回负整数
                //约定3：认为左边对象 等于 右边对象 请您一定返回0

                //因为这个返回值是int型，而比较的是double型，不能再用return o1.getHeight() - o2.getHeight();
                //第一种方法
                if(o1.getHeight() > o2.getHeight())
                    return 1;
                else if(o1.getHeight()<o2.getHeight())
                    return -1;
                else
                    return 0;

                //第二种方法：和第一种效果相同
                //return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

• 运行结果
  

Double.compare(o1.getHeight(),o2.getHeight());是比较这两个double型参数的大小，前大后，返回正数；前小后，返回负数；前等后，返回0。