JavaSE——Day5——数组、二维数组、遍历、递归

数组

概念

数组是存储多个变量（元素）的东西（容器），这多个变量的数据类型要一致。
在实际的开发过程中，我们经常会面对同时处理大量的数据，如果同时声明这么多的变量显然不现实，Java给我们提供了数组来解决这个问题。

数组是存储同一种数据类型多个元素的集合。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义语法

语法一： 数据类型 [ ] 数组名；
语法二： 数据类型 数组名 [ ]

数组的初始化

Java中的数组必须先开始初始化，然后才能使用。
所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

初始化的分类

动态初始化：只指定长度，由系统给出初始化值
静态初始化：给出初始化值，由系统决定长度

两种方式只能二选一，不能动静结合。

初始化的语法

动态初始化： 数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ] ;
静态初始化： 数据类型 [ ] 数组名 = { 元素1,元素2,元素3…… } ;

数组长度就是数组中元素的个数。

举例：
int [] arr1 = new int [3] ;
即定义了一个名叫arr1的int类型的新数组，这个数组中有3个元素。

int [] arr2 = {1,2,3} ;
即定义了一个名叫arr2的int类型的新数组，这个数组中的元素是：1,2,3

Java中的内存分配以及栈和堆的区别

栈：存放的是局部变量(在方法定义中或者方法声明中的变量)
堆：存放的是所有new出来的东西

堆的特点：
1、每一个new出来的东西都会为其分配一个地址值
2、每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
3、使用完后就变成了垃圾，等待垃圾回收器对其回收

数组部分常见的小问题

1、ArrayIndexOutOfBoundsException——数组索引越界异常
原因：访问了不存在的索引
2、NullPointerException——空指针异常
原因：数组已经不再指向堆内存了，还用数组名去访问元素。

数组的基本操作——遍历

public class MyArray{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9,10};
		//arr.length就是数组中的元素个数
		for(int i = 0 ; i < arr.length ; i++){
			System.out.println(arr[i]);
		}
	}
}

数组的基本操作——获取最值

public class MyArray2{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9,10};
		//假设第一个数最大,注意数组中的第一个数的地址是0而不是1
		int max = arr[0];
		//记录最大值的地址
		int maxIndex = 0;
		//arr.length就是数组中的元素个数,从第二个数开始找
		for(int i = 1 ; i < arr.length ; i++){
			//如果第一个数后面的数比它大，就把这个数的值赋给max
			if(arr[i] > max){
			max = arr[i];
			maxIndex = i;
			}
		System.out.println("最大值是："+"max");
		System.out.println("它是数组中第"+(maxIndex+1)+"个数");
	}
}

数组的基本操作——反转（元素对调）

public class MyArray3{
	public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //输出变化前的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //把整个数组分为前后两部分，一一对调。
        for (int i = 0; i < arr.length / 2; i++) {
            //定义temp变量来记录值
            int temp = arr[i];
            //arr.length - i - 1 是对调目标的地址，如果我们i值从1开始，就不必再减1
            arr[i] = arr[arr.length - i - 1];
            //完成对调
            arr[arr.length - i - 1] = temp;
        }
        //输出变化后的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

关键部分的另外一种写法：

