这篇文章主要讲解了“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中数组的概念和用法这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是天达云，小编将为大家推送更多相关知识点的文章，欢迎关注！