根据数组的定义，数组可以包含基元数据类型以及类的对象。对于基元数据类型，实际值存储在相邻的内存位置。对于类的对象，实际对象存储在堆段中。

一维阵列：

一维数组声明的一般形式是

type var-name[];
OR
type[] var-name;

在Java中实例化数组

var-name = new type [size];

例如

int intArray[];  // Declaring an array
intArray = new int[20];  // Allocating memory to the array

// The below line is equal to line1 + line2
int[] intArray = new int[20]; // Combining both statements in one
int[] intArray = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Accessing the elements of the specified array
for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + ": "+ intArray[i]);

参考：Java中的数组

另一种声明和初始化ArrayList的方法：

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

要创建类对象的数组，可以使用java.util.ArrayList.来定义数组：

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

为数组赋值：

arrayName.add(new ClassName(class parameters go here);

从阵列中读取：

ClassName variableName = arrayName.get(index);

注：

variableName是对数组的引用，这意味着操纵variableName将操纵arrayName

对于循环：

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

for循环，允许您编辑arrayName（常规for循环）：

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

声明和初始化数组非常容易。例如，您希望在数组中保存5个整数元素，即1、2、3、4和5。您可以通过以下方式进行操作：

a)

int[] a = new int[5];

or

b)

int[] a = {1, 2, 3, 4, 5};

因此基本模式用于初始化，方法a）的声明是：

datatype[] arrayname = new datatype[requiredarraysize];

数据类型应为小写。

因此，基本模式用于初始化，方法a的声明是：

如果是字符串数组：

String[] a = {"as", "asd", "ssd"};

如果是字符数组：

char[] a = {'a', 's', 'w'};

对于浮点双精度，数组的格式将与整数相同。

例如：

double[] a = {1.2, 1.3, 12.3};

但是当您通过“方法a”声明和初始化数组时，您必须手动或通过循环或其他方式输入值。

但是，当您通过“方法b”执行此操作时，您不必手动输入值。

这里有很多答案。我添加了一些创建数组的技巧（从考试的角度来看，知道这一点很好）

声明和定义数组intintArray[]=新int[3]；这将创建一个长度为3的数组。由于它持有一个基元类型int，所有值默认设置为0。例如intArray[2]；//将返回0在变量名称前使用方括号[]int[]intArray=新int[3]；intArray[0]=1；//数组内容现在为｛1，0，0｝初始化并向阵列提供数据int[]intArray=新int[]｛1，2，3｝；这一次，无需在方框括号中提及尺寸。甚至一个简单的变体是：int[]intArray=｛1，2，3，4｝；长度为0的数组int[]intArray=新int[0]；int length=intArray.length；//将返回长度0类似于多维数组int intArray[][]=新int[2][3]；//这将创建一个长度为2的数组//每个元素包含另一个长度为3的数组。// { {0,0,0},{0,0,0} }int lenght1=intArray.length；//将返回2int length2=intArray[0].length；//将返回3

在变量之前使用方括号：

    int[][] intArray = new int[2][3];

如果你在最后放一个盒子支架，那是绝对好的：

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

一些示例

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

每个内部元素的大小不一定相同。

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

如果使用上述语法，则必须确保向前方向必须在方括号中指定值。否则它将无法编译。一些示例：

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

另一个重要特征是协变

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // This is also valid

重要信息：对于引用的类型，数组中存储的默认值为空。

此外，如果您需要更动态的内容，可以使用List界面。这不会表现得很好，但更灵活：

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );