[数据结构与算法]Arrays类的常用API

一、简述Arrays 的用法（初级）

（1）返回数组内容的toString(数组)

（2）排序的API（默认自动对数组元素进行升序排序）----------------------sort方法

（3）二分搜索技术（前提是数组必须排好序才支持，否则会出现bug

（4）返回不存在元素的规律 ---------------------返回应存在的位置的负数

? ? ? ? 注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug

package Arrays;

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        //目标：学会使用Arrays类的常用API，并理解其原理
        int[] arr = {10,2,55,23,24,100};
        System.out.println(arr);

        //1.返回数组内容的toString(数组)
        String rs = Arrays.toString(arr);
        System.out.println(rs);//（1）第一种方法 ， 两行

        System.out.println(Arrays.toString(arr));//（2）第二种方法（合并！！！）（优雅）

        System.out.println("------------------------------");
        //2.排序的API（默认自动对数组元素进行升序排序） -------------sort方法
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));/**API调用工程师!!!😜*/

        //3.二分搜索技术（前提是数组必须排好序才支持，否则会出现bug）
        int index = Arrays.binarySearch(arr,55);
        System.out.println(index);//4

        //4.返回不存在元素的规律          返回应存在的位置的负数
        int index1 = Arrays.binarySearch(arr,22);
        System.out.println(index1);//-3------------意思是22应该在第二个位置的后面   （-（2）-1）（应在第三个位置）

        //注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug
        int[] arr1 = {12,36,34,25,13,24,234,100};
        System.out.println(Arrays.binarySearch(arr1,36));//-7

    }
}?

二、进阶版：

?1.降序排序（自定义比较器对象，只能支持引用类型的排序）

? 对一个对象含有多个内容进行比较

? 浮点型比较排序时需要特殊对待

return o1.getAge() - o2.getAge();升序排序 按年龄排

return o2.getAge() - o1.getAge();//降序排序

return Double.compare(o1.getHeight() , o2.getHeight());//升序排序

?

package Arrays;

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

public class ComparatorDemo {
    public static void main(String[] args) {
        //目标：自定义数组的排序规则：Comparator 比较器对象
        //1.Arrays的sort方法对于有值特性的数组是默认升序排序的
        int[] ages = {34,12,42,23};
        Arrays .sort(ages);
        System.out.println(Arrays.toString(ages));

        //2.需求：降序排序！（自定义比较器对象，只能支持引用类型的排序）
        Integer[] ages1 = {34,12,42,23};
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("--------------------");
        Student[] students = new Student[3];
        students[0] = new Student("吴",18,162.5);
        students[1] = new Student("季",19,172.5);
        students[2] = new Student("天",20,182.5);
        System.out.println(Arrays .toString(students ));

        //Arrays.sort运行会直接崩溃（不知道以哪个为标准，来进行排序）
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //return o1.getAge() - o2.getAge();//升序排序   按年龄排
                //return o2.getAge() - o1.getAge();//降序排序
                return Double.compare(o1.getHeight() , o2.getHeight());//升序排序
                /**比较浮点型必须这样写！！！（见上）*/
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

System.out.println("---------------第二个包----------------");

package Arrays;

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

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    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 double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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