数组的代码学习

package com.testLesson;


import java.util.Arrays;

public class Texts {
    public static void main(String[] args){

        /**
         * Arrays的静态类方法，对元素进行替换
         * */
        // fill(int[] a,int value) 该方法可将制定的int值分配给int型数组的每个元素
        int arr[] = new int[5]; // 创建int型数组
        Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
        for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
            // 将数组中的元素依次输出
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
        /**
         * 第0个元素是：8
         第1个元素是：8
         第2个元素是：8
         第3个元素是：8
         第4个元素是：8
         * */

        // file(int[] a,int forIndex,int toIndex,int value)
        // 该方法将制定的int值分配给int型数组指定范围中的每个元素。
        // 范围从索引formIndex（包括）一直到索引toIndex（不包括）。如果formIndex==toIndex，则填充范围为空
        int arr1[] = new int[] { 45, 12, 2, 10 }; // 定义并初始化int型数组arr
        Arrays.fill(arr1, 1, 2, 8); // 使用fill方法对数组进行初始化
        for (int i = 0; i < arr1.length; i++) { // 循环遍历数组中元素
            // 将数组中的每个元素输出
            System.out.println("第" + i + "个元素是：" + arr1[i]);
        }
        /**
         * 第0个元素是：45
         第1个元素是：8
         第2个元素是：2
         第3个元素是：10
         * */

        /**
         * Arrays的静态类方法 sort(),可以实现对数组的排序
         * java中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面
         * */
        int arr2[] = new int[] { 23, 42, 12, 8 }; // 声明数组
        Arrays.sort(arr2); // 将数组进行排序
        for (int i = 0; i < arr2.length; i++) { // 循环遍历排序后的数组
            System.out.println(arr2[i]); // 将排序后数组中的各个元素输出
        }// 8 12  23 42

        /**
         * Arrays的静态类方法 复制数组
         * copyOf(arr,int newLength)方法 是复制数组至指定长度
         * copyOfRange(arr,int formIndex,int toIndex)方法 将指定数组的指定长度复制到一个新数组中,不包括toIndex索引的元素
         * */
        int arr3[] = new int[] { 23, 42, 12, }; // 定义数组
        int newarr[] = Arrays.copyOf(arr3, 5); // 复制数组arr
        for (int i = 0; i < newarr.length; i++) { // 循环变量复制后的新数组
            System.out.println(newarr[i]); // 将新数组输出
        }// 23 42 12  0  0

        int arr4[] = new int[] { 23, 42, 12, 84, 10 }; // 定义数组
        int newarr1[] = Arrays.copyOfRange(arr4, 0, 3); // 复制数组
        for (int i = 0; i < newarr1.length; i++) { // 循环遍历复制后的新数组
            System.out.println(newarr1[i]); // 将新数组中的每个元素输出
        }// 23 42  12

        /**
         * Arrays的静态方法 数组查询 binarySearch() 二分搜索法来搜索指定数组，已获得指定对象，该方法返回搜索元素的索引值
         * binarySearch(Object[] a,Object key)要搜索的数组和要搜索的值
         * 使用之前需要对搜索的数组sort()
         * binarySearch(Object[] a,int formIndex,int toIndex,Object key) 该方法在指定的范围内检索某一元素 （toIndex不包括）
         *
         * Arrays.binarySearch0()方法是利用二分法来查找数据的，最后对于不存在于数组中的数据的下标返回值是return -(low + 1)。
         * */
        int ia[] = new int[] { 1, 8, 9, 4, 5 }; // 定义int型数组ia
        Arrays.sort(ia); // 将数组进行排序
        int index = Arrays.binarySearch(ia, 3); // 查找数组ia中元素3的索引位置，默认顺序是 1,3,4,5,8,9 。查找3返回-（1+1） = -2
        System.out.println("3的索引位置是：" + index); // 将索引输出 4的索引位置是：-2

        // 定义String型数组str
        String str[] = new String[] { "ab", "cd", "ef", "yz" };
        Arrays.sort(str); // 将数组进行排序
        // 在指定的范围内搜索元素"cd"的索引位置
        int index2 = Arrays.binarySearch(str, 0, 2, "gh");//范围0~2，ab,cd,gh
        System.out.println("gh的索引位置是：" + index2); // 将索引输出


        /**
         * 数组元素插入
         * */
        System.out.println("数组元素插入");
        int indexs = 0;
        int[] arra = new int[6];
        arra[0] = 2;
        arra[1] = 4;
        arra[2] = 6;
        arra[3] = 8;
        System.out.println();
        for(int i = 0;i < arra.length;i++){
            System.out.print(arra[i]+" ");
        }
        int nums = 5;
        for(int i =0;i < arra.length;i++){
            if(nums < arra[i]) {// 升序小于号，降序大于号
                indexs = i;
                System.out.println(indexs);
                break;
            }
        }
        // 关键代码，从indexs位置，全部后移一位，留下indexs索引位置赋值nums
        for(int j = arra.length - 1; j > indexs;j--){
            arra[j] = arra[j-1];
        }
        arra[indexs] = nums;
        System.out.println();
        for(int i = 0;i < arra.length;i++){
            System.out.print(arra[i]+" ");
        }
        System.out.println();



        /**
         * 数组的排序算法
         * 冒泡排序
         *
         * */

        int[] arrs={6,3,8,2,9,1};
        System.out.println("排序前数组为：");
        for(int num:arrs){
            System.out.print(num+" ");
        }
        for(int i=0;iarrs[j+1]){
                    int temp=arrs[j];
                    arrs[j]=arrs[j+1];
                    arrs[j+1]=temp;
                }
            }
        }
        System.out.println();
        System.out.println("排序后的数组为：");
        for(int num:arrs){
            System.out.print(num+" ");
        }



        /**
         * 直接选择排序
         * 将每次最小的值放在第一位
         * 63,4,24,1,3,15
         * 外层i = 0
         * 内层索引tem = i 与索引j 比较大小，索引tem大于索引j ,交换索引，在继续向后比较大小，遇到索引j 更小的时候交换
         * */
        int[] arr6 = {63,4,24,1,3,15};
        for(int i=0;i arr6[j]) {
                    tem = j;
                }// 每次循环找到最小值的索引
            }
            // 然后最小值的索引和索引i 交换位置，下次循环又找到小值的索引，在和索引i交换
            int temp1 = arr6[i];
            arr6[i] = arr6[tem];
            arr6[tem] = temp1;
        }
        System.out.println(Arrays.toString(arr6));


        // 创建一个数组
        int[] array = { 40, 50, 30, 40, 05, 60 };
        // 创建反转排序类的对象
        Texts sorter = new Texts();
        // 调用排序对象的方法将数组反转
        sorter.sort(array);// 60	5	40	30	50	40
    }

    /**
     * 反转排序
     * */
    public void sort(int[] array) {
        System.out.println("数组原有内容：");
        showArray(array);// 输出排序前的数组值
        int temp;
        int len = array.length;
        for (int i = 0; i < len / 2; i++) {
            temp = array[i];
            array[i] = array[len - 1 - i];
            array[len - 1 - i] = temp;
        }
        System.out.println("数组反转后内容：");
        showArray(array);// 输出排序后的数组值
    }

    // 二分搜索法简单底层实现思想
    public static int halfSearch(int[] a , int key) {

        int min = 0;
        int max = a.length - 1;

        while(min < max) {
            int mid = (min + max)/2;
            if(key > a[mid]) {
                min = mid + 1;
            } else if(key < a[mid]) {
                max = mid - 1;
            } else {
                return mid;
            }
        }
        return -(min + 1);
    }

    public void showArray(int[] array) {
        for (int i : array) {// foreach格式遍历数组
            System.out.print("\t" + i);// 输出每个数组元素值
        }
        System.out.println();
    }

}