四、java 数组

一、数组的理解:多个相同类型数据 按照 一定顺序排列 的集合，并使用同一个名字命名，通过编号的方式对这些数据进行统一管理
1.数组是有序排列；
2.数组属于引用数据类型的变量。数组的元素既可以是 基本数据类型，也可以使 引用数据类型；
3.创界数组对象会在内存中会开辟一整串联系空间；
4.数组的长度：元素的个数，长度一旦确定就不能修改；
 
一维数组的使用
  1.一维数组的声明和初始化；
  2.如何调用数据的指定位置元素；
  3.如何获取数组长度；
  4.如何遍历数组；
  5.数组元素的默认初始化值；
  6.数组的内存解析；
 

public static void oneDimesion() {
        //1.数组的声明  1。1静态初始化
        int[] ids = new int[]{1001,1002,1003};
        //数组的声明  1.2动态初始化
        String[] name = new String[4];
        //总结：一旦数组初始化成功，其长度就确定了；
        
        //2.如何调用数组的指定位置元素：通过索引的方式调用,索引从0开始；到 长度-1 结束；
        name[0] = "joy";
        name[1] = "tom";
        name[2] = "lucy";
        name[3] = "jreey";
        
        //3数组长度
        System.out.println(name.length);
        
        //4数组的遍历
        for(int i=0;i<name.length;i++) {
            System.out.println(name[i]);
        }
        
        //数组的默认初始化值,整型数组默认初始化值 0；char:0 ;boolean:false;  浮点型：0.0；引用数据类型：null
        int[] arr = new int[4];
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
        
        char[] arr1 = new char[4];
        for(int i=0;i<arr1.length;i++) {
            System.out.println("char 默认初始化值："+arr1[i]);
        }
        
        boolean[] arr2 = new boolean[4];
        for(int i=0;i<arr2.length;i++) {
            System.out.println("Boolean 默认初始化值："+arr2[i]);
        }
        
        String[] arr3 = new String[4];
        for(int i=0;i<arr3.length;i++) {
            System.out.println("引用数据类型 默认初始化值："+arr3[i]);
        }
    }

一维数组的内存解析：

 二维数组的理解:我们可以看成时一维数组array1 又作为 array2的元素存在；
 1.数组是有序排列；
 2.数组属于引用数据类型的变量。数组的元素既可以是 基本数据类型，也可以使 引用数据类型；
 3.创界数组对象会在内存中会开辟一整串联系空间；
 4.数组的长度：元素的个数，长度一旦确定就不能修改；
 
  二维数组的使用

  1.二维数组的声明和初始化；
  2.如何调用数据的指定位置元素；
  3.如何获取数组长度；
  4.如何遍历数组；
  5.数组元素的默认初始化值；
  6.数组的内存解析；
 
  数组的默认初始化值：(外层元素：如int[3];内层元素：如 int[3][2])
  针对初始化方式一：如：int[][] arr = new int[4][3];
  外层元素的初始化值：地址值；
  内层元素的初始化值为：与一位数组初始化情况相同；
  针对初始化方式二：如：int[][] arr = new int[4][];
  外层元素的初始化值：null
  内层元素的初始化值为：内层元素不能调用；

