day07总结

二维数组

二维数组的概述 格式

二维数组概述
	我们学校的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。
	这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
	由此可见：其实二维数组其实就是每一个元素为一维数组的数组。
二维数组格式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个元素
注意事项
	A:以下格式也可以表示二维数组
		a:数据类型 数组名[][] = new 数据类型[m][n];
		b:数据类型[] 数组名[] = new 数据类型[m][n];
		这两种格式不推荐使用
	B:注意下面定义的区别
		int x,y;
		int[] x,y[];	
		
		区别是:
		 int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
		  x=new int[3];	
  			  y=new int[3][];
  			  

二维数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ASIZ0qFk-1586619627924)(E:\新建文件夹\二维数组的内存图2.png)]

ublic class ArrayDemo4 {
    public static void main(String[] args) {
        //如果后面的第二个中括号，写上值，
        //这个值表示的是，二维数组中的一维数组长度，
        //你写上后，我们在创键二维数组时，也会初始化二维数组中放的一维数组，
        //如果不写，就不会去初始化一维数组，默认值为null。
        int[][] arr=new int[2][2];
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        arr[0][0]=10;
        arr[0][1]=20;
        arr[1][0]=100;
        arr[1][1]=200;

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);

    }
}

将一维数组存入二维数组

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[][] arr=new int[2][];  //null null
        //手动创建两个一维数组
        int[] minArr1=new int[3];
        System.out.println(minArr1);
        int[] minArr2 = new int[2];
        System.out.println(minArr2);
        minArr2[1]=300;

        //把上面的两个一维数组装到二维数组里面去

        arr[0]=minArr1;
        arr[1]=minArr2;

        System.out.println(arr[0]);
        System.out.println(arr[1]);

        arr[0][0]=100;
        arr[0][1]=200;

        System.out.println(minArr1[0]);
        System.out.println(arr[1][1]);
    }
}

二维数组的静态初始化及内存图

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
	简化版:
		数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
	这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
		举例: 
			int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
			int[][] arr = {{1,2,3},{5,6},{7}};
B:案例演示
	定义一个二维数组,打印每一个二维数组中的一维数组,在打印每一个二维数组中的元素
public class MyDemo {
    public static void main(String[] args) {
        //二维数组的静态初始化：由我们给元素赋值，有系统计算长度
        int[][] arr=new int[][]{{20,30},{1,3},{100,200,300}};
        System.out.println(arr.length);
        System.out.println(arr[2][2]);
        //数组中最后一个元素的索引=数组的长度-1
        System.out.println(arr[arr.length-1][arr[arr.length - 1].length-1]);

        //静态初始化的简写

        double[][] arr2={{2,30},{2.14,3.4},{1L,3.1F}};
        double[] minArr=arr2[0];
        System.out.println(minArr[0]);
    }
}    

二维数组的遍历

需求：二维数组遍历
	外循环控制的是二维数组的长度，其实就是一维数组的个数。
	内循环控制的是一维数组的长度。
public class MyTest {
    public static void main(String[] args) {
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    
      //二维数组的遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}
    

二维数组求和的两个案例

公司年销售额求和

需求：公司年销售额求和
	某公司按照季度和月份统计的数据如下：单位(万元)
	第一季度：22,66,44
	第二季度：77,33,88
	第三季度：25,45,65
	第四季度：11,66,99
public class MyTest2 {
    public static void main(String[] args) {
       /* A:
        案例演示
        需求：公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度： 22,66, 44
        第二季度：77, 33, 88
        第三季度：25, 45, 65
        第四季度：11, 66, 99*/

       //遍历二维数组元素求和
        //动态初始化
        int[][] arr = new int[4][3];
        arr[0]=new int[]{22, 66, 44};
        arr[1] = new int[]{77, 33, 88};
        arr[2]= new int[]{25, 45, 65};
        arr[3]=new int[]{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+"万元");
        System.out.println("===================================");
        int[][] arr2={{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
        int sum2 = 0;
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                sum2 += arr2[i][j];
            }
        }
        System.out.println("总计：" + sum2 + "万元");
    }
}    

打印杨辉三角

需求：打印杨辉三角形(行数可以键盘录入)

		1
		1 1	
		1 2 1
		1 3 3 1
		1 4 6 4 1 
		1 5 10 10 5 1

分析：看这种图像的规律
	A:任何一行的第一列和最后一列都是1
	B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

步骤：
	A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
	  这个n的数据来自于键盘录入。
	B:给这个二维数组任何一行的第一列和最后一列赋值为1
	C:按照规律给其他元素赋值
		从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
	D:遍历这个二维数组。
public class MyTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int n = sc.nextInt();
        //我们假定行数和列数都相等
        int[][] arr=new int[n][n];
        //1.每一行的首尾都是1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
        }
        //2. 从第三行开始，从第二列开始，中间的数字 = 他上一行的前一列和上一行的本列之和。
        for (int i =2; i < arr.length; i++) {
            for (int j =1; j <i; j++) {
                arr[i][j]=arr[i-1][j-1]+ arr[i - 1][j];
            }
        }
        //3.打印三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}        

java中的参数传递问题及内存图

ublic class MyTest {
    public static void main(String[] args) {
        //参数的传递问题
        //基本类型作为参数传递，属于值传递，会把这个变量的值传过去。----------------
        //引用类型作为参数传递，属于引用传递，传递的是地址值。-------------------
        //基本类型作为参数传递，形参的改变，不影响实参。----------------------------
        //引用类型作为参数传递，形参的改变，会影响实参-----------------------------
        //定义两个int边路
        int a = 10;
        int b = 20;
        //输出变量的值
        System.out.println("a: " + a + ",b: " + b); //1. 10  20
        //调用方法，把 a 和 b 传过去
        change(a, b);
        //输出变量的值
        System.out.println("a: " + a + ",b: " + b); //4.20 40 / 10 20
        //定义一个数组
        int[] arr =new int[]{1, 2, 3, 4, 5};
        //调用方法，把数组传过去
        System.out.println("传递的arr"+arr);
        change(arr);
        //输出数组中第二个元素的值
        System.out.println(arr[1]); //5. 4
    }

    public static void change(int a, int b) {

        System.out.println("a: " + a + ",b: " + b); //2.a 10 b 20
        a = b; //a 20
        b = a + b;
        System.out.println("a: " + a + ",b: " + b); //3.20 40
    }



    public static void change(int[] arr) {
        System.out.println("收到的arr:" + arr);
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] % 2 == 0) {
                arr[x] *= 2;
            }
        }
    }
}

递归

A:递归概述: 方法定义中调用方法本身的现象
B:递归注意事项
	要有出口，否则就是死递归，会造成栈溢出。（方法不断加载进栈执行）//StackOverflowErrow
	次数不能太多，否则就内存溢出
c:递归体现的是一种拆分，合并的思想  
案例，求5的阶乘：    

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2RDgOdIC-1586619627925)(E:\新建文件夹\递归的思想.png)]

public class MyTest3 {
    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);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gJK1ritl-1586619627926)(E:\新建文件夹\5的阶乘递归图.png)]

递归案例（斐波那契列数列）

需求：兔子问题(斐波那契数列)
	有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
	由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 .
    
public class MyTest2 {
    public static void main(String[] args) {
        //用递归来做一下不死神兔
        int sum=rabbit(20);
        System.out.println(sum);
    }
    private static int rabbit(int i) {
        if(i==1||i==2){
            return 1;
        }else{
            return rabbit(i-1)+rabbit(i-2);
        }
    }
}