JAVA基础｜常用API-Arrays

一. 说明

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

二. 常用的方法

方法名	说明
public static String toString(类型[] arr)	返回数组的内容
public static int[] copyOfRange(类型[] arr,起始索引,结束索引)	拷贝数组（指定范围）
public static copyOf(类型[] arr,int newLength)	拷贝数组
public static setAll(double[] array,IntToDoubleFunction generator)	把数组中的原数据改为新数据
public static void sort(类型[] arr)	对数组进行排序（默认是升序排序）

三. 使用

1. 返回数组的内容

int[] arr = {10, 20, 30, 40, 50};
System.out.println(Arrays.toString(arr));

2. 拷贝指定范围内的数组内容

int[] arr2 = Arrays.copyOfRange(arr,1,4);
System.out.println(Arrays.toString(arr2));

3. 拷贝数组，可以指定新数组的长度

int[] arr3 = Arrays.copyOf(arr,10);
System.out.println(Arrays.toString(arr3));

4. 把数组中的原数据改为新数据又存进去

例如，我们写个案例，要求将数组内的所有数据打8折之后再存进去：

double[] prices = {99.8,128,100};
//把所有的加个都打八折，然后又存进去
Arrays.setAll(prices, new IntToDoubleFunction() {
      @Override
      public double applyAsDouble(int value) {
            return prices[value] * 0.8;
      }
});
System.out.println(Arrays.toString(prices));

5. 对数组进行排序（默认是升序排序）

Arrays.sort(prices);
System.out.println(Arrays.toString(prices));

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

例如，我们有个学生类，其中包含成员属性：姓名，身高，年龄。我们创建了一个学生对象的数组，那么如何对该数组进行排序呢？

import java.util.Arrays;

public class ArrayTest2 {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("小关",180.0,18);
        students[1] = new Student("小王",179.1,19);
        students[2] = new Student("花魁",127.2,14);
        students[3] = new Student("皇上",124.1,18);

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

public class Student {
    private String name;
    private double height;
    private int age;

    public Student() {
    }
    public 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;
    }
}

 

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

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

    //制定比较规则
    @Override
    public int compareTo(Student o) {
        //约定1：认为左边对象 大于 右边对象，请您返回正整数
        //约定2：认为左边对象 小于 右边对象，请您返回负整数
        //约定3: 认为左边对象 等于 右边对象，请您一定返回0
        //按照年龄生序排序
        if (this.age > o.age) {
            return 1;
        } else if (this.age < o.age) {
            return -1;
        }
        return 0;
    }

    public Student() {
    }
    public 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;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", height=" + height + ", age=" + age + "]";
    }
}

在这里，我们进行了以下修改：

1. 让Student类实现了Comparable接口，要注意这里的Comparable是泛型接口，所以要在后面加上<Student>
2. 重写Comparable中的compareTo方法
3. 其实上述步骤已经完成了自定义排序，但由于排序后打印出来的内容是对象的地址，所以我们重写了toString方法

其实，我们在重写compareTo方法的时候没必要写那么多，只需要写一个

return this.age-o.age;

如果左边的对象大于右边的对象，自然就返回正整数，小于，等于的时候同理。

要注意，这么写只是因为age是int类型的变量，所以能得到整数，如果是身高啥的这种double型的就不能这么写了。

那么我们如果想要降序排序的话，直接把掉个头，让o.age-this.age就行了，或者加个符号！

 

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

public static <T> void sort(T[] arr,Comparator<? super T>c) 对数组进行排序（支持自定义排序规则）

参数一：需要排序的数组，参数二：Comparator比较器对象（用来制定对象的比较规则）

Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if (o1.getHeight() > o2.getHeight()) {
                    return 1;
                } else if (o1.getHeight() < o2.getHeight()) {
                    return -1;
                }
                return 0;
            }
        });

这里重写的是compare方法，注意Comparator是一个接口，所以这里要用到他的对象得采用匿名内部类。

这里也可以这么简写：

return Double.compare(o1.getHeight(),o2.getHeight());

用的包装类的比较方法。