(十二)高级数组(数组复制,冒泡排序,二分法)

高级数组

1.数组的拷贝
2.数组的冒泡排序
3.数组的二分查找
4.操作数组方法

1.数组的拷贝

方法一

需求:定义一个方法设为工具方法,不给外界new对象,将指定数组的指定位置复制到目标数组的指定位置

分析:

• 构造器私有化
• 将方法定义为static修饰,外界直接用类来调用
• 定义方法,传入参数数组oldArr ,旧数组索引位置fromIndex,新数组newArr,新数组索引位置endIndex,需要复制的长度length

定义数组工具类

public class ArrayUtils {
   //1.私有化构造器
    private ArrayUtils() {
    }
    //2.定义静态方法
    public static void arrayCopy(int[] arr , int fromIndex , int[] newArr ,int endIndex ,int length){
        //要复制数组,肯定需要遍历啦
        for (int i = 0; i <length ; i++) {
            //将指定索引旧数组的元素,赋值给新数组,索引值随着循环增加
           newArr[endIndex +i]= arr[fromIndex +i];
        }
        //最后打印新数组 使用Arrays.toString()方法
        System.out.println(Arrays.toString(newArr));
    }
}

测试类

public class Test01 {
    public static void main(String[] args) {
        int[] arr1 ={1,2,3,4,5,6,7};
        int[] arr2 = new int[10];
       //复制arr1,索引为2开始,长度为3的元素给到arr2索引为2开始
        ArrayUtils.arrayCopy(arr1, 2, arr2, 2, 3);
    }
}

结果: [0, 0, 3, 4, 5, 0, 0, 0, 0, 0]

方法二

java.util.Arrays,在API中提供了复制数组的方法

Arrays.copyOf(original, int newLength):复制数组的时候是从索引为0开始复制

import java.util.Arrays;

public class Test02 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        int[] arr2 = Arrays.copyOf(arr1, 10);
        System.out.println(Arrays.toString(arr2));
        
    }
}
结果:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

方法三

对于数组复制的原理,底层使用的方法是 System.arraycopy();

import java.util.Arrays;

public class Test01 {
    public static void main(String[] args) {
        int[] arr1 ={1,2,3,4,5,6,7};
        int[] arr2 = new int[10];
       //指定数组指定位置,与复制长度,复制给新数组指定位置的
        System.arraycopy(arr1, 0, arr2, 0, 5);
        System.out.println(Arrays.toString(arr2));
    }
}

2.数组的冒泡排序

原理:对未排序的元素从头到尾依次两两比较,如果前一个元素比后一个元素大,则位置交换,经过多轮循环后,得到排序

理解

遍历数组元素,遍历次数是数组长度-1 ,
每一次遍历都将数组元素两个比较,将较大的数进行替换,
遍历次数随着较大的数沉底而减少,也是数组长度-1,每遍历一次就次数-i,
从而排序,在排序期间,要将大的数与小的数进行替换,
需要找一个临时变量来存较大的数进行替换

方法一

将方法定义为工具类
public class ArrayUtils {
    //私有化构造器
    private ArrayUtils() {
    }
     //定义静态方法
    public static void arraySort(int[] arr ){
        int temp; //临时变量,存储交换的值
        //控制循环趟数
        for (int i = 0; i <arr.length-1 ; i++) {
            //循环数组内部的元素,逐渐次数减少
            for (int j = 0; j <arr.length-1-i ; j++) {
                //当前一位元素比后一位元素值大时
                if(arr[j] >arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
   
}

测试类

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {1,4,6,3,8,7,2,9};     
        ArrayUtils.arraySort(arr);            
    }
}
结果:[1, 2, 3, 4, 6, 7, 8, 9]

方法二

在Arrays类下,有定义排序的方法 Arrays.sort()

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {1,4,6,3,8,7,2,9};
        //调用排序方法
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

3.数组的二分查找

二分法查找（折半查找）: 前提 数组元素有序

理解:

二分法前提是有序的数组
    将最小索引与最大索引相加除二,得到中间索引,
    让中间索引的值与目标值进行比较,
    如果目标值比中间值大,那么最大索引-1缩小范围,
    目标值比中间值小,最小索引+1,直到得到为止

方法一

 /**
     * 二分法 (前提是有序的)
     * @param arr 目标数组
     * @param key 目标元素
     * @return 没有该元素返回-1
     */
    public static int keySearch(int[] arr ,int key){
        int low =0; //最小索引0
        int high = arr.length-1;  //最大索引

        int mid,val;
        while(low <=high){
             mid = (low+high) /2 ; //中间比较索引
             val = arr[mid]; //目标比较元素
            if(val >key){
                high =mid-1;
            }else if (val <key){
                low =mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }
}

方法二

import java.util.Arrays;

public class Test02 {
    public static void main(String[] args) {
     int[] arr1 = {1,2,3,4,5,6,7,8};
         //二分法
        int i = Arrays.binarySearch(arr1, 5);
        System.out.println(i);
    }
}

4.操作数组方法

//打印数组
Arrays.toString();
//排序
Arrays.sort();

//复制数组
Arrays.copyOf();
System,arraycopy();

//二分查找
Arrays.binarySearch();