        //首尾元素交换
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

数组的基本操作——查表法

import java.util.*;
public class MyArray4 {
    public static void main(String[] args) {
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        System.out.println("请输入一个整数0-6");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        String b = getIndex(week, a);
        System.out.println("你要查找的是：" + b);
    }
	//创建一个私有的方法来查找
    private static String getIndex(String[] arr, int index) {
        if (index >= 0 && index <= 6) {
            String s = arr[index];
            return s;
        } else {
            return ("指令错误");
        }
    }
}

二维数组

语法

数据类型[][] 变量名 = 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:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用

注意下面定义的区别
int x,y;
int[] x,y[];
区别是:
int[] x,y[]; //定义了两个数组 一个是一维数组x 一个是二维数组y

public class MyArray5 {
    public static void main(String[] args) {
        //一位数组表示班级，二维数组表示学生，三个班，每个班两个人
        String[][] school = new String[3][2];
        school[0] = new String[]{"张小凡","陆雪琪"};
        school[1] = new String[]{"哈利波特","伏地魔"};
        school[2] = new String[]{"马云","马化腾"};
        System.out.println(school[0][0]);
        System.out.println(school[0][1]);
        System.out.println(school[1][0]);
        System.out.println(school[1][1]);
        System.out.println(school[2][0]);
        System.out.println(school[2][1]);
    }
}

另外一种格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度

String[][] school = {{"张小凡","陆雪琪"},{"哈利波特","伏地魔"},{"马云","马化腾"},};

二维数组的遍历

外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。

public class MyArray6 {
    public static void main(String[] args) {
        String[][] school = new String[3][2];
        school[0] = new String[]{"张小凡", "陆雪琪"};
        school[1] = new String[]{"哈利波特", "伏地魔"};
        school[2] = new String[]{"马云", "马化腾"};

        //遍历,school.length是一维数组的个数，school[i].length是每层一维数组中的元素个数
        for (int i = 0; i < school.length; i++) {
            for (int j = 0; j < school[i].length; j++) {
                System.out.println(school[i][j]);
            }
        }

    }
}

二维数组练习——求和

案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

public class MyArray5 {
    public static void main(String[] args) {
        int[][] turnover = {{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
        int totalMoney = 0;
        for (int i = 0; i < turnover.length; i++) {
            for (int j = 0; j < turnover[i].length; j++) {
                totalMoney = totalMoney + turnover[i][j];
            }
        }
        System.out.println("年销售总额为"+totalMoney);
    }
}

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

		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由键盘录入，列数待定。
	B:给这个二维数组任何一行的第一列和最后一列赋值为1
	C:按照规律给其他元素赋值：从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
	D:输出

public class YangHuiTriangle {
    public static void main(String[] args) {
        //键盘录入行数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个正整数代表你想要打印多少行的杨辉三角：");
        int n = scanner.nextInt();
        //创建一个二维数组，行数由控制台输入给定，列数待定
        int[][] arr = new int[n][];
        //开始赋值，外层循环表示行数
        for (int i = 0; i < n; i++) {
            //arr[i]表示二维数组arr中的第i+1层一维数组，即杨辉三角的行数；
            //例：arr[0]就是第1层一维数组……；
            //new int [i+1] 表示第i+1层一维数组有i+1元素，即杨辉三角每行的列数；
            //例：arr[0] = new int [0+1]，表示第1层一维数组中有1个元素；
            //我们观察图形发现第一行有一个元素，第二行有两个元素……故用这种方法完成二维数组的定义。
            arr[i] = new int[i + 1];
            //每行的第一个元素和最后一个元素为1
            arr[i][0] = arr[i][i] = 1;
            //内层循环表示列数
            for (int j = 0; j < i + 1; j++) {
                //从第三行开始，即i>1,每一个数据是它上一行的前一列和它上一行的本列之和。
                if (i > 1 && (j > 0 && j < i)) {
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                }
                //输出这一行的元素
                System.out.print(arr[i][j]);
            }
            //换行
            System.out.println();
        }
    }
}

递归

方法定义中调用方法本身的现象

递归的注意事项：要有出口，否则变成死龟 (0_0)’ ……
次数不能太多，否则就内存溢出。

案例：求5的阶乘

public class Factorial {
    public static void main(String[] args) {
        MyFactorial myFactorial = new MyFactorial();
        int goCal = myFactorial.GoCal(5);
        System.out.println(goCal);
    }
}

class MyFactorial {
    public int GoCal(int i) {
        if (i == 1) {
            return 1;
        } else {
            return i * GoCal(--i);
        }
    }
}

案例：不死神兔问题（斐波那契数列）

A:案例演示: 需求：兔子问题(斐波那契数列)
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 …

使用递归一层一层的调，再一层一层的返回

public class MyFibonacciList {
    public static void main(String[] args) {
        int rabbit = Rabbit(20);
        System.out.println(rabbit);
    }
    // 1 1 2 3 5 8 13 21 斐波那契数列 从第三个数开始，每个数等于他前两个数之和
    //这个递归的出口在月数等于1或者月数等于2，我们不断地调法方法，方法不断的返回前两个数的和
    private static int Rabbit(int months){
        if( months==1 || months==2 ){
            return 1;
        }else{
            return Rabbit(months-1)+Rabbit(months-2);
        }
    }
}

这个问题其实使用数组也能做：

public class Rabbit{
	public static void main(String[] args){
		int[] arr = new int[20];
		arr[0] = 1;
		arr[1] = 2;
		for(int i = 2; i < arr.length; i++){
			arr[i] = arr[i-1] + arr[i-2];
		}
		system.out.println(arr[20]);
	}
}