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工具類方法介紹：

使用代碼案列如下：

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));
    }

個人學習，內容簡略，

標籤：Java

上一篇：全堆疊的自我修養: 0005 Java 包掃描實作和應用(Jar篇)

下一篇：依賴倒置、依賴注入和控制反轉傻傻分不清楚？