下载文档原格式
java定义二维数组的几种写法//定义二维数组写法1class numthree{public static void main(String[] args){float[][] numthree; //定义一个float类型的2维数组numthree=new float[5][5]; //为它分配5行5列的空间大小numthree[0][0]=1.1f; //通过下标索引去访问1行1列=1.1 numthree[1][0]=1.2f; // 2行1列=1.2 numthree[2][0]=1.3f; // 3行1列=1.3 numthree[3][0]=1.4f; // 4行1列=1.4 numthree[4][0]=1.5f; // 5行1列=1.5 System.out.println(numthree[0][0]); //打印换行输出喽System.out.println(numthree[1][0]);System.out.println(numthree[2][0]);System.out.println(numthree[3][0]);System.out.println(numthree[4][0]);}}//定义二维数组写法2 定义的同时分配空间大小class numfour{public static void main(String[] args){short[][] numfour=new short[5][8]; //定义一个short类型的数组同时为它分配5行8列的空间大小numfour[0][7]=10;numfour[1][6]=20;numfour[2][5]=30;numfour[3][4]=40;numfour[4][3]=50;System.out.println(numfour[0][7]);System.out.println(numfour[1][6]);System.out.println(numfour[2][5]);System.out.println(numfour[3][4]);System.out.println(numfour[4][3]);}}//定义二维数组写法3 不规则数组class numfive{public static void main(String[] args){long[][] numfive=new long[5][]; //定义一个long类型的不规则数组numfive[0]=new long[5]; //为第1行分配5列numfive[1]=new long[6]; //为第2行分配6列numfive[2]=new long[7]; //为第3行分配7列numfive[3]=new long[8]; //为第4行分配8列numfive[4]=new long[9]; //为第5行分配9列numfive[0][4]=10000000000L; //1行5列=10000000000numfive[1][5]=20000000000L; //2行6列=20000000000numfive[2][6]=30000000000L; //3行7列=30000000000numfive[3][7]=40000000000L; //4行8列=40000000000numfive[4][8]=50000000000L; //5行9列=50000000000System.out.println(numfive[0][4]); //打印换行输出喽System.out.println(numfive[1][5]);System.out.println(numfive[2][6]);System.out.println(numfive[3][7]);System.out.println(numfive[4][8]);System.out.println(numfive[4][7]); //打印输出一个没有定义数组元素的数组java 会自动将他初始化值为0}}//定义2维数组写法4 定义的同时赋初始值class numsix{public static void main(String[] args){double[][] numsix={{1.111D,2.222D,3.333D},{4.444D,5.555D,6.666D}};//定义double型的数组分配3行3列的空间同时赋值System.out.println(numsix[0][0]); //打印换行输出1行1列=1.111System.out.println(numsix[1][1]); //打印换行输出2行2列=5.555}}//定义2维数组写法5 定义不规则的2维数组同时赋初始值class numseven{public static void main(String[] args){int[][] numseven=new int[][]{{10,20,30},{40,50},{60}}; //没什么好说的如果你在看不懂那就别学了！System.out.println(numseven[0][2]);System.out.println(numseven[1][1]);System.out.println(numseven[0][0]);}}//定义2维数组写法6 定义不规则的2维数组同时赋初始值；class numeight{public static void main(String[] args){int[][]numeight={{100,200,300,400},{500,600,700,800},{900,1000,1100,1200,1300}}; System.out.println(numeight[0][2]);System.out.println(numeight[1][2]);System.out.println(numeight[2][1]);}}。
数组的元素也可以是数组，每个数组的一个元素都是由一个一维数组构成，被称为二维数组。
同样，多维数组可以看作是数组的数组，即N维数组的每一个元素就是一个N-1维数组。
如：三维数组中的每一个元素都是一个二维数组。
多维数组的定义即初始化与二维数组的基本类似，因此本节主要讲述二维数组。
1 、二维数组的声明二维数组声明的一般格式如下：数据类型数组名[][];或者格式如下：数据类型[][] 数组名;其中数据类型与一维数组的相同，它既可以是基本数据类型，也可以是复合数据类型，数组名可以是任意合法的变量名。
下面是数组声明举例。
char ch[][];double[][] d;String[][] str;与一维数组的声明相同，二维数组也不需要规定其中任意一维的长度，下面的声明都是不合法的。
char ch[4][];double[][5] d;String[6][7] str;2、二维数组的初始化二维数组的初始化也分为直接初始化和动态初始化两种方式。
直接初始化必须在声明时开始，如下 ··124面的例子所示。
int array[][] = {{1,2},{2,4},{4,8}};二维数组的动态初始化又可分为两种方式：一种是直接规定每一维的长度，并分配所需的内存空间，另一种是从高维开始，分别为每一维规定长度并分配内存空间。
直接为每一维分配内存的格式如下：变量名= new 数据类型[二维长度][一维长度];其中二维长度和一维长度都是大于0的整数，如下所示。
int array[][];array = new int[3][5];array是一个二维数组，二维长度为3，array[0]、array[1]、array[2]都是一维数组，长度都是5。
分别分配内存格式如下：变量名= new 数据类型[二维长度][];变量名[0] = new 数据类型[一维长度0];变量名[1] = new 数据类型[一维长度1];变量名[2] = new 数据类型[一维长度2];...变量名[二维长度-1] = new 数据类型[一维长度n];下面是一个二维数组初始化的实例。
java⼆维数组和对象数组1.⼆维数组：⼆维数组就是存储⼀维数组(内存地址/引⽤)的数组2.⼆维数组的初始化1) int intA[][]={{1,2},{2,3},{3,4,5}};2) int [][] intB=new int[3][5];3) int []intC []=new int[3][];intC[0]=new int[2];intC[1]=new int[3];intC[2]=new int[5];1public class TestArray2 {2public static void main(String[] args) {3//⼆维数组不是规则的矩阵4int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};5 System.out.println(intA);//[[I@5e265ba4 两个[[表⽰是⼆维的 I表⽰数组是int型 @5e265ba4是内存地址67//声明⼀⼀个⼆维数组，⽤于存储3个⼀维数组，每⼀个⼀维数据存多少个数组，不知道，null8int [][]intB=new int[3][];9 intB[0]=new int[3]; //310 intB[1]=new int[]{1,2,3,4}; //311 intB[2]=new int[2]; //212 System.out.println(intB[1]);//[I@156643d413 System.out.println(intB[1][1]);//21415//声明⼀个⼆维数组，同时创建出⼀维数组，每个⼀维数组的长度均相同16//存储三个⼀维数组，每个⼀维数组的长度为417int []intC[]=new int[3][4];18 System.out.println(intC);1920 }21 }3.⼆维数组的遍历1) 普通 for 循环2) 加强 for 循环3) 普通 for 循环+加强 for 循环public class TestArray3 {public static void main(String[] args) {//⼆维数组int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};//(1)普通for循环for(int i=0;i<intA.length;i++){ //0,1,2for(int j=0;j<intA[i].length;j++){ //每⼀个⼀维数组的长度System.out.print(intA[i][j]+"\t");}System.out.println();}//(2)加强for循环System.out.println("\n=========================");for(int[] arr:intA){ //int[]⼆维数组中元素的类型, arr迭代变量, intA⼆维组的名称for(int i:arr){ //int，⼀维数组中元素的类型，i,迭代变量,arr，⼀维数组的名称 System.out.print(i+"\t");}System.out.println();}//(3)普通与加强for循环的混搭System.out.println("\n-------------------------");for(int [] arr:intA){//加强forfor(int i=0;i<arr.length;i++){System.out.print(arr[i]+"\t");}System.out.println();}System.out.println("\n--------------------------");for(int i=0;i<intA.length;i++){for(int j:intA[i]){//加强forSystem.out.print(j+"\t");}System.out.println();}}}View Code4.对象数组存储表格数据张三 19 男李四 20 ⼥王五 28 男数组存基本数据类型，也可以存引⽤数据类型对象数组：使⽤数组存储对象（⾃定义对象）public class Person {private String name;//姓名private int age;//年龄private String gender;//性别//重写toString以打印想要的输出否则只会打印对象的内存地址@Overridepublic String toString() {// TODO Auto-generated method stubreturn name+"\t"+age+"\t"+gender;//}public Person(String name, int age, String gender) {super(); = name;this.age = age;this.gender = gender;}public Person() {super();}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getGender() {return gender;}public void setGender(String gender) {this.gender = gender;}View Code1public class TestArray {2public static void main(String[] args) {3//创建⼀个Person类型的数组，⽤于存储3个Person类型的对象4 Person [] pers=new Person[3];5//创建Person类型的对象6 Person p1=new Person("张三", 19, "男");7//将p1对象存储到Person类型的数组中8 pers[0]=p1;910 pers[1]=new Person("李四", 20, "⼥");11 pers[2]=new Person("王五",28,"男");1213for(int i=0;i<pers.length;i++){14 System.out.println(pers[i]);15 }16//对象数组中存储的是对象的引⽤（内存地址）17 }18 }5.数组拷贝地址的拷贝int[]array={11,22,33,44};int[] arrayB=new int[5];arrayB=array //两个数组指向同⼀内存值的拷贝int[]array={11,22,33,44};int[] arrayB=new int[5];arrayB[0]=array[0];System 类中的 arraycopy(…)⽅法：快速，数组⼤时⽤次⽅法。
【黑马程序员】Java 中二维数组今天我们来聊一聊二维数组，所谓二维数组就是其元素是一维数组的数组。
因为二维数组在平时的开发中接触比较少。
所以借此机会来总结一下二维数组的常见定义格式和相关知识。
首先，我们以定义一个int 类型的二维数组为例，看一下二维数组的定义格式都是有哪些： 1 2 3 int[][] arr 1;int[] arr 2[];int arr 3[][]; 好像除了第一种，后边的两种不太常见，但是也是二维数组的合法定义格式。
接下来，我们来看看二维数组的初始化方式，一维数组我们很熟悉，有两种初始化方式，一种是静态初始化，一种是动态初始化。
我们的二维数组也是一样。
也有静态初始化和动态初始化两种方式。
首相来看一下动态初始化： 1 i nt[][] arr 1 = new int[3][2];这是创建一个二维数组，其中包含3个一维数组，每个一维数组中有两个元素。
这种动态初始化方式不太灵活，规定了每个一维数组的长度都是二。
我们接下来介绍一下另外一种比较灵活的动态初始化方式。
1 2 3 4 int[][] arr = new int[3][];arr[0] = new int[2];arr[1] = new int[4];arr[2] = new int[5];首先，初始化二维数组的时候，只声明其包含3个一维数组。
然后在给每个一维数组初始化，每个一维数组可以是不同长度的。
这样就灵活多了。
最后我们介绍一下二维数组的静态初始化方式：1 i nt[][] arr = {{1,2},{4,5,6}};创建的这个二维数据是有两个一维数组。
第一个一维数组有两个元素。
第二个一维数组有三个元素。
静态初始化是一种比较灵活的初始化方式。
我们接下来介绍一下二维数组的遍历方法： 1 2 3 4 5 6 int[][] arr = {{1,2,3},{4,5,6}};for (int i = 0; i < arr.length; i ++) {for (int j = 0; j < arr[i].length; j ++) {System.out.println (arr[i][j]);}}最后我们来看一下一个比较冷门的只是就是如下代码声明的是什么呢：1 i nt[] arr1,arr2[];比较有迷惑性，这是声明了一个一维数组arr1，和一个二维数组arr2.。
Java基础语法之⼆维数组详解⽬录⼀、⼆维数组⼆、⼆维数组的声明与初始化2.1声明2.2初始化2.2.1静态初始化2.2.2动态初始化三、⼆维数组的遍历四、⼆维数组的内存图分析五、数组操作的常见异常六、总结⼀、⼆维数组进⼊正题之前.⾸先为了便于⼤家理解,我画了⼀个图:xx枪战游戏中, 我是⼀个刚刚注册账号的⼩⽩,系统送了我两把枪,此时,我的武器库只有这么⼀层(可以理解为⼀位数组,枪就是对应的数组中对应的元素)经过艰苦卓绝的战⽃,终于有了⼀笔钱,现在我打算配置好的游戏装备,我现在有了⼀个枪柜,它可以存放三层的枪械,每⼀层都可以放多把武器(这个就是⼆维数组,有多层,每层都是⼀个⼀维数组)随着游戏时长和我的⾼超技术,获取游戏装备的效率越来越⾼了,⼀个枪柜已经存不下了,于是,我就有了多个枪柜(这个就是多维数组,单个维度存放的就是单个的⼆维数组,单个⼆维数组中有多个⼀维数组~):上图从⼀维数组到多维数组的演变~是不是很形象,哈哈~⼆维数组的定义⼆维数组,本质上就是⼀个数组,它内部⼜包含了多个⼀维数组⼆维数组也可以看成⼀个⼆维表，⾏*列组成的⼆维表，只不过这个⼆维表，每⼀⾏的列数还可能不同。
但是每⼀个单元格中的元素的数据类型是⼀致的，例如：都是int，都是String等⼆维数组的标记: [][]⼆、⼆维数组的声明与初始化2.1 声明声明⼀个⼆维数组int[][] arr;语法格式//推荐元素的数据类型[][] ⼆维数组的名称;//不推荐元素的数据类型⼆维数组名[][];//不推荐元素的数据类型[] ⼆数组名照例,我把⼀些不推荐但是不会造成编译异常的写法放上,因为有的⾯试题会遇到,有印象就好2.2 初始化初始化如同⼀维数组⼀样,同样有两种⽅法2.2.1 静态初始化//1.先声明，再静态初始化元素的数据类型[][] ⼆维数组名;⼆维数组名 = new 元素的数据类型[][]{{元素1，元素2，元素3 。
},{第⼆⾏的值列表},...{第n⾏的值列表}};//2.声明并同时静态初始化元素的数据类型[][] ⼆维数组名 = new 元素的数据类型[][]{{元素1，元素2，元素3 。
java 二维数组
与C 、C++一样，Java 中多维数组可以被看作数组的数组，如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。
下面我们主要以二维数为例来进行说明，与高维的情况是类似的。
1．创建二维数组
多维数组的声明和一维数组的声明大致相同。
声明数组包括数组的名称、数组包含元素的数据类型。
分别指明数组的长度，其中size1指定最外层数组的长度，size2指定内层数组的长度。
2．初始化二维数组
初始化数组是由内到外逐步初始化，如下所示。
该数组的内存结构如图
4-19所示。
Temp[0]
Temp[1]
图4-19 内存结构示意图
在图4-19中，temp[0]与temp[1]元素中存放的是低维数组的引用，相当于C语言中的内存地址。
最右边的一维数组才存放着所使用的数据。
Java数组、动态数组、⼆维数组的应⽤⼀、认识数组1、容器的概念⽤于存储数据的⼀块内存称为容器，⽣活中有很多容器，例如⽔杯，⾐柜，以及存放“东西”存放在容器中的数据，称为“元素”2、为什么会存在数组呢？假如现在存储全班同学的成绩，全班40⼈，按照定义变量的思维，需要定义40个double类型的数据变量，每次从40个变量中找⼀个变量，操作很⿇烦，java中可以定义以和数据类存放40个⼈的成绩，使⽤数据类型存储数组定义：它是相同数据类型的有序集合3、数据特点数组的长度固定（数据的长度⼀旦声明，就不能改变）数组中存储的元素数据类型必须相同数组的元素通过下标访问，且下标默认从0开始数组类型属于引⽤数据类型，数组的元素类型既可以是基本数据类型也可以是引⽤数据类型4、数组的创建⽅式⽅式⼀数组存储的数据类型 [] 数组名 = new 数组存储的数据类型 [长度]详解：数组存储的数据类型：创建数组容器中可以存储说明数据类型（基本数据类型、引⽤数据类型）[]：表⽰数组数组名：给数组起名字，遵循标识符规则new：创建数组的关键字[长度]：数组的长度，这个长度定义后不可改变可表⽰为array.length例如int [] arr = new int[3];new出来的空间在堆内存中，数组是引⽤数据类型，存在内存地址内存解析：在堆内存中开票⼀段连续的3个长度的int类型的内存空间，并由arr变量指向这块内存地址（换句话说rr输出就是这个内存的地址）⽅式⼆数据类型 [] 数组名 = new 数据类型 []{元素1，元素2，元素3.。
}这⾥的数组长度就是元素的个数⾃动分配⼤⼩int[] arr = new int[]{99 .97 .95};或者int arr [] = new int[]{90,95,96,94}⽅式三数据类型 [] 数组名 = {元素1，元素2，元素3.。
}注意：这⾥的元素类型必须满⾜数组的元素数据类型char [] arr = {'a','b','c'}或者char arr [] = {'a','b','c'}5、数组的访问数组的访问通过索引访问索引（下标）：每⼀次数组的元素都有⼀个编号，这个编号从0开始，这个编号称为数组的索引，通过数组名[索引]访问到数组的元素例如：访问数组的第⼆个元素：数组名[1];数组的长度：数组的长度声明以固定，访问数组的长度：数组名.length数组的最⼤索引 = 数组长度 - 1数组元素的赋值：通过索引可以给元素赋值数组名[索引] = 值将数据赋值给指定索引的元素⼆、动态数组1、数组的定义⽤于存储相同数据类型的⼀组连续的存储空间2、数组的特点数组的长度⼀旦定义，则不可改变访问数组元素需要通过下标（索引）访问，下标从零开始数组是引⽤数据内存，内存分布在堆内存中，数组的变量存储在内存地址3、动态数组由于数组的长度定义后不能改变，所谓“动态数组”是可以增加数据长度，所以java实现动态数组是改变数组变量指向不同的内存地址，本质并没有将数组的长度改变动态数组的本质：将内存空间的改变，以及指向数组内存地址的改变操作1：数组添加新元素，可添加在最后⾯，也可以添加到指定位置/*** 添加元素，（添加到末尾）*/public static int[] addEle(int []array ,int num){//初始数组添加的元素// int array [] = {10,9,3,2,1};//1、创建临时数组的长度int [] tempArray = new int[array.length+1];//2\将⽬标数组的元素 copy到临时数组的内存中for (int i=0;i<array.length;i++){tempArray[i]=array[i];}//3、将添加的元素放⼊临时数组中tempArray[tempArray.length-1]=num;//4、将⽬标数组的地址指向临时数组的地址array=tempArray; //由于tempArray 是局部变量⽅法执⾏完内存⾃动回收// 如果不返回没有地址指向tempArray的内存// 如果返回并接受说明这块内存地址仍然使⽤return array;}/*** 将元素num 添加到指定index的位置* @param args*/public static int [] addEle(int [] arr,int num,int index){//1、创建临时数组的⼤⼩int [] tempArray = new int[arr.length+1]//2、便利arrfor(int i=0;i<=arr.length;i++){//如果i<indexif (i<index){tempArray[i]=arr[i];}else if (i==index){tempArray[i]=num;}else{//i>indextempArray[i]=arr[i-1];}}//赋值arr=tempArray;return arr;}public static void main(String[] args) {//扩容数组// int [] array = {5,4,3};// //动态扩容⼀个// array=addEle(array,2);// for (int i=0;i<array.length;i++){// System.out.println(array[i]);// }// System.out.println(array.length);//插⼊到指定下标int[]arrary={10,9,3,2,1};arrary = addEle(arrary,5,5);System.out.println(Arrays.toString(arrary)); // 直接输出数组的每⼀个元素}操作2：可删除元素删除指定下标元素/*** 删除指定下标的数组元素，删除后⾯的向前缩进⼀个*/public static int [] Ele(int arr[],int index){//1、创建⼀个新的临时数组int tempArray [] =new int[arr.length-1];for (int i=0;i<arr.length-1;i++){if (i<index){tempArray[i]=arr[i];}else {tempArray[i]=arr[i+1];}//i=3 temparray[3]=arr[4];//i=4 temparray[4]=arr[4+5];}//赋值arr=tempArray;return arr;}public static void main(String[] args) {int array []={10,5,4,7,8,6};array=Ele(array,3);System.out.println(Arrays.toString(array));}三、⼆维数组1、⼆维数组定义在⼀维数组中定义每⼀个元素也是⼀个数组元素，这样的数组称为“⼆维数组”多维数组就是在⼀维数组上再次定义⼆维数组或三位数组等。
java二维数组定义方法
一。
在 Java 中，二维数组就像是一个摆放整齐的表格，能帮我们处理很多有规律的数据。
1.1 先来说说最常见的定义方式。
就好比我们要给一个班级的学生安排座位，我们可以这样定义：int[][] arr = new int[3][4]; 这就好比我们准备了 3 行 4 列的座位，等着学生们“入座”。
1.2 还有一种定义方式，就像我们提前知道了每个座位上的具体情况。
比如：
int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 这是不是很直观，一目了然。
那在使用二维数组的时候，也有一些小窍门。
2.1 访问数组元素可不能马虎。
要通过行和列的索引来找到具体的“座位”上的值。
比如说 arr[1][2]，就能拿到第二行第三列的那个数。
2.2 遍历二维数组也有多种方法。
可以用两个嵌套的 for 循环，就像我们一个一个座位去查看一样。
2.3 给二维数组赋值也不难，按照对应的位置放进去就行，千万别放错了“座位”。
三。
最后再唠叨几句。
3.1 二维数组能让我们的数据结构更清晰，处理起来更有条理。
3.2 掌握好二维数组的定义和使用，就像手里有了一把好用的工具，能在编程的道路上更加得心应手。
Java 中的二维数组是个很实用的东西，只要我们用心去理解，多练习，就能运用自如，让我们的程序更加精彩！。
Java之多维数组（⼆维数组）⼀、多维数组 Java 语⾔⾥提供了⽀持多维数组的语法。
如果说可以把⼀维数组当成⼏何中的线性图形，那么⼆维数组就相当于是⼀个表格，类似于⼀个 Excel表格。
以⼆维数组来讨论，可以看成⼀维数组array1 中⼜作为另⼀个⼀维数组 array2 的元素⽽存在的。
⼆、⼆维数组声明与初始化 1、格式1：动态初始化 语法格式：int[][] arr = new int[3][2]; 定义了⼀个名称为 arr 的⼆维数组，⼆维数组中有3个⼀维数组，每⼀个⼀维数组中有2个元素，⼀维数组的名称分别为 arr[0]，arr[1]， arr[2] 给第⼀个⼀维数组下标为1赋值为78的写法是：arr[0][1] = 78; 2、格式2：动态初始化int[][] arr = new int[3][2]; ⼆维数组中有3个⼀维数组，每个⼀维数组都是默认初始化值 null。
（注意：区别与格式1） 可以对这个三个⼀维数组分别进⾏初始化。
arr[0]=new int[3]; arr[1] = new int[1]; arr[2] = new int[2]; 注意： int[][] arr = new int[][3]; 是⾮法的，即第⼀个[]中必须有值。
3、格式3：静态初始化 语法格式：int[][] arr = new int[][]{{3, 8, 2}, {2, 7}, {1, 2, 3, 4}}; 定义⼀个名称为 arr 的⼆维数组，⼆维数组中有三个⼀维数组，每⼀个⼀维数组中具体元素也都初始化了。
第三个⼀维数组的长度表⽰⽅式： arr[2].length； 注意：特殊写法情况int[] x,y[]: x是⼀维数组，y 是⼆维数组 Java 中多维数组不必都是规则矩阵形式，⽐如上⾯的每个⼀维数组的长度各部相同。
4、根据类型推断省略格式int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};三、⼆维数组的长度和访问 1、长度 由于⼆维数组并不是规则的矩阵，其中的长度也不是同⼀的。
二维数组的定义基本与一维数组类似//定义一个3行5列的二维数组//方法1，先new对象，然后再初始化每个元素int[][] a = new int[3][5];a[0][0]=1;a[0][1]=2;a[0][2]=3;//方法2，直接赋初值来创建对象int[][] b = {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };//方法3，new完对象直接初始化int[][] a = new int[][] {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };定义二维数组必须指定其行数，列数可以指定，可以不指定。
这样定义是正确的：int[][] d = new int[3][];这样定义是错误的：int[][] d = new int[][4]; int[][] d = new int[][]; 也可以定义不规则数组：arr = new int[2][];arr[0] = new int[3];arr[1] = new int[5];3 数组的长度length是数组的一个属性(不是方法!)，对于一维数组int[] b = {1,2,3}; b.length 的值是3，对于二维数组，首先研究一下它的配置细节：int[][] arr = new int[2][3];上面这个程序片段中，配置了 2 行 3 列的二维数组对象，由于数据类型是int ，所以数组元素的预设元素为0 。
其实arr[0] 、arr[1] 是两个一维数组对象，其长度各为 3 ，而arr 类型是int[] [] ，内容值为arr[0] 与arr[1]Java 二维数组的声明和初始化1.二维数组可以看成以数组为元素的数组；2.Java中二维数组的声明和初始化应按照从高维到低维的顺序进行。
数组的初始值：实例：静态初始化：Array2.java:程序代码定义二维数组写法1定义二维数组写法2定义二维数组写法3。
