Java中的数组声明（单维和多维）

Java中的数组|介绍

一维数组：

它是由一个通用名称使用的相同类型的变量的集合。

例子：
变量的一维数组声明：

import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
        int[] a; // valid declaration
        int b[]; // valid declaration
        int[] c; // valid declaration
    }
}

我们可以用任何方式编写它。

现在，如果你像下面这样声明你的数组：

import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
        // invalid declaration -- If we want to assign 
        // size of array at the declaration time,  it 
        // gives compile time error.
        int a[5];
  
        // valid declaration
        int b[];
    }
}

现在，假设我们要编写数组变量的多个声明，那么我们可以这样使用它。

import java.io.*;
  
class GFG { 
    public static void main(String[] args)
    {
        // valid declaration, both arrays are
        // one dimensional array.
        int a[], b[];
  
        // invalid declaration
        int c[], [] d;
  
        // invalid declaration
        int[] e, [] f;
    }
}

当我们同时声明多个变量时，我们必须先编写变量，然后声明该变量，但第一个变量声明除外。第一个变量没有限制。

现在，当我们创建数组时，必须传递数组的大小；否则我们会得到编译时错误。
您可以使用 new运算符来创建数组。

import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
        // invalid, here size of array is not given
        int[] a = new int[];
  
        // valid, here creating 'b' array of size 5
        int[] b = new int[5];
  
        // valid
        int[] c = new int[0];
  
        // gives runtime error
        int[] d = new int[-1];
    }
}

打印数组：

/* A complete Java program to demonstrate working
   of one dimensional arrays */
class oneDimensionalArray {
  
    public static void main(String args[])
    {
        int[] a; // one dimensional array declaration
        a = new int[3]; // creating array of size 3
        for (int i = 0; i < 3; i++) {
            a[i] = 100;
            System.out.println(a[i]);
        }
    }
}

输出：

100
100
100

二维数组

假设，您要创建 int 类型数据的二维数组。因此，您可以通过以下多种方式声明二维数组：

// Java program to demonstrate different ways
// to create two dimensional array.
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
        int a[][]; // valid
        int[][] b; // valid
        int[][] c; // valid
        int[] d[]; // valid
        int[][] e; // valid
        int[] f[]; // valid
        [][] int g; // invalid
        [] int[] h; // invalid
    }
}

现在，假设我们要编写数组变量的多个声明，那么您可以像这样使用它。

// Java program to demonstrate multiple declarations
// of array variable
import java.io.*;
  
class GFG {
public static void main(String[] args)
    {
        // Here, 'a' is two dimensional array, 'b'
        // is two dimensional array
        int[] a[], b[];
  
        // Here, 'c' is two dimensional array, 'd'
        // is two dimensional array 
        int[] c[], d[]; 
  
        // Here, 'e' is two dimensional array, 'f' 
        // is three dimensional array
        int[][] e, f[]; 
  
        // Here, 'g' is two dimensional array, 
        // 'h' is one dimensional array
        int[] g[], h; 
    }
}

在没有 new运算符的情况下创建一维数组和二维数组：

/* Java program for one and two dimensional arrays.
   without new operator*/
class oneTwoDimensionalArray {
  
     public static void main(String args[])
    {
        int[] a[] = { { 1, 1, 1 }, { 2, 2, 2 },
                     { 3, 3, 3 } }, b = { 20 };
  
        // print 1D array
        System.out.println(b[0]);
  
        // print 2D array
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                a[i][j] = 100;
                System.out.println(a[i][j]);
            }
        }
    }
}

输出：

使用 new运算符创建一维数组和二维数组：

/* Java program for one and two dimensional arrays.
   using new operator*/
class oneTwoDimensionalArray {
  
    public static void main(String args[])
    {
        int[] a[], b = { 20 };
        a = new int[3][3];
        b = new int[3];
  
        // print 1D array
        for (int i = 0; i < 3; i++)
            System.out.println(b[i]);
  
        // print 2D array
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                a[i][j] = 100;
                System.out.println(a[i][j]);
            }
        }
    }
}

输出：