Java中數組的概念和用法

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

數組

1. 概述

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

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

2. 聲明與創(chuàng)建

   package com.zhang.array;
   
   public class ArrayDemo00 {
       public static void main(String[] args) {
           // 聲明數組
           int[] nums;
           int numss[];
           // 創(chuàng)建數組
           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關鍵字進行創(chuàng)建

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

3. 內存分析

   

   

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

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

• 靜態(tài)初始化

  創(chuàng)建和賦值同時進行

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

       

• 動態(tài)初始化

  創(chuàng)建和賦值分開

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

       

• 默認初始化

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

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

       

  package com.zhang.array;
  
  public class ArrayDemo01 {
      public static void main(String[] args) {
          /**
           * 認識數組：
           * 1. 數組是相同元素的有序集合，通過下標進行訪問，下標從0開始；
           *
           */
          // 數組的聲明、創(chuàng)建、初始化的三種方式
          int[] nums; // 聲明為int類型的數組，長度大小未確定
          nums = new int[10]; // 創(chuàng)建長度為10的int類型數組
  
          // 1. 動態(tài)初始化
          nums[0] = 1;
          nums[1] = 2;
  
          // 2. 靜態(tài)初始化
          int[] nums01 = {1, 2, 3};   // 包含了數組的聲明與創(chuàng)建
  
          // 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. 稀疏數組

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

   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列現(xiàn)有2個數據

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

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

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

   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中數組的概念和用法這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！