Java Arrays类、Comparable、Comparator

1. Arrays

用来操作数组的一个工具类

2. Arrays类提供的常用方法

|----------------------------------------------------------------------|----------------------------------------|
| Arrays类提供的常用方法名 | 说明 |
| public static String toString(类型[] arr) | 返回数组的内容 |
| public static int[] copyOfRange(类型[] arr, 起始索引, 结束索引) | 复制数组(指定范围) [起始索引,结束索引) |
| public static copyOf(类型[] arr, int newLength) | 复制数组( int newLength 数组的长度多出来的会自动填默认值) |
| public static setAll(double[] array, IntToDouleFunction generator) | 把数组的原始数据改为新数据 |
| public static void sort(类型[] arr) | 对数组进行排序(默认是升序) |

java 复制代码

public static void main(String[] args) {
        //Arrays

        //public static String toString(类型[] arr)	 返回数组的内容
        int[] arr = {1,2,3,4,5,6,7,8,9};
        String s =  Arrays.toString(arr);
        System.out.println(s);//[1, 2, 3, 4, 5, 6, 7, 8, 9]

        //public static int[] copyOfRange(类型[] arr, 起始索引, 结束索引)	复制数组(指定范围) 前闭后开[起始索引,结束索引)
        int[] arr2 = Arrays.copyOfRange(arr,0,4);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]

        //public static copyOf(类型[] arr, int newLength)复制数组 int newLength 新数组的长度 多出来的会自动填默认值 少的话只会复制长度的部分
        int[] arr3 = Arrays.copyOf(arr,10);
        System.out.println(Arrays.toString(arr3));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
        int[] arr4 = Arrays.copyOf(arr,5);
        System.out.println(Arrays.toString(arr4));//[1, 2, 3, 4, 5]

        //public static setAll(double[] array, IntToDouleFunction generator)把数组的原始数据改为新数据
        double[] d = {99.3, 94.4, 93.5};
        Arrays.setAll(d, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                return new BigDecimal(d[value] + "") .multiply(new BigDecimal("0.1")).doubleValue(); //将 d数组的每一项*0.1并返回 double容易失真，所以使用BigDecimal
            }
        });
        System.out.println(Arrays.toString(d));//[9.93, 9.44, 9.35]

        //public static void sort(类型[] arr)	对数组进行排序(默认是升序)
        Arrays.sort(d);
        System.out.println(Arrays.toString(d));//[9.35, 9.44, 9.93]
}

3. Comparable、Comparator

(1) 自定义类(如Student)时不能使用 public static void sort(类型[] arr) 方法进行排序(程序不知道要根据什么进行排序)，会报错；有两种实现方法：Comparable接口或Comparator比较器

(2) Comparable:让该类对象实现Comparable(比较规则)接口，然后重写compareTo方法，自己制定比较规则

(3) 创建Comparator比较器接口的匿名内部类对象，自己制定比较规则；public static <T> void sort(t[] arr, Comparator<? super T> c) 对数组进行排序(支持自定义排序规则)

java 复制代码

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double score;

    public Student() {
    }

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

    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;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

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

//方式1. Comparable:让该类对象实现Comparable(比较规则)接口，然后重写compareTo方法，自己制定比较规则
    @Override
    public int compareTo(Student o) {
        //左边对象 大于 右边对象 返回正整数
        //左边对象 小于 右边对象 返回负整数
        //左边对象 等于 右边对象 返回0
        //如按照成绩排序 默认升序

        /*if (this.score > o.score) {
            return 1;
        }else if (this.score < o.score) {
            return -1;
        }else {
            return 0;
        }*/
        return Double.compare(this.getScore(), o.getScore());//升序

        //降序的话：
        //左边对象 大于 右边对象 返回负整数
        //左边对象 小于 右边对象 返回正整数
        //左边对象 等于 右边对象 返回0
       /* if (this.score > o.score) {
            return -1;
        }else if (this.score < o.score) {
            return 0;
        }else {
            return 0;
        }
        return Double.compare(o.getScore(), this.getScore());//降序
        */
    }
}


public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("卡莎", 18, 100);
        students[1] = new Student("泰坦", 19, 98);
        students[2] = new Student("伊泽", 17, 99);
        students[3] = new Student("璐璐", 21, 15);

        // public static void sort(类型[] arr)	对数组进行排序(默认是升序)
        /*Arrays.sort(students);
        System.out.println(Arrays.toString(students));//报错*/

        //实现自定义类排序的两种方式：
        //1. Comparable:让该类对象实现Comparable(比较规则)接口，然后重写compareTo方法，自己制定比较规则
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

        //2. 创建Comparator比较器接口的匿名内部类对象，自己制定比较规则；public static <T> void sort(t[] arr, Comparator<? super T> c) 对数组进行排序(支持自定义排序规则)
        //参数1：需要降序的数组
        //参数1：Comparator 比较器对象
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //降序的话：
                //左边对象 大于 右边对象 返回负整数
                //左边对象 小于 右边对象 返回正整数
                //左边对象 等于 右边对象 返回0
                /*if (o1.getScore() > o2.getScore()) {
                    return -1;
                }else if (o1.getScore() < o2.getScore()) {
                    return 0;
                }else {
                    return 0;
                }*/
                //return Double.compare(o1.getScore(), o2.getScore());//升序
                return Double.compare(o2.getScore(), o1.getScore());//降序
            }
        });
        System.out.println(Arrays.toString(students));

}