Arrays类的使用

Arrays类

Arrays类的基本使用

// 1、public static String toString(类型[] arr): 返回数组的内容
        int[] arr=new int[]{11,12,13,14};
        System.out.println(Arrays.toString(arr));

        // 2、public static 类型[] copyOfRange(类型[] arr, 起始索引, 结束索引) ：拷贝数组（指定范围，包前不包后）
        int[] arr1 = Arrays.copyOfRange(arr, 1, 3);
        System.out.println(Arrays.toString(arr1));

        // 3、public static copyOf(类型[] arr, int newLength)：拷贝数组，可以指定新数组的长度。
        //**常用于数组的扩容
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr2));

        // 4、public static setAll(double[] array, IntToDoubleFunction generator)：把数组中的原数据改为新数据又存进去。
        double[] arr3=new double[]{128,100,278};
        // 把所有的价格都打八折，然后又存进去。，匿名内部类
        Arrays.setAll(arr3, new IntToDoubleFunction() {
            BigDecimal bigDecimal,discont;
            //applyAsDouble(value)中value获取的是当前数组的索引
            @Override
            public double applyAsDouble(int value) {
                //这里采用BigDecimal对象运算，避免失真
                bigDecimal=BigDecimal.valueOf(arr3[value]);
                discont=BigDecimal.valueOf(0.8);
            return bigDecimal.multiply(discont).doubleValue();
            }
        });
        System.out.println(Arrays.toString(arr3));

        // 5、public static void sort(类型[] arr)：对数组进行排序(默认是升序排序)
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));

Arrays类操作对象数组

如果数组中存储的是对象，如何排序？

对于利用Arrays类对对象数组排序时，需要在对象类中定义排序规则。

方式一：对象类实现Comparable接口，重写compareTo方法

 student[] students=new student[4];
        students[0] = new student("蜘蛛精", 23, 169.6);
        students[1] = new student("紫霞", 26, 163.8);
        students[2] = new student("紫霞", 26, 163.8);
        students[3] = new student("至尊宝", 24, 167.5);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

class student implements Comparable<student>{
    private String name;
    private int age;
    private double height;

    public student() {
    }

    public student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    /*
    在compareTo方法中定义规则
     */
    @Override
    public int compareTo(student o) {
        //约定1：左边对象（this）大于右边对象（o） 返回正整数
        //约定2：左边对象（this）小于右边对象（o） 返回负整数
        //约定1：左边对象（this）等于右边对象（o） 返回0
        //按年龄升序排序
//        if (this.getAge()>o.getAge()){
//            return 1;
//        }else if (this.getAge()<o.getAge()){
//            return -1;
//        }
        return this.getAge()-o.getAge();//升序
//        return -(this.getAge()-o.getAge());//降序
    }

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

方式二：使用Arrays.sort()方法，传入排序数组，以及Comparator的匿名内部类，实现compare方法定义规则

student[] students = new student[4];
        students[0] = new student("蜘蛛精", 23, 169.6);
        students[1] = new student("紫霞", 26, 163.8);
        students[2] = new student("紫霞", 26, 163.8);
        students[3] = new student("至尊宝", 24, 167.5);
        Arrays.sort(students, new Comparator<student>() {
            @Override
            public int compare(student o1, student o2) {
                //约定1：左边对象（this）大于右边对象（o） 返回正整数
                //约定2：左边对象（this）小于右边对象（o） 返回负整数
                //约定1：左边对象（this）等于右边对象（o） 返回0
                //按身高升序排序
//                if (o1.getHeight()>o2.getHeight()){
//                    return 1;
//                } else if (o1.getHeight() < o2.getHeight()) {
//                    return -1;
//                }
                //这里要注意，对于小数不要直接用return o1.getHeight()-o2.getHeight();
                //因为该函数返回的是一个整数，对于差值0.1的情况返回的是1，导致了结果不对
                return Double.compare(o1.getHeight(), o2.getHeight());//升序
                //return -Double.compare(o1.getHeight(), o2.getHeight());//降序
            }
        });
        System.out.println(Arrays.toString(students));