数组与递归

数组
Java 语言中提供的数组是存储固定大小的同类型元素的集合。
数组既可以存储基本数据类型，也可以存储引用数据类型(后面讲解)。
1.一维数组
1.1数组格式：
格式1： 数据类型[] 数组名；
例：int[] arr
格式2： 数据类型 数组名[];
例：int arr[]
1.2数组的初始化
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组初始化分为动态初始化和静态初始化。
动态初始化: 只指定长度，由系统给出初始化值
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3};
数组操作的两个常见小问题越界和空指针
ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
数组遍历演示

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr={10,20,50,40,102};
        //数组的遍历
        //for(int i=0;i<arr.length;i++){
        //    System.out.println(arr[i]);
        //}
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------------------");
        //反向遍历
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }

    }
}

执行结果：

数组获取最值

public class ArrayDemo2 {
    public static void main(String[] args) {
        //获取数组中的最大值或最小值
        int[] arr = {10, 20, 50, 40, 102};
        int max = getMax(arr);
        System.out.println("最大值是" + max);

        int[] arr2 = {10, 20, 50, 40, 102,1000,1};
        int max1 = getMax(arr2);
        System.out.println("最大值是" + max1);
    }

    public static int getMax(int[] arr){

        //定义一个参照值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

执行结果：

数组的反转

public class ArrayDemo3 {
    public static void main(String[] args) {
      
        int[] arr = {10, 20, 30, 40, 50}; //50 40 30 20 10

        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }

    showArray(arr);


    }


    private static void reverseArray(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;

        }
    }

    private static void showArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }


}

执行结果：

2.二维数组
二维数组是每一个元素为一维数组的数组。
二维数组格式
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
int[][] arr = new int[3][2];
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}…};
注意事项
以下格式也可以表示二维数组：
数据类型 数组名[][] = new 数据类型[m][n];
数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
打印杨辉三角

public class ArrayDemo {
    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]; 
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1; 
            arr[i][i]=1; 
        }

       
        for (int i =2; i < arr.length; i++) {
            for (int j =1; j <= i-1; j++) {
             arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }

        }

    

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

    }
}

执行结果：

递归算法
递归算法就是直接或间接调用自己的算法。
递归注意事项：
要有出口，否则就是死递归。
次数不能太多，否则就内存溢出。
案例演示: 需求：兔子问题(斐波那契数列)
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 …

public class MyTest2 {
    public static void main(String[] args) {
       int sum = sumRabbit(20);
       System.out.println("兔子的对数" + sum);
    }

    private static int sumRabbit(int i) {
        if (i == 1 || i == 2) {
            return 1;
        } else {
            return sumRabbit(i - 1) + sumRabbit(i - 2);
        }

    }
}