如何架设一个网站,东莞石龙网站建设莞网站制作,建立网站策划书,手机之家下载安装目录 引言
一、数组概述
1.什么是数组#xff1f;
2.数组的分类#xff1f;
3.Java数组存储元素的特点#xff1f;
4.数组优点#xff1f;
5.数组缺点#xff1f;
二、一维数组
1. 静态初始化一维数组
2.增强 for 循环#xff08;for-each 循环#xff09;
3…目录 引言
一、数组概述
1.什么是数组
2.数组的分类
3.Java数组存储元素的特点
4.数组优点
5.数组缺点
二、一维数组
1. 静态初始化一维数组
2.增强 for 循环for-each 循环
3.动态初始化一维数组
4.当一维数组中存储引用时的内存图
5.如何获取数组中的最大值
6.如果知道值如何通过值找它的下标
7.如何将数组中的所有元素反转
⑴第一种方式创建一个新的数组。
⑵第二种方式首尾交换
8.关于main方法的形参args的作用
①在DOS命令窗口中怎么传
② 在IDEA中怎么传
③应用场景
9.关于方法的可变长度参数
⑴.语法
⑵.示例代码
⑶.代码解释
⑷.注意事项
10.一维数组的扩容
⑴.System.arraycopy() 方法
⑵. 使用 Arrays.copyOf() 方法
⑶. 手动遍历复制
⑷.关于数组扩容的效率问题
三、二维数组
1. 静态初始化
2. 二维数组动态初始化 引言
数组是Java中最基础且重要的数据结构之一用于存储相同数据类型的元素集合。本文将全面解析Java数组的特性、用法及常见应用场景。
一、数组概述
1.什么是数组 ①在Java中数组是一种用于存储多个相同数据类型元素的容器。 ②例如一个存储整数的数组int[] nums {100, 200, 300}; ③例如一个存储字符串的数组String[] names {“jack”,“lucy”,“lisi”}; ④数组是一种引用数据类型隐式继承Object。 ⑤因此数组也可以调用Object类中的方法。 ⑥数组对象存储在堆内存中。 2.数组的分类 ①根据维数进行分类一维数组二维数组三维数组多维数组。 ②根据数组中存储的元素类型分类基本类型数组引用类型数组。 ③根据数组初始化方式不同分类静态数组动态数组。 3.Java数组存储元素的特点 ①数组长度一旦确定不可变。 ②数组中元素数据类型一致每个元素占用空间大小相同。 ③数组中每个元素在空间存储上内存地址是连续的。 ④每个元素有索引首元素索引0以1递增。 ⑤以首元素的内存地址作为数组对象在堆内存中的地址。 ⑥所有数组对象都有length属性用来获取数组元素个数。末尾元素下标length-1 4.数组优点 ①根据下标查询某个元素的效率极高。数组中有100个元素和有100万个元素查询效率相同。时间复杂度O(1)。也就是说在数组中根据下标查询某个元素时不管数组的长短耗费时间是固定不变的。 ②原因知道首元素内存地址元素在空间存储上内存地址又是连续的每个元素占用空间大小相同只要知道下标就可以通过数学表达式计算出来要查找元素的内存地址。直接通过内存地址定位元素。 5.数组缺点 ①随机增删元素的效率较低。因为随机增删元素时为了保证数组中元素的内存地址连续就需要涉及到后续元素的位移问题。时间复杂度O(n)。O(n)表示的是线性阶随着问题规模n的不断增大时间复杂度不断增大算法的执行效率越低。不过需要注意的是对数组末尾元素的增删效率是不受影响的。 ②无法存储大量数据(原因因为很难在内存上找到非常大的一块连续的内存。 二、一维数组
1. 静态初始化一维数组 第一种方式 数据类型[ ] 变量名 new 数据类型[ ] { 元素1,元素2,元素3.... }; 比如
int[] arr new int[]{1,2,3,34,45};
第二种方式 数据类型[ ] 变量名 {元素1,元素2,元素3....}; // 方式一指定数组元素类型后跟方括号和数组名
数据类型[] 数组名;
// 方式二指定数组元素类型数组名后跟方括号
数据类型 数组名[];
// 声明一个整型数组
int[] intArray;
// 声明一个字符串数组
String stringArray[];
通常推荐使用第一种方式因为它更能清晰地表明这是一个数组类型。
比如
int[] arr {1,2,3,3,4,45,6};
注意在创建数组对象的时候提前知道数组中应该具体存储哪些元素建议使用静态初始化
示例代码
public class ArraysTest {public static void main(String[] args) {// 静态初始化一维数组的第一种方式int[] arr new int[]{100, 200, 300};String[] names new String[]{jack,lucy,tom};// C/C的风格不建议的知道就行别人这样写能看懂就行//int nums[] new int[]{100, 200, 300};// 静态初始化一维数组的第二种方式省略newint[] nums {200, 500, 666, 888};String[] citys {北京, 上海, 天津};//数组也是引用数据类型Animal a1 new Animal();Animal a2 new Animal();Animal a3 new Animal();Animal[] animals {a1, a2, a3, new Animal()};}
}
class Animal{}
2.增强 for 循环for-each 循环 * 增强for循环/for-each循环。JDK5的新特性。
*
* for each语法结构
* for(数据中元素的数据类型 变量名 : 数组名){
*
* }
*
* 注意变量名 代表数组中的每个元素。
*
* for each的优点代码简洁可读性强。
*
* for each的缺点没有下标。如果需求中需要使用到下标这种方式就差一点。 示例代码
/*** 增强for循环/for-each循环。JDK5的新特性。** for each语法结构* for(数据中元素的数据类型 变量名 : 数组名){** }** 注意变量名 代表数组中的每个元素。** for each的优点代码简洁可读性强。** for each的缺点没有下标。如果需求中需要使用到下标这种方式就差一点。*/
public class ArraysTest1 {public static void main(String[] args) {//静态初始化一维数组int[] arr{100,200,300};String[] names{jack,lucy,tom};//遍历arr数组for-eachfor(int num : arr){// num代表数组中的每个元素System.out.println(num);}//遍历names数组for-eachfor(String name : names){System.out.println(name);}}
}
运行结果 增强 for 循环适用于只需要访问数组元素而不需要使用索引的场景。
3.动态初始化一维数组
方式
数据类型[] 数组名 new 数据类型[数组长度];
示例代码
import java.util.Random;/*** 一维数组的动态初始化* 1. 什么时候使用动态初始化一维数组呢* 当创建数组时不知道数组中具体存储哪些元素可以使用动态初始化。* 2. 语法格式* 数据类型[] 变量名 new 数据类型[长度];* 3. 动态初始化一维数组之后数组长度确定数组中存储的每个元素将采用默认值。* 4. 默认值* 数据类型 默认值* * byte 0* short 0* int 0* long 0L* float 0.0F* double 0.0* boolean false* char \u0000* 引用数据类型 null*/
public class ArrayTest04 {public static void main(String[] args) {// 动态初始化一维数组int[] nums new int[4];for (int num : nums) {System.out.println(num);}String[] names new String[10];for(String name : names) {System.out.println(name);}System.out.println();Object[] objs new Object[5];for (Object obj : objs) {System.out.println(obj);}System.out.println();// 向objs数组的第三个位置上放一个对象objs[2] new Object();for (Object obj : objs) {System.out.println(obj);}double[] scores new double[10];// 创建一个随机数生成器对象Random random new Random();for (int i 0; i scores.length; i) {scores[i] random.nextDouble(101);}// 遍历for(double score : scores){System.out.println(score);}}
}
运行结果 小细节当一个方法的参数是一个数组的时候我们怎么传参数
示例代码
/*** 当一个方法的参数是一个数组的时候我们怎么传参数*/
public class ArrayTest05 {public static void main(String[] args) {// 第一种方式静态初始化创建好数组对象然后传进去int[] nums {1,2,3,4};display(nums);System.out.println();// 第二种方式静态初始化直接传//display({1,2,3,4}); // 这是错误的。display(new int[]{1,2,3,4}); // 这是正确的。注意这个小细节。System.out.println();// 动态初始化方式。display(new int[10]);}/*** 遍历一维数组。* param arr*/public static void display(int[] arr) {for(int num : arr) {System.out.println(num);}}
} “Array initializer is not allowed here” 错误主要是因为在不恰当的位置使用了数组初始化器解决的关键在于确保在需要初始化数组时正确使用 new 关键字。
4.当一维数组中存储引用时的内存图
父类Animal
public class Animal {}
子类Bird
public class Bird extends Animal{public void fly(){System.out.println(鸟儿在飞翔);}
}
子类Cat
public class Cat extends Animal{public void catchMouse(){System.out.println(猫抓老鼠);}
}
测试类Test
public class Test {public static void main(String[] args) {//要求创建一个数组让该数组既可以存储Cat又可以存储BirdAnimal[] animals{};//创建一个数组既能够存储A又能存储BA anew A();B bnew B();Cat cnew Cat();Object[] objs{a,b,c};Bird birdnew Bird();//Cat[] cats{c,bird};//编译报错类型不统一/不一致Object[] objs2{c,bird};}
}
class A{}
class B{}
当放进去的类型不一致时编译会报错 测试类Test02
public class Test1 {public static void main(String[] args) {Bird b new Bird();Cat c new Cat();// 创建一个数组让该数组既可以存储Cat又可以存储Bird// 数组中存储的不是对象本身实际上是对象在堆内存当中的地址。存储的是引用。Animal[] animals {b, c, new Cat(), new Bird()};}
}
当一维数组中存储引用时的内存图 5.如何获取数组中的最大值
假设首元素是最大的然后遍历数组中所有元素只要有更大的就将其作为最大值。
思考找出最大值的下标怎么做
示例代码
public class ArrayTest4 {public static void main(String[] args) {int[] arr {1,3,3,4,45,56,6,7,87,8,8898,1,2,1};System.out.println(arr.length);int max searchMax(arr);System.out.println(最大值是 max);int maxIndex searchMaxIndex(arr);System.out.println(最大值的下标是 maxIndex);}/*** 找最大值的下标* param arr 数组* return 最大值的下标*/public static int searchMaxIndex(int[] arr) {// 假设第一个元素是最大的。int maxIndex 0;// 遍历数组for (int i 0; i arr.length; i) {if(arr[i] arr[maxIndex]) {maxIndex i;}}return maxIndex;}/*** 从arr数组中找最大值。* param arr 数组* return 最大值*/public static int searchMax(int[] arr) {// 假设第一个是最大的int max arr[0];// 遍历数组//1.法一for (int num : arr) {if(num max){max num;}}//2.方案二for (int i 0; i arr.length; i) {if(arr[i] max) {max arr[i];}}return max;}
}
6.如果知道值如何通过值找它的下标
示例代码
/*** 知道要查数组中的哪个值请返回这个值第一次出现处的下标因为可能重复*/
public class ArrayTest07 {public static void main(String[] args) {int[] arr {200,1,33,4,5,110,56,120,6,120,120,7,4,4,43,3,3,3};int elt 200;int index findIndexByElt(arr, elt);System.out.println(index 0 ? elt 在数组中的下标是 index : 您查找的数据不存在);}/*** 从arr数组中查找elt元素的下标。第一次出现处的下标* param arr 数组* param elt 要查找的元素* return 元素下标*/public static int findIndexByElt(int[] arr, int elt){for (int i 0; i arr.length; i) {if(arr[i] elt) {return i;}}// 找不到就返回-1return -1;}
}
7.如何将数组中的所有元素反转 第一种方式创建一个新的数组。 第二种方式首位交换。 ⑴第一种方式创建一个新的数组。
public class ArrayTest5 {// 用创建一个新数组的方式进行数组的反转。public static void main(String[] args) {int[] arr {1,2,3,4,5,6,7,8,9};// 反转int[] newArr reverse(arr);// 遍历for (int i 0; i newArr.length; i) {System.out.println(newArr[i]);}}public static int[] reverse(int[] arr){// 第一种方式创建新数组// 动态初始化一维数组int[] newArr new int[arr.length];// 遍历新数组for (int i 0; i newArr.length; i) {newArr[i] arr[arr.length - 1 - i];}return newArr;}
}运行结果 ⑵第二种方式首尾交换 假设数据有偶数个
* {1,2,3,4}
* 第一次循环{4,2,3,1}
* 第二次循环{4,3,2,1}
*
* 假设数据有奇数个
* {1,2,3,4,5}
* 第一次循环{5,2,3,4,1}
* 第二次循环{5,4,3,2,1}
*
* 无论数组中的数据量是奇数还是偶数循环的次数都是length / 2 示例代码
public class ArrayTest6 {// 首尾交换的方式完成数组的反转。public static void main(String[] args) {int[] arr {1,2,3,4,5,6,7,8,9};// 反转reverse(arr);// 遍历for (int i 0; i arr.length; i) {System.out.println(arr[i]);}}/*** 这种方式完成的数组反转不但效率高循环次数少而且还节省空间因为不需要new新的数组对象。* param arr*/public static void reverse(int[] arr){for (int i 0; i arr.length / 2; i) {// 首尾交换// 首 arr[i]// 尾 arr[arr.length - 1 - i]int temp arr[i];arr[i] arr[arr.length - 1 - i];arr[arr.length - 1 - i] temp;}}
}
运行结果 8.关于main方法的形参args的作用 ①接收命令行参数 ②在DOS命令窗口中怎么传 在IDEA中怎么传 ①在DOS命令窗口中怎么传
⑴.在 Java 中public static void main(String[] args) 是程序的入口方法其中 String[] args 是该方法的参数它是一个字符串类型的数组。下面详细介绍它的作用和使用方式
作用
String[] args 的主要作用是接收从命令行传递给 Java 程序的参数。当你运行一个 Java 程序时可以在命令行中输入一些额外的信息这些信息会被存储在 args 数组中程序可以根据这些参数执行不同的操作这为程序提供了一定的灵活性和交互性。 关于main方法上的String[] args作用是什么
1. 作用接收命令行参数用的。2. JVM负责调用ArrayTest.main()方法。JVM负责给main方法准备一个String[]一维数组的对象。3. java ArrayTest abc def xyz底层JVM是怎么做的命令行参数abc def xyzJVM会将以上字符串以“空格”进行拆分生成一个新的数组对象。最后这个数组对象是String[] args {abc,def,xyz};4. 命令行参数有什么用需求使用该系统的时候需要提供正确的口令用户名和密码如果用户名是admin并且密码是admin123则表示合法用户其他用户是非法的。非法用户直接退出系统。 示例代码
public class ArrayTest{public static void main(String[] args){System.out.println(args);System.out.println(如果命令在使用的时候没有提供参数则数组的长度是args.length);}}
运行 示例代码2
public class ArrayTest {public static void main(String[] args) {if(args.length ! 2){System.out.println(对不起要使用该系统至少需要提供用户名和密码用户名和密码需要通过命令行参数传进来例如java ArrayTest 用户名 密码);return;}// 取出用户名String username args[0];// 取出密码String password args[1];if(username.equals(admin) password.equals(admin123)){System.out.println(登录成功欢迎使用本系统);System.out.println(.....);}else{System.out.println(对不起您的用户名不存在或者密码错误请重新进入);return;}}
}
运行 // 当两个字符串String进行equals的时候并且其中有一个字符串是字面量。
// 建议将字面量写到前面。可以避免空指针异常的发生。 示例代码3 // 需求使用该系统的用户包括两种// 一个是普通用户// 一个是超级管理用户// 如果是超级管理员用户在命令行参数的第一个参数上标注admin如果是普通用户第一个参数上标注user// 假设超级管理员的用户名和密码是zhangsan 123// 假设普通用户名和密码是lisi 123if(args.length ! 3){System.out.println(对不起命令行参数不正确要使用该系统命令行参数格式必须是java ArrayTest 角色 用户名 密码);return;}// 取出角色String role args[0];// 取出用户名String username args[1];// 取出密码String password args[2];// 当两个字符串String进行equals的时候并且其中有一个字符串是字面量。// 建议将字面量写到前面。可以避免空指针异常的发生。if(admin.equals(role) username.equals(zhangsan) password.equals(123)){System.out.println(欢迎超级管理员username请使用本系统);}else if(role.equals(user) username.equals(lisi) password.equals(123)){System.out.println(欢迎操作员username请使用本系统);}else{System.out.println(角色不对或者用户名不存在可能密码也错了);}
② 在IDEA中怎么传
示例代码
public class ArrayTest7 {public static void main(String[] args) {System.out.println(args[0]);System.out.println(args[1]);}}
运行结果 解释
直接访问了 args[0] 和 args[1]也就是数组的第一个和第二个元素。不过当你运行这个程序时没有传递任何命令行参数那么 args 数组的长度就为 0。在 Java 中数组索引是从 0 开始的一个长度为 0 的数组没有任何元素所以访问 args[0] 或者 args[1] 就会导致数组越界异常。
如何解决
1.点右上角Edit Configurations 2.选择要配置的运行项在左侧的列表中选择 ArrayTest7。
3.设置命令行参数在右侧的 Program arguments 文本框中输入至少两个参数参数之间用空格分隔例如 重新运行 ③应用场景 配置程序行为通过命令行参数可以配置程序的不同行为例如指定文件路径、设置日志级别等。批量处理任务可以传递一组数据作为参数让程序对这些数据进行批量处理。测试不同输入在开发和测试过程中可以通过传递不同的参数来测试程序在各种输入情况下的表现。 总之String[] args 为 Java 程序提供了一种从外部接收数据的方式使得程序更加灵活和可配置。
9.关于方法的可变长度参数 ①可变长参数只能出现在形参列表中的最后一个位置。 ②可变长参数可以当做数组来处理。 在 Java 中方法的可变长度参数Varargs是一种特殊的语法它允许你在调用方法时传递不定数量的参数。可变长度参数为开发者提供了更大的灵活性使得方法可以处理不同数量的输入。以下将详细介绍可变长度参数的相关内容。
⑴.语法
在方法声明中可变长度参数使用三个连续的点 ... 来表示其基本语法如下
public void methodName(Type... parameterName) {// 方法体
}
其中Type 是参数的类型parameterName 是可变长度参数的名称。在方法内部可变长度参数被当作数组来处理。
⑵.示例代码
下面是一个简单的示例展示了如何使用可变长度参数
public class VarargsExample {// 定义一个带有可变长度参数的方法public static int sum(int... numbers) {//可变长度参数在方法内部被当作数组处理int total 0;// 遍历可变长度参数数组for (int num : numbers) {total num;}return total;}public static void main(String[] args) {// 调用 sum 方法传递不同数量的参数int result1 sum(1, 2, 3);int result2 sum(4, 5);int result3 sum(6, 7, 8, 9);System.out.println(结果 1为: result1);System.out.println(结果 2为: result2);System.out.println(结果 3为: result3);}
}
运行结果 ⑶.代码解释
方法定义sum 方法使用了可变长度参数 int... numbers表示可以接收任意数量的 int 类型参数。方法内部处理在 sum 方法内部numbers 被当作数组来处理使用增强 for 循环遍历数组并计算所有元素的总和。方法调用在 main 方法中分别调用 sum 方法并传递不同数量的参数程序会根据传递的参数动态计算总和。
⑷.注意事项
一个方法只能有一个可变长度参数而且可变长度参数必须是方法的最后一个参数否则会导致编译错误。例如以下代码是不合法的
// 错误示例可变长度参数不是最后一个参数
public void invalidMethod(int... numbers, String name) {// 方法体
} 2.可变长度参数可以为空在调用方法时可以不传递任何参数给可变长度参数此时参数数组的长度为 0。例如
int result sum(); // 传递空参数
3.可变长度参数与数组的关系虽然可变长度参数在方法内部被当作数组处理但在调用方法时传递数组和传递多个参数是有区别的。例如
int[] arr {1, 2, 3};
int result1 sum(arr); // 传递数组
int result2 sum(1, 2, 3); // 传递多个参数
sum(new int[]{1,2,3,3,3,4,4,5});
sum(1,2,3,3,3,4,4,5);
这两种调用方式在功能上是等价的但语法上有所不同。
10.一维数组的扩容 关于数组的扩容问题
* 1. 数组的长度一旦确定不可变。
* 2. 如果数组满了想存储更多的数据只能创建一个新的数组将原数组中的数据全部拷贝到新数组当中。这样就可以完成扩容了。
* 3. 怎么优化建议减少扩容次数。建议预测数据量创建一个容量差不多的数组。
* 4. 扩容的时候需要使用到数组的拷贝怎么拷贝
* System.arraycopy() 在 Java 中数组的长度在创建之后确实是不可变的。若要实现数组扩容通常的做法是创建一个更大的新数组然后把原数组里的数据复制到新数组中。下面详细介绍几种实现一维数组扩容的方式。
⑴.System.arraycopy() 方法
System.arraycopy() 是 Java 提供的一个高效的数组复制方法其语法如下
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src源数组。srcPos源数组的起始位置。dest目标数组。destPos目标数组的起始位置。length要复制的元素个数。
示例代码如下
public class ArrayExpansionExample {public static void main(String[] args) {// 原始数组int[] originalArray {1, 2, 3, 4, 5};// 扩容后的新数组长度int newLength originalArray.length * 2;// 创建新数组int[] newArray new int[newLength];// 使用 System.arraycopy() 方法将原数组元素复制到新数组System.arraycopy(originalArray, 0, newArray, 0, originalArray.length);// 打印新数组元素for (int i 0; i newArray.length; i) {System.out.print(newArray[i] );}}
}
在这个示例中先定义了一个原始数组 originalArray接着创建了一个长度为原数组两倍的新数组 newArray最后使用 System.arraycopy() 方法把原数组的元素复制到新数组中。 底层是C的
⑵. 使用 Arrays.copyOf() 方法
Arrays.copyOf() 是 Java 标准库中 Arrays 类提供的一个便捷方法它可以创建一个新数组并将原数组的元素复制到新数组中同时可以指定新数组的长度。示例代码如下
import java.util.Arrays;public class ArrayExpansionExample2 {public static void main(String[] args) {// 原始数组int[] originalArray {1, 2, 3, 4, 5};// 扩容后的新数组长度int newLength originalArray.length * 2;// 使用 Arrays.copyOf() 方法进行数组扩容int[] newArray Arrays.copyOf(originalArray, newLength);// 打印新数组元素for (int i 0; i newArray.length; i) {System.out.print(newArray[i] );}}
}
Arrays.copyOf() 方法内部实际上也是调用了 System.arraycopy() 方法它简化了数组扩容的代码编写。
⑶. 手动遍历复制
除了使用上述方法还可以通过手动遍历原数组将元素逐个复制到新数组中。示例代码如下
public class ArrayExpansionExample3 {public static void main(String[] args) {// 原始数组int[] originalArray {1, 2, 3, 4, 5};// 扩容后的新数组长度int newLength originalArray.length * 2;// 创建新数组int[] newArray new int[newLength];// 手动遍历复制元素for (int i 0; i originalArray.length; i) {newArray[i] originalArray[i];}// 打印新数组元素for (int i 0; i newArray.length; i) {System.out.print(newArray[i] );}}
}
这种方法的效率相对较低尤其是在处理大规模数组时因为它需要手动进行元素复制操作而 System.arraycopy() 和 Arrays.copyOf() 方法是经过优化的本地方法执行效率更高。
⑷.关于数组扩容的效率问题
数组扩容会影响程序的执行效率因为每次扩容都需要创建新数组并复制原数组的元素。所以在实际开发中尽可能提前预测数据量创建一个接近所需数量的数组以此减少扩容的次数从而提高程序的性能。
三、二维数组
1. 静态初始化 完整语法 int[][] arr new int[][]{{1, 2}, {3}, {4, 5}}; 简化语法仅限声明时使用
int[][] arr {{1, 2}, {3}, {4, 5}};
示例代码
/*** 1.二维数组的静态初始化* 2.二维数组中元素的访问。*/
public class ArrayTest8 {public static void main(String[] args) {// 静态初始化二维数组的第一种方式// 定义一个二维数组 arr它包含多个一维数组// 这里每个大括号 {} 代表一个一维数组其中包含了具体的元素int[][] arr new int[][]{{1,2,3},{4,5,6,7,8},{1,1,1,1,1,1,1,1,1,1,100}};// 输出该二维数组中包含的一维数组的数量// arr.length 表示二维数组中一维数组的个数System.out.println(该二维数组当中有 arr.length 个一维数组);// 输出每个一维数组的长度// arr[0].length 表示二维数组中第一个一维数组的元素个数System.out.println(arr[0].length); // 3// arr[1].length 表示二维数组中第二个一维数组的元素个数System.out.println(arr[1].length); // 5// arr[2].length 表示二维数组中第三个一维数组的元素个数System.out.println(arr[2].length); // 11// 找二维数组中第一个一维数组中的第一个元素// 下面两行代码是分步获取元素的过程// 先获取二维数组中的第一个一维数组/*int[] arr0 arr[0];// 再从第一个一维数组中获取第一个元素int arr00 arr0[0];*/// 合并以上两步直接通过双重索引访问二维数组中的元素// arr[0][0] 表示二维数组中第一个一维数组的第一个元素int arr00 arr[0][0];// 输出二维数组中第一个一维数组的第一个元素System.out.println(二维数组中第一个一维数组中的第一个元素 arr00);// 访问最后一个一维数组的最后一个元素// arr.length - 1 表示二维数组中最后一个一维数组的索引// arr[arr.length - 1].length - 1 表示最后一个一维数组中最后一个元素的索引System.out.println(最后一个一维数组的最后一个元素 arr[arr.length - 1][arr[arr.length - 1].length - 1]);// 修改最后一个一维数组的最后一个元素的值为 456arr[arr.length - 1][arr[arr.length - 1].length - 1] 456;// 再次输出修改后最后一个一维数组的最后一个元素的值System.out.println(最后一个一维数组的最后一个元素 arr[arr.length - 1][arr[arr.length - 1].length - 1]);// 静态初始化二维数组的第二种方式int[][] arr2 {{1,2,3},{4,5,6,7,8},{1,1,1,1,1,1,1,1,1,1,100}};// 访问第二个一维数组的第二个元素System.out.println(arr2[1][1]);}
}
2. 二维数组动态初始化
⑴等长二维数组每个内层数组长度相同
int[][] arr new int[3][4];
外层数组长度3每个内层数组长度4初始值为0。
⑵不等长二维数组内层数组长度可变
int[][] arr new int[3][]; // 外层长度3内层未初始化均为null
arr[0] new int[2]; // 手动初始化各内层数组
arr[1] new int[3];
arr[2] new int[4];