public static void testMultidimession() {
        // 1.数组的声明 1。1静态初始化
        int[] ids = new int[] { 1001, 1002, 1003 };
        int[][] ids1 = new int[][]{{ 1001, 1002, 1003 },{ 1001, 100, 1003 },{ 1001, 99, 1003 }};
        
        int[][] ids2 = new int[4][];
        // 数组的声明 1.2动态初始化
        String[] name = new String[4];
        String[][] name1 = new String[4][3];//4行3列
        String[][] name2 = new String[4][];//4行 列数不确定,如果列数不一样，就用这种方式初始化

        // 2.如何输出指定位置的元素；
        System.out.println(ids1[0][1]);
        System.out.println(name1[1][1]);
        //System.out.println(name2[1][1]);//报错，空指针异常

        // 3数组长度
        System.out.println(ids1.length);
        // 4数组的遍历
        for (int i = 0; i < ids1.length; i++) {
            for(int j=0;j<ids1[i].length;j++) {
                System.out.print(ids1[i][j]+" ");
            }
            System.out.print("
");
        }

        // 数组的默认初始化值,整型数组默认初始化值 0；char:0 ;boolean:false; 浮点型：0.0；引用数据类型：null
        int[][] arr = new int[4][3];
        System.out.println("int 二维数组默认初始化："+arr[0]);//地址值[I@6d06d69c
        System.out.println("int 二维数组默认初始化："+arr[0][0]);//0
        System.out.println("int 二维数组默认初始化："+arr);////地址值[[I@7852e922
        
        System.out.println("string 二维数组 列数不确定："+name2);//[[Ljava.lang.String;@4e25154f
        System.out.println("string 二维数组 列数不确定："+name2[0]);//null
        System.out.println("int 二维数组 列数不确定："+ids2[0]);//null
        
        String[] str1 = {"2","3"};
        name2[0] = str1;
        System.out.println(name2[0][1]);//null
    }

三、数组的常用操作

/**
     * 
     * @Description 获取arr数组中所有元素的和
     * @author lixiuming
     * @date 2020年5月5日下午12:32:08
     *
     */
    public static void multiDimessionAdd() {
        int[][] arr = new int[][] { { 3, 5, 8 }, { 12, 9 }, { 7, 0, 6, 4 } };
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];

            }
        }
        System.out.println(sum);
    }

    /**
     * 
     * @Description 打印10行杨辉三角
     * @author lixiuming
     * @date 2020年5月5日下午12:42:46
     *
     */
    public static void multiDimessionYangHui() {
        int[][] yangHui = new int[10][];
        for (int i = 0; i < 10; i++) {
            int[] arr = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                if (j == 0 || j == i) {
                    arr[j] = 1;
                    yangHui[i] = arr;
                    System.out.print(1 + "	");
                } else {
                    yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
                    System.out.print(yangHui[i][j] + "	");
                }

            }
            System.out.println();
        }

        // 不放心可以重新遍历元素
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "	");
            }
            System.out.println();
        }
    }

    /**
     * 
     * @Description        创建一个长度为6的int型数组，要求数组的值在1-30之间，且是随机赋值，同时，要求元素的值各不同；
     * @author            lixiuming
     * @date            2020年5月6日上午10:09:46
     *
     */
    public static void testArithmetic1() {
        int[] arr = new int[6];
        Random random = new Random();
        for(int i = 0;i<arr.length;i++) {
            int radNum = random.nextInt(30)+1;
                for(int j = 0;j<i && i > 0;j++) {
                    while(arr[j] - radNum ==0) {
                        radNum = random.nextInt(30)+1;
                    }
                }
                arr[i] = radNum;
        }
        for(int i = 0;i<arr.length;i++) {
            System.out.println("1-30 6为数组的随机数："+arr[i]+"	");
        }
        
    }
    
    /**
     * 
     * 求数值型数组中元素的最大值，最小值，平均数，总和
     * <p>随机数公式 [a,b] Math.random()*(b-a+1)+a;
     * @Description        求数值型数组中元素的最大值，最小值，平均数，总和
     *                     定义int型数组，包含10个元素，分别赋两位随机数求最大值，最小值，平均数，总和
     * @author            lixiuming
     * @date            2020年5月6日下午2:15:08
     *
     */
    public static void testArithmetic2() {
        int[] arr = new int[10];
        for(int i = 0; i<10;i++) {
            Random random = new Random();
            arr[i] = random.nextInt(90)+10;
        }
        
        int sum = 0;
        int avg = 0;
        int min = 0;//最好直接指定值 即 arr[0]
        int max = 0;//最好直接指定值 即 arr[0]
        for(int i = 0; i<arr.length;i++) {
            sum += arr[i];
        }
        System.out.println("总和："+sum);
        System.out.println("平均："+(sum/10.0));
        
        for(int i = 0; i<arr.length;i++) {
            System.out.print(arr[i]+"	");
            min = arr[0];
                if(arr[i]>=max) {
                    max = arr[i];
                }
                if(arr[i]<=min) {
                    min = arr[i];
                }
        }
        System.out.println();
        System.out.println("最大："+max);
        System.out.println("最小："+min);
    }

    /**
     * 
     * 使用简单数组 数组复制
     * 
     * <p>
     * 1.创建两个int[]了星星变量 arr1,arr2;</br>
     * 2.使用{},把arr1初始化8个素数；</br>
     * 3.显示arr1内容；</br>
     * 4.arr2 = arr1,修改arr2的偶素索引元素，使他等于索引值 即 arr2[0] = 0;;arr[2] == 2;</br>
     * 
     * @Description        
     * @author            lixiuming
     * @date            2020年5月6日下午3:13:28
     *
     */
    public static void testArithmetic3() {
        int[] arr1,arr2;
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        arr2 = arr1;//这个操作不能复制数组；arr1 arr2 都指向了堆空间的唯一一个数组实体；
        for(int i=0; i<arr2.length;i++) {
            System.out.print("原始："+arr1[i]+"	");
        }
        for(int i=0; i<arr2.length;i++) {
            if(i%2 == 0) {
                arr2[i] = i;
            }
        }
        System.out.println();
        for(int i=0; i<arr1.length;i++) {
            System.out.print("修改arr2后arr1的结果："+arr1[i]+"	");
        }
        
        //数组复制
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        arr2 = new int[arr1.length];
        System.out.println();
        for(int i=0; i<arr1.length;i++) {
            if(i%2 == 0) {
                arr2[i] = i;
            }else {
                arr2[i] = arr1[i];
            }
        }
        for(int i=0; i<arr1.length;i++) {
            System.out.print("(重新new)修改arr2后arr1的结果："+arr1[i]+"	");
        }
    }
    /**
     * 数组反转
     * @Description        
     * @author            lixiuming
     * @date            2020年5月7日下午12:45:29
     *
     */
    public static void testArithmetic4() {
        int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
        int[] arr2 = new int[arr1.length];
        for(int i=0;i<arr1.length;i++) {
            arr2[i] = arr1[i];
        }
        for(int i=(arr2.length-1);i>=0;i--) {
            int j = arr2.length-1-i;
            arr1[j] = arr2[i];
        }
        System.out.println();
        for(int i=0;i<arr1.length;i++) {
            System.out.print(arr1[i]+"	");
        }
        

        //推荐 ：写法二
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        for(int i = 0;i<arr1.length/2;i++) {
            int temp = arr1[i];
            arr1[i] = arr1[arr1.length-1-i];
             arr1[arr1.length-1-i] = temp;
        }
        System.out.println();
        for(int i=0;i<arr1.length;i++) {
            System.out.print(arr1[i]+"	");
        }
    }
    
    /**
     * 数组线性查找
     * @Description        
     * @author            lixiuming
     * @date            2020年5月7日下午3:05:21
     *
     */
    public static void testArithmetic5() {
        String[] arr1 = new String[] {"AA","BB","CC","DD"};
        String dest = "BB";
        boolean flag = false;
        for(int i = 0; i<arr1.length;i++) {
            if(dest.equals(arr1[i])) {
                flag = true;
                System.out.println("找到了指定元素，位置为："+i);
                break;
            }
        }
        if(!flag) {
            System.out.println("没找到指定元素");
        }
    }
    
    /**
     * 二分法查找 
     * 
     * <p>所要查找的数组必须有序
     * @Description        
     * @author            lixiuming
     * @date            2020年5月7日下午3:05:21
     *
     */
    public static void testArithmetic6() {
        int[] arr1 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
        int dest = 2;
        int start = 0;
        int end = arr1.length-1;
        boolean flag = false;
        for(int i = start; i<end;i++) {
            int indexNum = (end + start)/2;
            if(dest<arr1[indexNum]) {
                end = indexNum-1;
            }else if(dest>arr1[indexNum]){
                start = indexNum+1;
            }else if(dest == arr1[indexNum]){
                flag = true;
                System.out.println("找到了指定元素，位置为："+indexNum);
                break;
            }
        }
        if(!flag) {
            System.out.println("没找到指定元素");
        }
    }
    /**
     * 数组的冒泡排序
     * @Description        
     * @author            lixiuming
     * @date            2020年5月8日上午11:40:06
     *
     */
    public static void testArithmetic7() {
        int[] arr = new int[] {43,32,76,98,0,64,33,-21,32,99};
//        冒泡排序 从小到大排序
        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)]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            
        }
        
        System.out.println();
        for(int i = 0;i<arr.length;i++) {
            System.out.print(arr[i] +"	");
        }
        System.out.println();
    }

