一、Arrays的概述

Arrays是操作数组的工具类

二、Arrays的常用方法

Arrays的常用方法基本上都被static静态修饰，因此在使用这些方法时，可以直接通过类名调用

1.toString

语法：Arrays.toString(数组)

用于将数组的元素转换为一个字符串，元素之间用逗号分隔，所有元素用[]包括。

注意：Arrays 类的 toString 方法来拼接或获取任何类型数组的字符串表示，包括基本数据类型数组和对象数组。对于对象数组，如果对象本身重写了 toString 方法，那么这些方法的实现将被用于生成字符串表示。

该方法可以用来展示数组的元素（因为如果直接输出数组名 则输出的是数组的地址）

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {
        // 1.Arrays.toString(数组) 将数组变成字符串
        int [] arr1=new int[]{1,2,3};
        String s1=Arrays.toString(arr1);
        System.out.println(s1);// [1, 2, 3]

        char [] arr2=new char[]{'a','b','c'};
        String s2=Arrays.toString(arr2);
        System.out.println(s2);// [a, b, c]

        String [] arr3=new String[]{"aaa","bbb","ccc"};
        String s3=Arrays.toString(arr3);
        System.out.println(s3);// [aaa, bbb, ccc]
        
        // Student类重写了toString方法 它的输出是"Student{name = " + name + ", age = " + age + "}"
        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr4=new Student[]{student1,student2,student3};
        String s4=Arrays.toString(arr4);
        System.out.println(s4);// [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}]

    }
}
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;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

2.binarySearch

语法：Arrays.binarySearch(数组，元素)；

返回查找元素的索引 前提是传入的数组必须是升序的

注意：

如果该元素存在 则返回他在数组中的索引值 

如果该元素不存在 则返回 -插入值-1

插入值是根据从小到大的顺序 该元素如果在数组中存在 它的索引值

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.binarySearch(数组,元素) 返回元素在数组中的索引
        int [] arr1=new int[]{1,2,3,4,5,6,7,8,9,10};
        int index1=Arrays.binarySearch(arr1,4);
        int index2=Arrays.binarySearch(arr1,10);
        int index3=Arrays.binarySearch(arr1,-1);
        System.out.println(index1);// 3  元素值为4在数组中的索引为3
        System.out.println(index2);// 9  元素值为10在数组中的索引为9
        System.out.println(index3);// -11 元素值在数组中不存在的索引为-插入值-1
        // 元素-1如果在数组(已经按照升序排列)存在 那么它的位置应该在0索引处 这就是它的插入值 再减一 得到它的索引
    }
}

3.copyOf

语法：Arrays.copyOf(老数组，新数组的长度)；

如果新数组的长度小于老数组的长度 则会部分拷贝（从左往右拷贝）

如果新数组的长度等于老数组的长度 则会完全拷贝

如果新数组的长度大于老数组的长度 不仅会完全拷贝 而且多余的部分通过该数组元素数据类型的默认值来填充

组合数据类型的默认值为null

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOf(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        int [] arr1=Arrays.copyOf(arr,2);
        int [] arr2=Arrays.copyOf(arr,4);
        int [] arr3=Arrays.copyOf(arr,8);
        // 如果直接输出数组名 则结果是数组的地址
        // 如果想要输出数组的元素 则可以通过Arrays.toString()
        System.out.println(arr1);// [I@4eec7777
        System.out.println(arr2);// [I@3b07d329
        System.out.println(arr3);// [I@41629346
        System.out.println(Arrays.toString(arr1));// [7, 8]
        System.out.println(Arrays.toString(arr2));// [7, 8, 9, 10]
        System.out.println(Arrays.toString(arr3));// [7, 8, 9, 10, 0, 0, 0, 0]

        String [] arr_1=new String[]{"AAA","BBB","CCC"};
        String [] arr4=Arrays.copyOf(arr_1,2);
        String [] arr5=Arrays.copyOf(arr_1,3);
        String [] arr6=Arrays.copyOf(arr_1,5);

        System.out.println(Arrays.toString(arr4));// [AAA, BBB]
        System.out.println(Arrays.toString(arr5));// [AAA, BBB, CCC]
        System.out.println(Arrays.toString(arr6));// [AAA, BBB, CCC, null, null]

        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr7=new Student[]{student1,student2,student3};
        Student [] arr8=Arrays.copyOf(arr7,4);
        System.out.println(Arrays.toString(arr8));
        // [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}, null]
    }
}
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;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

