一维数组
一维数组：
特点：
1.指定一种数据类型
2.指定长度
声明：
数组类型 数组名称[];
数组类型[] 数组名称;
创建：
数组名称 = new 数组类型[长度];
初始化：
数组类型 数组名称[]={数组元素1,数组元素2,....}
数组类型 数组名称[]=new 数组类型[]{数组元素1,数组元素2,....}
取值：
数组名称[下标];
赋值：
数组名称[下标] = 值;
属性：
length:获取数组的元素个数，即数组长度
遍历：for循环 或 foreach遍历
异常：下标越界，java.lang.ArrayIndexOutOfBoundsException
stack(栈)：系统分配，大小限制，先进后出
一般用来存储基本数据类型(局部变量)、与 引用类型的地址值
heap(堆)：程序员控制，先进先出,当程序员使用new关键字时，系统将分配对应的堆内存来存储对应的对象值
一般用来存储引用类型的值
//声明数组
int[] intArray;
//系统分配栈（stack）来存储当前引用对象intArray、strArray的地址
//System.out.println(intArray.toString());
//此时intArray为null,null无法使用任何方法
//创建数组
intArray = new int[5];
//当使用new关键字时，系统将分配堆（heap）内存给当前对象存储值
//动态初始化：当数组被定义时，所有元素均有默认初始值，例如int默认值为0
System.out.println(intArray.toString());//[I@41649a55
//初始化
//intArray = {1,2,3,4,5};
//not ok 只允许在声明且创建的同时赋初始值
int[] intArray2 = {1,2,3,4,5};
//ok 静态初始化，即创建数组的同时完成初始值的赋值工作
int[] intArray3 = new int[]{1,2,3};
//ok 静态初始化，即创建数组的同时完成初始值的赋值工作
//取值
int num = intArray2[0];
System.out.println(num);
int num1 = intArray2[1];
System.out.println(num1);
int num4 = intArray2[5];
//not 长度为5，下标为0-4之间，下标5即为下标越界：java.lang.ArrayIndexOutOfBoundsException
System.out.println(num4);
//赋值
intArray2[4] = 100;
System.out.println(intArray2[4]);
//数组属性length(获取数组的长度)
int length = intArray2.length;
System.out.println("数组的长度：" + length);
/*
* for循环遍历取值
*/
for(int i=0;i<intArray2.length;i++)
{
int num2 = intArray2[i]; //通过下标取值
System.out.print( num2 + "\t");
}
System.out.println();
/*
* foreach循环
*/
for (int num3 : intArray2) {
System.out.print(num3 + "\t");
}
二维数组
/**
* 多维数组（以二维数组为例）：
* 声明：
* 数组类型[][] 数组名称;
* 数组类型 数组名称[][];
* 数组类型[] 数组名称[];
*
* 创建：
* 数组类型[][] 数组名称 = new 数组类型[行数][列数];
* 数组类型[][] 数组名称 = new 数组类型[行数][];
* 数组类型[][] 数组名称 = new 数组类型[][列数];--------错误
*
* 初始化：
* 数组类型[] 数组名称 = {1,2,3,4,5} --一维
* 数组类型[][] 数组名称 = {
* {元素1，元素2，元素3，...},
* {元素3，元素4，元素5，...},
* {元素6，元素7，元素8，...},
* {元素9，元素10，元素11，...},
* ....
* }
* 数组类型[][] 数组名称 = new 数组类型[][]{
* {元素1，元素2，元素3，...},
* {元素3，元素4，元素5，...},
* {元素6，元素7，元素8，...},
* {元素9，元素10，元素11，...},
* ....
* }
*
*/
//声明
int[][] intArray;
int[][] intArray3;
int[][] intArray5;
//创建
intArray = new int[4][3];//4行3列
intArray3 = new int[5][];//5行N列
//intArray5 = new int[][4];//N行4列 ----错误
//初始化(四行三列的二维数组)
int[][] intArray2 = {
{1,2,3},
{4,5,6},
{7,8,9},
{10,11,12}
};
int[][] intArray4 = new int[][]{
{1},
{2,3,4},
{5,6},
{7},
{8,9}
};
/*
* 静态赋值：方式一
*/
int[][] intArray6 = new int[3][3];
//第一行
int[] oneRow = new int[3];//等同于 int[] oneRow = new int[]{11,12,13};
oneRow[0] = 11;
oneRow[1] = 12;
oneRow[2] = 13;
intArray6[0] = oneRow;//将第一行添加到二维数组
//第二行
int[] twoRow = new int[3];//等同于 int[] twoRow = new int[]{21,22,23};
twoRow[0] = 21;
twoRow[1] = 22;
twoRow[2] = 23;
intArray6[1] = twoRow;//将第二行添加到二维数组
//第三行
int[] threeRow = new int[3];//等同于 int[] threeRow = new int[]{31,32,33};
threeRow[0] = 31;
threeRow[1] = 32;
threeRow[2] = 33;
intArray6[2] = threeRow;//将第三行添加到二维数组
/*
* 静态赋值：方式二
*/
int[][] intArray7 = new int[3][3];
//第一行
intArray7[0][0] = 11;
intArray7[0][1] = 12;
intArray7[0][2] = 13;
//第二行
intArray7[1][0] = 21;
intArray7[1][1] = 22;
intArray7[1][2] = 23;
//第三行
intArray7[2][0] = 31;
intArray7[2][1] = 32;
intArray7[2][2] = 33;
/*
* 二维数组遍历
*/
//遍历行：方式一
for(int i=0;i<intArray7.length;i++)
{
//遍历获取每一行的数组
int[] row = intArray7[i];
//遍历行中每列值
for(int j=0;j<row.length ; j++)
{
int column = row[j]; //-------------不同之处
System.out.print(column + "\t");
}
System.out.println();//换行
}
//遍历行：方式二
for(int i=0;i<intArray7.length;i++)
{
//遍历行中每列值
for(int j=0;j<intArray7[i].length ; j++)
{
int column = intArray7[i][j]; //-------------不同之处
System.out.print(column + "\t");
}
System.out.println();//换行
}