java常用API-Arrays-sort自定义比较器

在java的常用工具类中有个sort方法可以用来排序，但是当我们需要比将一个装满对象的数组进行排序呢？那就需要用到自定义比较器

一、基本使用

功能：将数组排序（默认升序，支持lambda，泛型） 参数：

• sort(Object[] a[, int fromIndex, int toIndex])
• 或者sort(T[] a[, int fromIndex, int toIndex,] Comparator<? super T> c)
• parallelSort(Object[] a[, int fromIndex, int toIndex])
• 或者parallelSort(T[] a[, int fromIndex, int toIndex,] Comparator<? super T> c)

返回值：无

代码示例：

    @Test
    public void sortTest() {
        String[] str = {"abc", "add", "java", "hello", "javascript"};
        int[] ii = {1, 8, 99, 222, 35};

        System.out.println(Arrays.toString(str));
        System.out.println(Arrays.toString(ii));

        //单参数情况
        //Arrays.sort(str);  默认全排，字母会按照字母表顺序
        //Arrays.sort(ii);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 35, 99, 222]

        //多参数情况
        //Arrays.sort(str,2,4);   只排列指定范围内的
        //Arrays.sort(ii,2,4);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 99, 222, 35]

        //可传入lambda表达式(多参数情况可指定开始结束位置)
//        Arrays.sort(str, (a, b) -> b.compareTo(a));  //降序
//        System.out.println(Arrays.toString(str));  //[javascript, java, hello, add, abc]

二、自定义比较器

在指定比较器的时候，有两种方法

方式一：实现Comparable<>接口，重写compareTo()方法

需要排序的对象的类

package 常用API2;
//实现Comparable接口，并且是泛型接口，里面传入你要排序的对象
public class Studentsss implements Comparable<Studentsss> {
    private String name;
    private int age;

    public Studentsss() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    //重写compareTo() 方法，形参为泛型传入的
    public int compareTo(Studentsss o) {
//        约定 左边对象 大于 右边对象 返回正整数
//        约定 左边对象 小于 右边对象 返回整数
//        约定 左边对象 等于 右边对象 返回0
//        用if
        if(this.age>o.age){
            return 1;
        }else if(this.age<o.age){
            return -1;
        }
        return 0;

        // 简写形式 只要是返回的负数就是小于，是正整数就是大于，等于那么就是等于
//        return this.age-o.age;
  }

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

实现方式

public class ArraysSortDemo {
    public static void main(String[] args) {
        Studentsss stu1=new Studentsss("zhangsan",16);
        Studentsss stu2=new Studentsss("wangwu",89);
        Studentsss stu3=new Studentsss("lishi",23);
        Studentsss stu4=new Studentsss("hehie",54);
        Studentsss [] stus={stu1,stu2,stu3,stu4};
        //普通用 sort 进行比较
//        Arrays.sort(stus);//直接就会报错，应为程序不知道该到底用什么排序
//        System.out.println(Arrays.toString(stus));
        // 自定义方式一：实现Comparable 然后重写comparaTo方法，实现自定义比较规则
        Arrays.sort(stus);
        System.out.println(Arrays.toString(stus));
       
    }
}

方式二：创建Comparator比较器接口的匿名内部类对象

是可以使用lambda表达式的

Arrays.sort(stus, new Comparator<Studentsss>() {
    @Override
    public int compare(Studentsss o1, Studentsss o2) {
        return o1.getAge()-o2.getAge();
    }
});

 //用 lambda表达式
        Arrays.sort(stus, (o1,  o2) -> o1.getAge()-o2.getAge());
        System.out.println(Arrays.toString(stus));;

一般都是会用简写形式 只要是返回的负数就是小于，是正整数就是大于，等于那么就是等于

return this.age-o.age;

如果想要打印出对象数组排序后的情况，需要让对象重写toString方法就可以了，否则答应的是对象的地址

那么如果是比较小数怎么办？

当比较小数的时候可以用Double工具类的方法compare()

retrun Double.compare(o1.getHeight,o2.getHeight)