Java中數組的概念和用法

這篇文章主要講解了“Java中數組的概念和用法”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java中數組的概念和用法”吧！

數組

1. 概述

• 相同類型數據的有序集合

• 數組中的每個數據稱為元素，通過下標進行取值（從0起）

2. 聲明與創建

   package com.zhang.array;
   
   public class ArrayDemo00 {
       public static void main(String[] args) {
           // 聲明數組
           int[] nums;
           int numss[];
           // 創建數組
           nums = new int[10];
           numss = new int[10];
           // nums.length獲得數組長度
           System.out.println(nums.length);
       }
   }

• nums = new int[5]; // 設置空間大小為5

• int[] numbs; // 推薦使用

• int numbs[]; // C/C++的風格

1. 數組需要先聲明后使用，數組聲明有兩種方式

2. 使用new關鍵字進行創建

3. 數組通過數組名.length獲得數組長度

3. 內存分析

   

   

4. 數組的三種初始化方式

   數組一共有三種初始化方式，數組的大小創建后不可以改變；

• 靜態初始化

  創建和賦值同時進行

  int[] a = {1,2,3}

       

• 動態初始化

  創建和賦值分開

  int[] a = new int[10];
  a[0] = 1;

       

• 默認初始化

  數組是引用類型，元素相當于類的實例變量，因此一旦分配了空間，其中元素也按照類變量初始化的方式被隱私初始化

  // 創建后會隱式賦值，int->0, string->null
  int[] a = new int[10];

       

  package com.zhang.array;
  
  public class ArrayDemo01 {
      public static void main(String[] args) {
          /**
           * 認識數組：
           * 1. 數組是相同元素的有序集合，通過下標進行訪問，下標從0開始；
           *
           */
          // 數組的聲明、創建、初始化的三種方式
          int[] nums; // 聲明為int類型的數組，長度大小未確定
          nums = new int[10]; // 創建長度為10的int類型數組
  
          // 1. 動態初始化
          nums[0] = 1;
          nums[1] = 2;
  
          // 2. 靜態初始化
          int[] nums01 = {1, 2, 3};   // 包含了數組的聲明與創建
  
          // 3. 默認初始化
          // 數組是引用類型，除了八大基本類型外的都是引用類型，元素相當于類的實例變量，因此一旦分配了空間，其元素也會按照實例變量的方式被隱式初始化；
          int[] nums02 = new int[2];
          System.out.println(nums02[0]);
      }
  }

  
  

5. 數組的使用

   package com.zhang.array;
   
   public class Demo03 {
       public static void main(String[] args) {
           int[] arr = {1,2,3,4,5};
           System.out.println("數組遍歷");
           printArr(arr);
           System.out.println("=====================");
           System.out.println("數組求和:"+sumArr(arr));
           System.out.println("=====================");
           System.out.println("查找數組最大元素："+getMax(arr));
           System.out.println("=====================");
           System.out.println("增強型for");
           printArrUp(arr);
           System.out.println("=====================");
           System.out.println("數組翻轉");
           printArrUp(reverseArr(arr));
       }
       // a.length返回數組長度
       public static void printArr(int[] a) {
           for (int i = 0; i <a.length ; i++) {
               System.out.println(a[i]);
           }
       }
       public static int sumArr(int[] a) {
           int sum = 0;
           for (int i = 0; i < a.length; i++) {
               sum += a[i];
           }
           return sum;
       }
       public static int getMax(int[] a) {
           int max = a[0];
           for (int i = 1; i < a.length; i++) {
               if (a[i] > max)
                   max = a[i];
           }
           return max;
       }
       public static void printArrUp(int[] a) {
           // 增強型for，jdk1.5后開始支持，便于遍歷數組數據
           for (int i : a) {
               System.out.println(i);
           }
       }
       public static int[] reverseArr(int[] a){
           int[] res = new int[a.length];
           for (int i = 0, j = a.length - 1; i < a.length; i++,j--) {
               res[j] = a[i];
           }
           return res;
       }
   }

• 遍歷

• 求和

• 查找最大元素

• 增強型for

• 數組作為參數進行傳參

• 返回數組

6. 多維數組

   二維數組：二維數組中的元素是一維數組

   依次類推...

   N維數組：N維數組中的元素是N-1維數組

   Arrays工具類介紹(JDK1.8中文在線文檔)

7. 稀疏數組

   數組稀疏會造成內存的極大浪費，采用稀疏數組進行存儲可以極大的節約資源，比如以下稀疏數組：

   0 0 0 0 1 2 0 0
   0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0

      

   采用稀疏數組如何存放以上數據？

   稀疏數組采用二維數組的方式，比如Arr【N】【3】

   表示長度維N的二維數組，

   第一行：3 8 2 // 表示原數組 3行8列現有2個數據

   // 接下來對每個位置的數字進行記錄

   第二行：0 4 1 // 表示第0行4列存放了數字1

   應用場景：比如走圍棋的時候采用稀疏數組的方式進行數據存儲可以極大節省空間，以

   package com.zhang.array;
   
   import java.util.Arrays;
   
   public class Demo04 {
       public static void main(String[] args) {
           // 1. 稀疏矩陣
           int[][] arr = new int[11][11];
           int sum = 0;
   
           arr[5][10] = 1;
           arr[1][10] = 2;
           System.out.println("稀疏數組：");
           for (int i = 0; i < arr.length; i++) {
               for (int i1 : arr[i]) {
                   System.out.print(i1+"\t");
               }
               System.out.println();
           }
   
           // 2. 記錄稀疏矩陣中的數值
           for (int i = 0; i < arr.length; i++) {
               for (int i1 : arr[i]) {
                   if(i1!=0)
                       sum++;  // 記錄非0元素個數
               }
           }
   
           // 3. 定義稀疏數組   sum+1 是因為第一行用于記錄
           int[][] rem = new int[sum+1][3];
           rem[0][0] = 11;
           rem[0][1] = 11;
           rem[0][2] = sum;
           // 將稀疏矩陣中的值記錄進稀疏數組中
           int count = 0;
           for (int i = 0; i < arr.length; i++) {
               for (int j =0; j < arr[i].length; j++) {
                   if(arr[i][j]!=0){
                       count++;
                       rem[count][0] = i;
                       rem[count][1] = j;
                       rem[count][2] = arr[i][j];
                   }
               }
           }
   
           // 打印稀疏數組
           System.out.println("稀疏數組為：");
           for (int[] ints : rem) {
               System.out.println(ints[0]+"\t"+ints[1]+"\t"+ints[2]);
           }
   
           // 稀疏數組還原
           System.out.println("稀疏數組還原：");
           int[][] arr3 = new int[rem[0][0]][rem[0][1]];
           for (int i = 1; i < rem.length; i++) {
               arr3[rem[i][0]][rem[i][1]] = rem[i][2];
           }
           // 打印
           for (int i = 0; i < arr3.length; i++) {
               for (int i1 : arr3[i]) {
                   System.out.print(i1+"\t");
               }
               System.out.println();
           }
       }
   }

• 數字0表示空

• 數字1表示白子

• 數字2表示黑子

感謝各位的閱讀，以上就是“Java中數組的概念和用法”的內容了，經過本文的學習后，相信大家對Java中數組的概念和用法這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！