4.copyOfRange

语法：Arrays.copyOfRange(开始索引，结束索引)；

从开始索引拷贝到结束索引，包括开始索引，但是不包括结束索引

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOfRange(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        // 从索引0拷贝到索引3 不包括索引3
        int [] arr1=Arrays.copyOfRange(arr,0,3);
        System.out.println(Arrays.toString(arr1));// [7, 8, 9]

        String [] arr_1=new String[]{"AAA","BBB","CCC","DDD"};
        // 从索引1拷贝到索引3 不包括索引3
        String [] arr2=Arrays.copyOfRange(arr_1,1,3);
        System.out.println(Arrays.toString(arr2));// [BBB, CCC]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr_1_1=new Student[]{student1,student2,student3};
        // 从索引0拷贝到索引1 不包括索引1
        Student [] arr3=Arrays.copyOfRange(arr_1_1,0,1);
        System.out.println(Arrays.toString(arr3));
        // [Student{name = zhangsan, age = 20}]
    }
}
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;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

5.fill

语法：Arrays.fill(数组，新数据)；

用新数据填充数组的每一个元素，注意：是直接在原数组中进行覆盖

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.fill(数组,新数据)
        int [] arr=new int[]{7,8,9,10};
        Arrays.fill(arr,100);
        System.out.println(Arrays.toString(arr));// [100, 100, 100, 100]

        String [] arr1=new String[]{"AAA","BBB","CCC","DDD"};
        Arrays.fill(arr1,"ppp");
        System.out.println(Arrays.toString(arr1));// [ppp, ppp, ppp, ppp]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr2=new Student[]{student1,student2,student3};
        Arrays.fill(arr2,student3);
        System.out.println(Arrays.toString(arr2));
        // [Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}]
    }
}
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;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

6.sort

语法1：Arrays.sort(数组)；

对数组进行排序 默认是升序排序 注意：是直接在原数组中进行排序

补充：字符串之间的比较是基于它们每个字符的Unicode值进行的。

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组)
        int [] arr=new int[]{100,20,89,1,-10,65};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]

        String [] arr1=new String[]{"i","like","pen","and"};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));// [and, i, like, pen]
        
    }
}

语法2：Arrays.sort(数组，排序规则)；

Arrays.sort(数组, (o1,o2)->o2-o1); 

是降序排序 其中o1,o2可以换成任何变量名

总结：如果是(o1,o2)->o2-o1则是降序  如果是(o1,o2)->o1-o2则是升序 

根据排序规则对数组进行排序  只能给引用数据类型排序 如果要给基本数据类型排序 则需要将基本数据类型转化为对应的包装类

import java.util.Arrays;
import java.util.Comparator;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组,排序规则)
        Integer [] arr=new Integer[]{100,20,89,1,-10,65};
        /*
           这个降序是通过Comparator接口实现的 方法的参数是接口
           当我们要调用方法时 需要传入该接口的实现类
           Comparator接口的compare方法:
           该方法是用来排序的 需要传入两个参数 Integer o1 Integer o2
           规定数组的0索引为有序序列 0索引以后为无序序列
           o1表示从无序序列中遍历得到的每一个元素
           o2表示从有序序列的元素
           返回值为正 表示当前插入的元素小于有序序列的元素 放在后面
           返回值为负 表示当前插入的元素大于有序序列的元素 放在前面
        */
        // 未通过lamdba表达式简化
        Arrays.sort(arr,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1,Integer o2){
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));// [100, 89, 65, 20, 1, -10]
        
        // 通过lamdba表达式简化
        Arrays.sort(arr, (o1,o2)->o2-o1);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]
    }
}