Java数组

一维数组：

一维数组的三种定义：

• 数据类型[] 数组名字 = new 数据类型[长度];   eg：int[] array = new int[6];
• 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};  eg：int[] arr = new int[]{1,2,3,4,5,6};
• 数据类型[] 数组名 = {元素1,元素2,元素3...};  eg：int[] arr = {1,2,3,4,5,6};

代码案列如下：

    public static void main(String[] args) {
        /* 如何定义一维数组 */
        int [] arr1 = new int[3];  //定义一个长度为3的一维数组但没有赋值
        arr1[0]=1;          //给数组下标为0的赋值为1
        arr1[1]=2;          
        arr1[2]=3;
        System.out.println("-------------------------");
        int [] arr2= new int[]{1,2,3,4};//定义一个一维数组并赋值；
        System.out.println("-------------------------");
        int [] arr3 = {1,2,3,4,5}; //直接定义一个一维数组赋值  和上面区别不大
    }

注：数组下标从0开始。

数组的类型：

    public static void main(String[] args) {
        /* 数组的声明同样和数据类型息息相关 */
        
         //整数 类型的数组
        int [] intArr= {1,2,3,4};
        short[] shortArr = {1,23,4};
        char [] charArr = {232,44,6};
        
        //浮点数 类型
        float floatArr[] = {1.2f,2.2f};
        double doubleArr[] = {1.2,0.0};
        
        //字符串 类型的数组
        String strArr []  = {"我","爱","你"};
        
        //boolean 类型 数组
        boolean booArr[] = {true,true};
    }

因为数组长度固定，因此数组本身无法添加或者移除元素，但是我们可以在原数组的基础上复制一份数组来改变其长度和元素。数组的类型可以根据自己需求而定义。

默认值：

 二维数组：

二维数组，是在一维数组的的层次上再嵌套一层数组的意思。

二维数组定义方式：

•  数据类型[][] 数组名字 = new 数据类型[长度][长度];   eg：int[][] array = new int[2][3];
• 数据类型[][] 数组名字 = new 数据类型[长度][]; eg：int[][] array = new int[2][];
• 数据类型[][] 数组名字 = new 数据类型[][]{{元素1},{元素2}...};   eg：int[][] array = new int[][]{{1,2},{3,4}};    int[][] array = {{1,2},{3,4}};

代码如下：

public static void main(String[] args) {
            /* 二维数组的定义 */
        int arrs1[][] = new int[2][3];   //定义了一维和二维的长度，并没有赋值     
                                         //前面的一个括号的是一维（外围数组）的长度 后面是定义二维数组的长度
        
        int[][] arrs2 = new int[2][];   // 这种方式在定义的时候只规定了外层的一维数组个数，并未规定内部元素嵌套的二维数组的内容和长度。
        
        int[][] array3 = new int[][]{{1,2},{3,4}};
        int[][] array4 = {{1,2},{3,4}};    //这种方式在定义的时候，直接对数组进行了初始化赋值。
    }

同样：二维数组和一维数组一样也可以定义不同数据类型的数组。

把数组和之前的知识点一起使用，可以有很多用处如下根据根据数组有几个练习题：

数组练习：

01 数组的遍历：

public static void main(String[] args) {
        /* 一维数组的遍历 */
        int arr1[] = { 1, 23, 3, 12, 11 };
        for (int i = 0; i < arr1.length; i++) {
            System.err.println(arr1[i]);
        }
        System.out.println("-----------------------------------");
        /* 一维数组的while遍历 */
        int []a = {12,13,14,15};
        int i1 = 0;
        while (i1>a.length) {
            System.out.println(a[i1]);
            i1++;
        }
        System.out.println("-----------------------------------");
        int []a1 = {12,13,14,15};
        for (int i : a1) {
            System.out.println(i);
        }
        /* 二维数组的遍历 */
        int arr[][] = { { 21, 331, 21, 11 }, { 11, 22, 33, 11 } };
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
        System.out.println("------------------------------------");
        /* 二维数组while循环 遍历 */
        int arr2[][] = { {1,2,3,4,5}, {6,7,8,9,0} };
        int i = 0;
        while (i<arr2.length) {
            int j =0;
            while (j<arr2[i].length) {
                System.out.println(arr2[i][j]);
                j++;
            }
            i++;
        }
        System.out.println("--------------------------------------");
    }

02.求数组的最大值，最小值：

