Arrays是JDK提供的专门操作数组的工具类，里面提供了一些静态的方法来操

1.static void toString(数组);//把数组转化为字符串

String[] str= {"张三","李四","王五","赵六","钱七","王八"};
        String s= Arrays.toString(str);
        System.out.println(s);

2.static void sort(数组);//对基本数据类型进行排序。排序(默认是升序),如果改变默认排序方式，不能使用基本数据类型。如果给引用数据类型排序则需要实现comparable类型或者创建comparator类型对象

Integer[] array= {1,23,4,34,13,345,52,214};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));

利用Collections.reverseOrder()方法进行排序（倒序）
        Arrays.sort(array,Collections.reverseOrder());
        for(Integer i:array) {
            System.out.println(i);
        }

static void sort(int[] a,int b,int c);//排序从b-c,左闭右开
        Arrays.sort( array,0,3);
        System.out.println(Arrays.toString(array));

引用数据类型

1创建Comparator对象

Person[] stus = new Person[5];
        stus[0] = new Person(80);
        stus[1] = new Person(70);
        stus[2] = new Person(90);
        stus[3] = new Person(30);
        stus[4] = new Person(100);
        
        //使用了匿名内部类的形式。Comparator也是一个函数式接口
        Comparator<Person> c = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.score-o1.score;
            }
        };
        
        Arrays.sort(stus,c);
        String s = Arrays.toString(stus);
        System.out.println(s);
    }
}

class Person{
    public int score;
    public Person(int score) {
        super();
        this.score = score;
    }
    @Override
    public String toString() {
        return "Person [score=" + score + "]";
    }
}

2实现Comparable

Student[] stu=new Student[4];
        stu[0]=new Student(20);
        stu[1]=new Student(40);
        stu[2]=new Student(60);
        stu[3]=new Student(10);
        
        System.out.println(Arrays.toString(stu));
    }
}

class Student implements Comparable<Student>{
    private int age;

    public Student(int age) {
        super();
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
  }

3.static List asList(T...a);//按照动态参数，创建一个ArrayList集合，不适用于基本数据类型，不能增加和删除

int[] arr= {11,12,13,14,15};
         List<int[]> asList = Arrays.asList(arr);
         System.out.println(asList.size());
        
        Integer[] array= {11,12,13,14,15};
        List<Integer> asList2 = Arrays.asList(array);
        System.out.println(asList2.size());

相同数组，一个是基本数据类型，一个是包装类型，元素个数不一样
 * 源代码
*  @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }
    通过源码，我们可以看出来asList方法接收一个泛型化的可变参数列表，
    当传入一个基本数据类型的数组的时候，它会把这个基本数据类型的数组当做一个参数传入，
    然后返回一个新的ArrayList，其中arr就是这个基本类型的数组，
    所以可变参数列表只接收了一个参数就是数组。
    当传入一个包装类型对象数组的时候，其中数组中的每一个元素都是一个对象，
    所以可变参数列表会传入五个对象类型Integer，
    还有一点是因为基础数据类型是不能被泛型化的，所以才会导致上面代码运行的结果。

4.static int binarySearch(Object[] a,Object key);//搜索(二分查找法),。返回查询元素的索引值，  二分查找的思路是从有序（从小到大）数组的中间位置开始查找，如果中间位置的数小于查找的目标值，则查找数组中间值右侧的部分，
 如果中间位置的数大于查找的目标值，则查找数组中间值左侧的部分，
 如果相等，则返回当前的下标，如果没有找到则返回一个负数。

int[] i= {1,3,4,63,643};
        int j = Arrays.binarySearch(i,1);
        System.out.println(j);