Java-Arrays

base黑马

方法名称	说明
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.lyh.arrays;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

public class ArraysTest01 {
    public static void main(String[] args) {
        //1、Arrays.toString (数组) ：把数组拼接成一个字符串
        int[] array = {1,2,3,5,6,7,8,9,10};
        String string = Arrays.toString(array);
        System.out.println(string); //[1, 2, 3, 5, 6, 7, 8, 9, 10]

        //2、Arrays.binarySearch(数组, 查找的元素)：二分查找法查找元素
        /*
        注意1：二分查找的前提是数组中的元素必须是升序的。
        注意2：如果查找的元素存在，则返回这个元素所对应的索引值，否则返回 -插入点 - 1
              比如元素“4”按照从小到大的顺序在数组array中进行排列，这时所在的位置索引值（插入点）是3
              也就是 -3-1 = -4，所以当查找不存在的元素“4”时，返回的值为“-4”
        为什么要减1呢？
            假如要查找不存在的元素值0，如果返回的值是 -插入点，此时元素0的插入点是0索引，
            即返回-0 也就是0索引，这就不能说明0元素不存在了
            所以得减1 返回-1 以表示要查找的0元素在数组中是不存在的
         */
        int index1 = Arrays.binarySearch(array, 6);
        System.out.println("“6”元素的索引："+index1); //4
        int index2 = Arrays.binarySearch(array, 4);
        System.out.println("“4”元素的索引："+index2); //-4
        int index3 = Arrays.binarySearch(array, 0);
        System.out.println("“0”元素的索引："+index3);//-1

        //3、Arrays.copyOf(原数组 , 新数组长度)：拷贝数组
        /*
        方法会根据 新数组长度 这个参数，来创建新的数组。
        如果新数组的长度等于老数组的长度会完全拷贝
        如果新数组的长度大于老数组的长度会将老数组拷贝到新数组中后，新数组中剩余的空间，用默认值（0）补齐。
        如果新数组的长度小于老数组的长度会部分拷贝
         */
        int[] newArray1 = Arrays.copyOf(array, 10);//完全拷贝
        System.out.println(Arrays.toString(newArray1)); //[1, 2, 3, 5, 6, 7, 8, 9, 10, 0]
        int[] newArray2 = Arrays.copyOf(array, 15);//默认值填充拷贝
        System.out.println(Arrays.toString(newArray2)); //[1, 2, 3, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0]
        int[] newArray3 = Arrays.copyOf(array, 5);//部分拷贝
        System.out.println(Arrays.toString(newArray3)); //[1, 2, 3, 5, 6]

        //4、Arrays.copyOfRange(原数组 , 起始索引 , 结束索引)：拷贝数组（指定范围）
        //拷贝的时候：包左不包右
        //int[] array = {1,2,3,5,6,7,8,9,10} 索引范围：3~6，最终返回值为：5,6,7
        int[] newArray4 = Arrays.copyOfRange(array, 3, 6);
        System.out.println(Arrays.toString(newArray4)); //[5, 6, 7]

        //5、Arrays.fill(数组 , 元素)：填充数组
        Arrays.fill(array,12);
        String string1 = Arrays.toString(array);
        System.out.println(string1); //[12, 12, 12, 12, 12, 12, 12, 12, 12]

        //6、Arrays.sort(数组)：按照默认方式进行数组排序
        //默认情况下基本数据类型采用升序排列，底层使用的是快速排序。
        int[] array1 = {1,2,5,3,6,7,8,9,10,4};
        Arrays.sort(array1);
        String string2 = Arrays.toString(array1);
        System.out.println(string2); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        //7、Arrays.sort(数组 , 排序规则)：按照指定方式对数组进行排序
        //只能给引用数据类型的数组进行排序，如果数组是基本数据类型，需要变成该基本数据类型的包装类，即Integer
        //第二个参数是一个接口，在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。
        //但是此实现类，仅使用一次，所以可以采用匿名内部类的方式。
        /*
        底层原理：
            利用插入排序 + 二分查找的方式进行排序。
            默认把0索引的数据当成是有序的序列，1索引到最后认为是无序的序列
            遍历无序的序列得到里面的每一个元素，假设当前得到的元素是A元素
            把A往有序序列中进行插入，在插入的时候，利用二分查找确定A元素的插入点
            拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
            如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
            如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
            如果方法的返回值是0，也拿着A跟后面的数据进行比较
            直到能确定A的最终位置为止。
         */
        //compare方法的形式参数
        //参数一 o1：表示在无序序列中，遍历得到的每一个元素
        //参数二 o2：有序序列中的元素
        Integer[] array2 = {1,2,5,3,6,7,8,9,10,4};
        Arrays.sort(array2,new Comparator<Integer>(){
            //返回值：
            //负数：表示当前要插入的元素是小的，放在前面
            //正数：表示当前要插入的元素是大的，放在后面
            //0：表示当前要插入的元素跟现在的元素比是一样的也放在后面
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1; //降序排列
//                return o1 - o2; //升序排列
            }
        });
        String string3 = Arrays.toString(array2);
        System.out.println("降序排列："+string3); //降序排列：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
//        System.out.println("升序排列："+string3); //升序排列：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    }
}

“请你务必一而再，再而三，三而不竭，千次万次，毫不犹豫救自己于人间水火”❤️✨✨