数组和递归

一、一维数组

什么是数组？

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

1. 数组定义的格式

   格式1： 数据类型[] 数组名； 格式2： 数据类型 数组名[];

   例如：

    int[] a；    定义了一个int类型的数组a；推荐使用这种方式进行定义
    int a[];    定义了一个int类型的a数组；

2. 数组的初始化

   在Java中，定义的数组必须初始化才能使用。初始化就是为数组中的数组元素分配内存空间，并且为每个元素赋初值。Java中的初始化分为两种，但是这两种方式只能使用一种，不能混合使用。

   1. 动态初始化：只指定数组的长度，由系统给出初始化值；

      格式：数据类型[] 数组名 = new 数据类型[数组长度];

      例如：int[] arr = new int[3];定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

   2. 静态初始化：给出初始值，由系统决定长度。

      格式：数据类型[] 数组名={数组元素};

      例如：int[] arr={1,2,3,4};定义了一个int类型的数组arr，这个数组可以存放4个int类型的值。

3. 越界和空指针

   1. 数组索引越界异常：ArrayIndexOutOfBoundsException，原因是访问了不存在的索引。

      例如：

      

   2. 空指针异常：NullPointerException，原因是数组已经不再指向堆内存时访问了数组。

4. 一维数组常见操作的方法

   1. 数组遍历

       public static void main(String[] args) {
           int[] arr={1,2,3};
           for (int i = 0; i < arr.length ; i++) {
                   System.out.println(arr[i]);
               }
           }

   2. 获取最大值

           public static int getMaxValue(int[] arr){
               int max=arr[0];
               for (int i = 0; i < arr.length; i++) {
                   if(arr[i]>max){
                       max=arr[i];
                   }
               }
               return max;
           }

   3. 获取最小值

           public static int getMinValue(int[] arr){
               int min=arr[0];
               for (int i = 0; i < arr.length; i++) {
                   if(arr[i]<min){
                       min=arr[i];
                   }
               }
               return min;
           }

   4. 数组元素翻转

           public static void arrInversion(int[] arr){
               for (int i = 0; i < arr.length/2; i++) {
                   int t=arr[i];
                   arr[i]=arr[arr.length-1-i];
                   arr[arr.length-1-i]=t;
               }
           }

   5. 数组查表法（键盘输入索引，打印对应元素）

          public static void printArrForIndex(int[] arr){
              Scanner sc=new Scanner(System.in);
              int a=sc.nextInt();
              System.out.println(arr[a]);
          }

   6. 根据输入的元素，查找第一次出现的索引

           public static int getFirstIndex(int[] arr,int a){
               for (int i = 0; i < arr.length; i++) {
                   if(arr[i]==a){
                       return i;
                   }
               }
               return -1;
           }

二、二维数组

什么是二维数组？

二维数组其实就是每个元素都为一个一维数组的数组。

1. 二维数组的定义格式

    数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组有多少个一维数组 必须写上
    n表示每一个一维数组的元素个数 可选

   其他定义格式

    数据类型 数组名[][]=new 数据类型[m][n];
    数据类型[] 数组名[]=new 数据类型[m][n];

2. 二维数组的遍历

   方法：两层循环，外层循环表示二维数组中一维数组的个数，内层循环表示一维数组的长度。实现代码：

    public class Test3 {
        public static void main(String[] args) {
            int[][] arr={{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}};//m=5,n=3
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(arr[i][j]+"\t");
                }
            }
        }
    }

1. 案例

   1. 二维数组遍历求和

       public class Test3 {
           public static void main(String[] args) {
               int sum = 0;
               int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
               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:" + sum);
           }
       }

   2. 打印杨辉三角（左下三角）

       import java.util.Scanner;
       ​
       public class Test8{     //打印杨辉三角
           public static void main(String[] args) {
               Scanner sc=new Scanner(System.in);
               System.out.println("Input lines please:");
               int n=sc.nextInt();
               getTriangle(n);
           }
       ​
           public static void getTriangle(int n){
               int[][] arr=new int[n][n];
               for (int i = 0; i < n; i++) {
                   for (int j = 0; j < n; j++) {
                       arr[i][0]=1;
                       if(i==j){
                           arr[i][j]=1;
                       }
                   }
               }
               for (int i = 2; i < n; i++) {
                   for (int j = 1; j <= i; j++) {
                       arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                   }
               }
               printArr(arr,n);
           }
           
           public static void printArr(int[][] arr,int n){
               for (int i = 0; i < n; i++) {
                   for (int j = 0; j <= i; j++) {
                       System.out.print(arr[i][j]+"\t");
                   }
                   System.out.println();
               }
           }
       }

三、Java中的递归

1. 什么是递归？

   在Java的方法定义中，方法调用方法本身的现象叫做递归。

2. 递归的注意事项

   递归要有出口，否则就是死递归；次数不能太多；这些情况都会造成栈内存溢出。

3. 递归的应用案例

   兔子问题（斐波那切数列）

   有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

   分析可知，兔子随月份变化的数列是1，1,2,3,5,8......

   代码实现：(求斐波那切数列指定位置的数据)

    import java.util.Scanner;
    ​
    public class Test6 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int a = sc.nextInt();
            System.out.println(fibonacci(a));
        }
    ​
        public static int fibonacci(int a) {
            if (a == 1 || a == 2) {
                return 1;
            } else {
                return fibonacci(a - 1) + fibonacci(a - 2);
            }
        }
    }