目录

目录

API                

        1.0 Arrays 类的说明

        1.1 Arrays 类中的 toString() 静态方法

        1.2  Arrays 类中的 copyOfRange(int[] original, int from, int to) 静态方法

        1.3 Arrays 类中的 copyOf(int[] original, int newLength) 静态方法

        1.4 Arrays 类中的 setAll(double[] array, IntToDoubleFunction generator) 静态方法

        1.5 Arrays 类中的 sort() 静态方法

        1.6 但是这个 sort() 方法是有弊端的，假设要求排列不是基本数据类型呢？（要求是 Student 类型的对象）

---

API                

        1.0 Arrays 类的说明

        Arrays 类是Java编程语言中的一个类，它提供了一些静态方法来操作数组。这些方法包括数组排序、搜索、填充等功能。这些静态方法可以直接通过 Arrays 类调用，而无需创建 Arrays 的实例。通过使用 Arrays 类的方法，我们可以更方便地对数组进行操作和处理。

        1.1 Arrays 类中的 toString() 静态方法

        通过 toString() 静态方法可以将数组内的全部内容以字符型串的形式输出，返回的是字符串类型。

代码如下：

import java.util.Arrays;

public class ArraysAPI {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        //调用静态方法
        String str = Arrays.toString(arr);
        System.out.println(str);
    }
}

运行结果如下：

        1.2  Arrays 类中的 copyOfRange(int[] original, int from, int to) 静态方法

        通过这个静态方法，复制一个可以指定起始位置到末尾位置的数组，返回相同类型的数组。

代码如下：

import java.util.Arrays;

public class ArraysAPI {
    public static void main(String[] args) {
            int[] arr = new int[]{1,2,3,4,5};
            int[] arr1 = Arrays.copyOfRange(arr,0,6);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果如下：

        要注意的是这指定的范围 [0,6）包前不包后，返回是一个新的数组。

        1.3 Arrays 类中的 copyOf(int[] original, int newLength) 静态方法

        通过这个方法可以拷贝数组，可以指定新数组的长度大小。

代码如下：

import java.util.Arrays;

public class ArraysAPI {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr1 = Arrays.copyOf(arr,3);
        System.out.println(Arrays.toString(arr1));
    }
}

代码如下：

        1.4 Arrays 类中的 setAll(double[] array, IntToDoubleFunction generator) 静态方法

        把数组中的数据进行修改之后又返回原数组，此静态方法并没有创建一个新的数组。该方法一共有两个参数，第一个参数为数组名，把要目标数据传进去。第二个参数为匿名内部类，需要重写里面的方法。

setAll(double[] array, IntToDoubleFunction generator) 静态方法内部的情况

具体来看看这静态方法的传参：

        这里可以简单的理解为，匿名内部类作为参数的时候，需要重写该父类、接口的抽象方法，那么就可以认为传入匿名内部类就是传递了一个自定义的方法。

代码如下：

import java.util.Arrays;
import java.util.function.IntToDoubleFunction;

public class ArraysAPI {

    public static void main(String[] args) {
      double[] arr = new double[]{1.0, 2, 9, 4, 5};
        Arrays.setAll(arr,new IntToDoubleFunction(){
            @Override
            public double applyAsDouble(int value) {
                return arr[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

        1.5 Arrays 类中的 sort() 静态方法

        通过这个方法可以让基本类型的数组按升序的方式排列。该方法并不会创建新的对象，而是直接在原始数组上进行排序。需要注意的是，sort() 方法直接修改了原始数组的顺序，而不是创建一个新的排序后的数组。因此，在使用 sort() 方法时要小心，以免意外修改了原始数组的顺序。如果需要保留原始数组，可以先创建一个副本数组，然后对副本数组进行排序。

代码如下：

import java.util.Arrays;

public class ArraysAPI {
    public static void main(String[] args) {
        int[] arr = new int[]{5,4,3,2,1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

    }
}

运行结果如下：

        1.6 但是这个 sort() 方法是有弊端的，假设要求排列不是基本数据类型呢？（要求是 Student 类型的对象）

        先介绍一个方式来解决这个问题。

        通过 sort() 静态方法传进一个相关的匿名内部类 new Comparator<Student>(){重写的方法}  ，可以简单的理解为，自定义一个用对象里面指定的内容进行比较，就需要重写方法，通过传入匿名内部类去重写自己定义方法。

代码如下：

定义 Student 类；

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

    public Student() {
    }

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

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

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

将学生的年龄进行按升序排列；

public class ArraysAPI {

    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("张三",32);
        students[1] = new Student("李四",21);
        students[2] = new Student("王五",20);
        students[3] = new Student("赵六",22);

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

    }
}

        这就可以自己定义用哪一个对象的内容进行对象与对象比较了。

---

---