JavaSE学习总结（四）二维数组概述/二维数组动态初始化/二维数组静态初始化/二维数组遍历/递归解决问题的思想
一、二维数组
一）二维数组概述
二维数组其实就是每一个元素为一维数组的数组。
（二）二维数组初始化格式
1.动态初始化
1.1 二维数组格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m] [n]来获取
表示获取第m+1个一维数组的第n+1个元素
注意事项
(1)以下格式也可以表示二维数组
数据类型 数组名[][] = new 数据类型[m][n];数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
(2)注意下面定义的区别
int x,y;`
`int[] x,y[];
区别是:
int[] x,y[];
定义了两个数组 一个是一维数组x 一个是二维数组y
案例演示
public class ArrayDemo {
public static void main(String[] args) {
//二维数组：数组中的元素是一维数组，数组嵌套数组
//动态初始化
//3 表示这个二维数组里面，放了3个一维数组
//2 表示二维数组中的一维数组的长度
int[][] arr=new int[3][2];
arr[0]=new int[]{10,20};//为第一个一维数组赋值
System.out.println(arr[0]);//二维数组里第一个一维数组的地址
System.out.println(arr[1]);//二维数组里第二个一维数组的地址
System.out.println(arr[0][0]);//输出第一个一维数组的第一个元素值
System.out.println(arr[0][1]);//输出第一个一维数组的第二个元素值
System.out.println(arr.length); //二维数组的长度
System.out.println(arr[0].length);//二维数组中的第一个一维数组的长度
}
}
内存解析：
首先，程序编译好后生成了字节码文件(.class文件)，JVM将字节码文件加载进内存的方法区，而main方法是程序的入口，需要被执行，于是调用main方法进栈执行。接着，执行第一句代码，创建了一个长度为3的int型二维数组，其每个元素为长度为2的一维数组。于是堆内存为该二维数组开辟空间，并将3个元素都初始化为null，内存空间地址为0x12345678(此处随意写的一个地址)，然后再初始化3个长度为2的一维数组，开辟完空间以后将每个一维数组的引用覆盖掉二维数组的初始值null，于是这个二维数组的每个元素都指向对应的一维数组。再将0x12345678赋给二维数组的引用arr，则名为arr的这个数组便指向了地址为0x12345678的空间。main方法执行完毕后，main方法弹栈，此时就没有引用指向堆内存中地址为0x12345678的空间了，于是最后垃圾回收器回收了该空间，释放内存。
1.2 二维数组格式2
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这种格式没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];//二维数组里的第一个一维数组长度为2
arr[1] = new int[3];//二维数组里的第二个一维数组长度为3
arr[2] = new int[1];//二维数组里的第三个一维数组长度为1
案例演示
public class ArrayDemo2 {
public static void main(String[] args) {
int[][] arr=new int[3][];
System.out.println(arr);//二维数组地址
System.out.println(arr[0]);//二维数组中第一个元素的值（初值null）
System.out.println(arr[1]);
System.out.println(arr[2]);
arr[0]=new int[3];
arr[1]=new int[5];
arr[2]=new int[4];
System.out.println(arr[0]);//动态赋值后第一个一维数组地址
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
内存解析:
这种格式，没有直接给出一维数组的元素个数，因此在创建二维数组时只会为二维数组开辟空间并初始化，不会为一维数组开辟空间和初始化。
注意事项：数组的长度不宜过长，否则会报堆内存不足的错误
public class Demo1 {
public static void main(String[] args) {
int[][] arr=new int[999999999][];
}
}
2.静态初始化
2.1 二维数组格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};
案例演示
public class ArrayDemo {
public static void main(String[] args) {
//二维数组静态初始化
int[][] arr=new int[][]{{2,4},{10,30},{10,30,40},{10,1}};
System.out.println(arr.length);
System.out.println(arr[3][1]);
//简写方式
int[][] arr2 ={{2, 4}, {10, 30}, {10, 30, 40}, {10, 1},{2,5}};
System.out.println(arr2.length);
System.out.println(arr2[2][2]);
}
}
（三）二维数组的遍历
案例演示
1.
public class ArrayDemo {
public static void main(String[] args) {
int[][] arr = {{2, 4}, {10, 30}, {10, 30, 40}, {10, 1}};
//二维数组的遍历
//外循环控制的是二维数组的长度，其实就是一维数组的个数。
//内循环控制的是一维数组的长度。
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
2.公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
public class ArrayDemo {
public static void main(String[] args) {
int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum=0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum+=arr[i][j];
}
}
System.out.println("公司年销售额为："+sum);
}
}
3.需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字");
int x = sc.nextInt();
int[][] a=new int[x][x];
for(int i=0;i<a.length;i++){//任何一行的第一列和最后一列都是1
a[i][0]=1;
a[i][i]=1;
}
//从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
for(int i=2;i<a.length;i++){
for(int j=1;j<i;j++){//第一列和最后一列已赋值
a[i][j]=a[i-1][j-1]+a[i-1][j];
}
}
//遍历二维数组 输出结果
for (int i = 0; i < a.length; i++) {
for(int j=0;j<=i;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
（四）思考题
看程序写结果，并画内存图解释
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a: " + a + ",b: " + b);
change(a,b);
System.out.println("a: " + a + ",b: " + b);
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]);
}
public static void change(int a,int b) {
System.out.println("a: " + a + ",b: " + b);
a = b;
b = a + b;
System.out.println("a: " + a + ",b: " + b);
}
public static void change(int[] arr){
for(int x = 0 ; x < arr.length ; x++){
if(arr[x]%2 == 0){
arr[x] *= 2;
}
}
}
答案
内存解析
首先main方法被调用进栈，然后定义了两个变量a和b并赋了值。当main方法调用change(int a,int b)方法时，此方法进栈，并执行其中代码，修改了两个变量的值，执行完以后便出栈了。返回主方法中继续执行代码，此时输出a和b的值时只能找到主方法中的a和b，因此a和b的值仍然不变。接着创建一个int型数组并赋值，在堆内存中开辟了空间并赋上各元素值，并将该空间的地址赋给数组的引用arr，于是arr便指向该空间的数组。当调用change(int[] arr)时，此方法进栈，并执行其中代码，修改了数组中两个元素的值，执行完以后方法弹栈，但堆内存中数据的改动仍然保留，返回主方法继续执行代码，找到arr指向地址的数组，找到索引为1的元素，输出。
基本数据类型，作为参数传递，形参的改变，不影响实参
引用数据类型，作为参数传递，形参的改变，会影响实参
（二）递归解决问题的思想
递归解决问题的思想即“拆分合并”
也就是将一个大问题拆分成一个个小问题，解决完小问题后再合并，便解决了大问题。
案例演示
1.求5的阶乘
方法1：利用循环
public class MyTest {
public static void main(String[] args) {
//问题求 5的阶乘 5！=5*4*3*2*1；
//循环做
int r=1;
for (int i = 1; i <= 5; i++) {
r*=i;
}
System.out.println("结果是"+r);
}
}
方法2：利用递归
public class MyTest {
public static void main(String[] args) {
//求 5的阶乘
//用递归来做
int r= jieCheng(5);
System.out.println("结果是"+r);
}
public static int jieCheng(int i) {
if(i==1){
return 1;
}else{
return i*jieCheng(i-1);
}
}
}
递归和循环的区别和联系
递归算法：
优点：代码简洁、清晰，并且容易验证正确性。
缺点：它的运行需要较多次数的方法调用，如果调用层数比较深，会对执行效率有一定影响。并且调用次数过多会出现栈内存溢出的现象。
循环算法：
优点：速度快，结构简单。
缺点：并不能解决所有的问题。
用循环能实现的，递归一般可以实现，但是能用递归实现的，循环不一定能。
2.兔子问题(斐波那契数列)
题目：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
分析：由此可见兔子对象每个月的对数分别是：1 , 1 , 2 , 3 , 5 , 8, 13 …
从中找到规律：前两个数都是1，从第三个数开始，这个数等于前两个数之和 （斐波那契数列）
方法1：
public class MyTest {
public static void main(String[] args) {
//采用数组方法来做，到第20个月有多少对兔子
int[] arr=new int[20];
arr[0]=1;
arr[1]=1;
for (int i =2; i < arr.length; i++) {
arr[i]=arr[i-1]+arr[i-2];
}
System.out.println("兔子的对数"+arr[19]);
}
}
方法2：递归
public class MyTest2 {
public static void main(String[] args) {
//递归来做
int sum = sumRabbit(20);
System.out.println("兔子的对数" + sum);
}
public static int sumRabbit(int i) {
if (i == 1 || i == 2) {
return 1;
} else {
return sumRabbit(i - 1) + sumRabbit(i - 2);
}
}
}
3763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
