Arrays工具类

Arrays

​ 操作数组的工具类

方法名	说明
public static String toString(数组)	把数组拼接成一个字符串
public static int binarySearch(数组,查找的元素)	二分查找法查找元素
public static int[] copyOf(原数组,新数组长度)	拷贝数组
public static int[] copyOfRange(原数组,起始索引,结束索引)	拷贝数组（指定范围）
public static void fill(数组,元素)	填充数组
public static void sort(数组)	按照默认方式进行数组排序
public static void sort(数组,排序规则)	按照指定的规则排序

package com.zhuixun.demo;

import javax.sound.midi.Soundbank;
import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author： zhuixun
 * @Date: 2023/1/2 21:34
 * @Version 1.0
 */
public class MyArrayDemo {

    public static void main(String[] args) {
        //toString 把数组编程字符串
        System.out.println("-----------toString--------");
        int[] arr = {1,2,3,4,5,6,7,8,9,10};


        //binarySearch:二分查找法查找元素
        //细节：二分查找的前提，数组中的元素必须是有序，数组中的元素必须是升序的
        System.out.println("---------binarySearch---------");
        //输出9
        System.out.println(Arrays.binarySearch(arr,10));
        //输出1
        System.out.println(Arrays.binarySearch(arr,2));
        //输出-11
        System.out.println(Arrays.binarySearch(arr,20));

        //copyOf:拷贝数组
        /**
         * 参数一：老数组
         * 参数二：新数组的长度
         * 方法的底层会根据第二个参数来创建新的数组
         * 如果新数组的长度小于老数组的长度，会部分拷贝
         * 如果新数组的长度等于老数组的长度，会完全拷贝
         * 如果新数组的长度是大于老数组的长度，会不上默认初始值
         */
        System.out.println("-------copyOf-----------");
        int[] newArr1 = Arrays.copyOf(arr, 20);
        System.out.println(Arrays.toString(newArr1));

        //copyOfRange:拷贝数组（指定范围）
        //细节：包头不包围包左不包右
        System.out.println("----copyOfRange-----------");
        int[] newArr2 = Arrays.copyOfRange(arr, 0, 9);
        System.out.println(Arrays.toString(newArr2));

        //fill:填充数组
        System.out.println("-----------fill--------");
        Arrays.fill(arr,100);
        System.out.println(Arrays.toString(arr));

        //sort:排序，默认情况下，给基本数据类型进行排序排列。底层使用的是快速排序
        System.out.println("-----------sort---------");
        int[] arr2 = {10,2,3,5,6,1,7,8,4,9};
        Arrays.sort(arr2);
        //{1,2,3,4,5,6,7,8,9,10}
        System.out.println(Arrays.toString(arr2));

        /**
         * public static void sort(数组,排序规则)  按照指定的规则排序
         * 参数一：要排序的数组
         * 参数二：排序的规则
         * 细节：
         *      1.只能给引用数据类型的数组进行排序
         *      2.如果数组是基本数据类型，需要变成包装类
         */
        Integer[] arr3 = {2,3,1,5,6,7,8,4,9};

        //第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则
        //但是这个实现类，我只要使用一次，所以就没有必要单独写一个类，直接采取匿名内部类的方式

        /**
         * 底层原理：
         * 利用插入排序+二分查找的方式进行排序的
         * 默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列
         * 遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
         * 把A往有序序列中进行插入，在插入的的时候，是利用二分查找确定A元素的插入点
         * 拿着A元素，即插入点的元素进行比较，比较的规则就是compare方法的方法体
         *
         * 1.如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
         * 2.如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
         * 3.如果方法的返回值是0，也拿着A跟后面的数据进行比较
         * 知道能确定A的最终位置为止
         *
         * 从compare方法的形式参数
         * 参数一 o1:表示在无序序列中，遍历得到的每一个元素
         * 参数二 o2:有序序列中的元素
         *
         * 返回值
         * 1.负数 ：表示当前要插入的元素是小的，放在前面
         * 2.正数：表示当前要插入的元素是大的，放在后面
         * 3. 0：表示当前要插入的元素跟现在的元素比是一样的，我们也会放在后面
         */
        Arrays.sort(arr3,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("===============");
                System.out.println("o1:"+o1);
                System.out.println("o2:"+o2);
                //这边是升序，如果改为o2-o1则是倒序
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(arr3));

    }

}