四、Arrays工具类的使用：java.util.Arrays:操作数组工具类，里面定义了很多操作数组的方法

/**
     * 比较两个数组是否相等；
     * 
     * @Description
     * @author lixiuming
     * @date 2020年5月8日下午3:50:17
     *
     */
    public static void testEquals() {
        int[] arr1 = new int[] { 1, 2, 3, 4 };
        int[] arr2 = new int[] { 1, 3, 2, 4 };
        boolean res = Arrays.equals(arr1, arr2);
        System.out.println(res);
    }

    /**
     * 
     * @Description
     * @author lixiuming
     * @date 2020年5月8日下午3:56:38
     *
     */
    public static void testToString() {
        int[] arr1 = new int[] { 1, 2, 3, 4 };
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 将指定的值填充到数组中
     * 
     * @Description
     * @author lixiuming
     * @date 2020年5月13日上午10:04:56
     *
     */
    public static void testFill() {
        int[] arr1 = new int[] { 1, 2, 3, 4 };
        Arrays.fill(arr1, 10);// 填充所有
        Arrays.fill(arr1, 0, 1, 1);// 填充到指定位置
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 排序
     * 
     * @Description
     * @author lixiuming
     * @date 2020年5月13日上午10:11:37
     *
     */
    public static void testSort() {
        int[] arr1 = new int[] { 1, 3, 5, 4 };
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));

        String[] str1 = new String[] { "b", "e", "a", "c" };
        Arrays.sort(str1);
        System.out.println(Arrays.toString(str1));
    }

    /**
     * 二分查找
     * 
     * @Description
     * @author lixiuming
     * @date 2020年5月13日上午10:12:08
     *
     */
    public static void testBinarySearch() {
        int[] arr1 = new int[] { 1, 2, 3, 4,50,51,52,68,100 };
        int res = Arrays.binarySearch(arr1,52);
        System.out.println(res);
    }