public static void main(String[] args) {
        //求一维数组的最大值
         System.out.println("求一维数组最大值");
          int arry [] = {19,30,22,11,9,-1,-36,67,31};
          int maxArry = arry[0];
          for (int i = 0; i < arry.length; i++) {
              if(maxArry < arry[i]) {
                  maxArry = arry[i];
              }
        }
          System.out.println(maxArry);
        //求一维数组的最小值
          System.out.println("----------------------------------------");
          System.out.println("求一维数组最小值");
        int arry1 [] = {19,2,1,33,-21,93,1,-27,33,0};
        int minArry1 = arry1[0];
        for (int i = 0; i < arry1.length; i++) {
            if(minArry1 > arry1[i]) {
                minArry1 = arry1[i];
            }
        }
        System.out.println(minArry1);
      //求二维数组的最小值
        System.out.println("----------------------------------------");
        System.out.println("求二维数组最小值");
        int arry2[][] = {{23,12,-29,29,12,78,39,-12,-33},{99,312,100,3,-22,-1,-29,93,211}};
        int minArry2 = arry2[0][0];
        for (int i = 0; i < arry2.length; i++) {
            for (int j = 0; j < arry2[i].length; j++) {
                if(minArry2 > arry2[i][j]) {
                    minArry2 = arry2[i][j];
                }
            }
        }
        System.out.println(minArry2);
        
      //求二维数组的最大值
        System.out.println("----------------------------------------");
        System.out.println("求二维数组最大值");
        int arry3[][] = {{23,12,-29,29,12,78,39,-12,-33},{99,312,100,3,-22,-1,-29,93,211}};
        int minArry3 = arry3[0][0];
        for (int i = 0; i < arry3.length; i++) {
            for (int j = 0; j < arry3[i].length; j++) {
                if(minArry3 < arry3[i][j]) {
                    minArry3 = arry3[i][j];
                }
            }
        }
        System.out.println(minArry3);
        
    }

03 .冒泡排序：

public static void main(String[] args) {
        /* 冒泡排序 */
        // for循环
        int arr[] = { 21, 123, -21, 31, -1 };
        for (int i = 1; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                int tem;
                if (arr[j] > arr[j + 1]) {
                    tem = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = tem;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

        // while循环
        System.out.println("-------------------------------");
        int i = 1;
        while (i < arr.length - 1) {
            int j = 0;
            while (j < arr.length - i) {
                int temp;
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[i];
                    arr[i] = temp;
                }
                j++;
            }
            i++;
        }
        System.out.println(Arrays.toString(arr));
    }

04 二分查找：

    public static void main(String[] args) {
        /*
         * 数组的二分查找 二分查找顾名思义，就是分成两等分开始查找，每次分两等分 eg：a[]={1,2,3,4,5,2,31,98};
         * 查找一个数，我们拿中间的5来作比较。如果比5大，我们在拿31做比较，如果小于5我们就拿3做比较 以此类推。
         */
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int key =9;
        int low = 0;
        int high = arr.length - 1;
        int middle = 0;            //定义middle
        if(key < arr[low] || key > arr[high] || low > high){
            System.out.println("越界");        
        }
        
        while(low <= high){
            middle = (low + high) / 2;
            if(arr[middle] > key){
                //比关键字大则关键字在左区域
                high = middle - 1;
            }else if(arr[middle] < key){
                //比关键字小则关键字在右区域
                low = middle + 1;
            }else{
                System.out.println(key+"的下标是："+middle);
                break;
            }
        }
    }

Arrays工具类：

以上的几种对数组操作的方法，在java API 中提供了直接调用的方法：

常用Arrays工具类方法介绍：

方法	说明
toString(Object[] a)	将任意类型的数组的元素以字符串形式打印
deepToString(Object[] a)	将任意类型的数组的深度元素以字符串形式打印（比如多维数组元素）
asList(T... a)	将任意类型数组转换为List集合形式
binarySearch(int[] a, int key)	二分查找方法
sort(int[] a)	数组排序
fill(int[] a, int fromIndex, int toIndex, int val)	替换数组指定角标位置元素
copyOfRange(int[] original, int from, int to)	对原数组进行指定范围元素复制为一个新数组

使用代码案列如下：

public static void main(String[] args) {
        // 定义一个元素顺序杂乱的数组
        int[] arr = { 4, 1, 3, 6, 2, 5};    
        // 直接打印
        System.out.println(arr);
        // 1、将数组以字符串形式打印
        System.out.println(Arrays.toString(arr));

        // 2、数组排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        
        // 3、数组二分查找
        int index =Arrays.binarySearch(arr, 1);
        System.out.println("元素1在有序数组arr中的索引位置为："+index);
        
        // 4、数组元素替换
        Arrays.fill(arr, 0, 2, 0);
        System.out.println(Arrays.toString(arr));
        
        // 5、数组的复制
        int[] copyArray =Arrays.copyOfRange(arr, 0, 3);
        System.out.println(Arrays.toString(copyArray));
    }

个人学习，内容简略。