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

数组

• 概念

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

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

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

• 数组的初始化

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

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

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

- 初始化的语法

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

数组长度就是数组中元素的个数，但是角标是从0开始。

举例：
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——空指针异常
原因：数组已经不再指向堆内存了，还用数组名去访问元素。

eg： 遍历（把数组中每个元素打印出来）

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]);
		}
	}
}

eg： 获取最大值

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)+"个数");
	}
}

eg： 反 转（元素对调）

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]);
        }
    }
}

二维数组

• 语法

数据类型[ ][ ] 变量名 = 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
int[] x,y[]; //定义了两个数组 一个是一维数组x 一个是二维数组y

静态初始化：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

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

eg： 求和

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

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

eg： 打印杨辉三角形(行数可以键盘录入)
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();
        }
    }
}

递归

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

注意事项：

1. 要有出口，否则变成死龟 ！！！
2. 次数不能太多，否则就内存溢出。

eg： 求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);
        }
    }
}

eg： 不死神兔问题（斐波那契数列）
有一对兔子，从出生后第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，我们不断地调法方法，方法不断的返回前两个数的和
    public static int Rabbit(int months){
        if( months==1 || months==2 ){
            return 1;
        }else{
            return Rabbit(months-1)+Rabbit(months-2);
        }
    }
}