Java中一维数组、二维数组、递归及数组在堆栈中存放详解

一、一维数组

1. 一维数组概念及定义格式

• 为什么要有数组
  数组可以存储同一类型的多个变量，当我们在存储诸如一个单位的工资、一个班级的成绩这种问题时，如果给每一个人都声明一个变量会显得很麻烦，这个时候就可以用数组来存储这些信息
• 数组的概念
  可以将数组看作是一个容器，数组是存储同一种数据类型的多个元素的集合，存储的元素既可以是基本数据类型，也可以是引用数据类型（二维数组就是）
• 一维数组定义格式
  • 格式一：数据类型[] 数组名
  • 格式二：数据类型 数组名[]
  • 格式一与格式二都是定义一个一维数组，效果一样，但是常用第一个

2. 一维数组的初始化

1）动态初始化

• 什么是初始化
  刚才我们定义了一个一维数组，需要进行初始化之后才能使用，初始化就是在堆区中为数组开辟一块内存空间，并为数组的每一个元素赋值（可以自己手动赋值，如果没有，系统会赋默认值）
• 初始化分类
  • 静态初始化
  • 动态初始化
  • 注：两种只能选其一，不能同时使用
• 动态初始化格式
  • 数据类型[] 数组名 = new 数据类型[数组长度];
  • 举例：int[] array = new int[3];// 定义了一个int型的一维数组array，这个数组的长度是3，可以存放3个int型变量

2）静态初始化

• 静态初始化格式
  • 数据类型[] 数组名 = new 数据类型[]{数组元素1,数组元素2,……}
  • 举例：int[] array = new int[]{1,2,3};
    //定义了一个int型的一维数组array，里面存放了1,2,3三个元素
  • 简化格式
    数据类型[] 数组名 = {数组元素1,数组元素2,……}

3. Java中内存分配及堆栈的区别

• 栈内存：存放局部变量
  在方法中或方法声明上的变量（参数）都是局部变量
  • 特点：没有初始值，必须赋值才能使用
• 堆内存：存放所有new(引用)的东西
  • 特点
    • 每一个new出来的东西都会为其分配一个地址值，使用地址值(数组名)来使用
    • 使用完毕就会被垃圾回收器回收
    • 系统会默认给初始值

类型	值
整数型	0
浮点型	0.0
char	‘\u0000’
boolean	false
引用类型	null

• 方法区：类的加载
• 本地方法区：和系统相关
• 寄存器：cpu使用

4. 数组操作中常见问题

• 数组越界：访问了不存在的索引（数组元素的下标，代表该元素在数组中的位置）
• 空指针异常：数组名已经不指向堆内存了，还用数组名去访问。

5. 一维数组内存图解

6. 一维数组练习

• 一维数组遍历

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

• 一维数组最值

  public static void main(String[] args) {
      int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
      int max = arr[0];
      int min = arr[0];
      for (int i = 0; i < 9; i++) {
          max = max > arr[i] ? max : arr[i];
          min = min < arr[i] ? min : arr[i];
      }
      System.out.println("最大值是：" + max + "，最小值是：" + min);
  }
  

• 一维数组反转

  public static void main(String[] args) {
      int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};//定义数组arr
      for (int i = 0; i < 9 / 2; i++) {//利用for循环对数组首末元素调换，以达到反转
          int mid = arr[i];
          arr[i] = arr[arr.length - i - 1];
          arr[arr.length - i - 1] = mid;//首末元素互换
      }
      for (int i = 0; i < 9; i++) {//对数组遍历输出
          System.out.print(arr[i] + "\t");
      }
  }
  

• 查表：根据键盘录入索引,查找对应星期

  public static void main(String[] args) {
      int input = input();//调用此方法得到用户输入的索引
      if (input >= 1 && input <= 7) {
          lookUp(input);//当用户输入索引合法时，调用此方法输出对应的星期
      } else
          System.out.println("你输入的索引有误！！");
  }
  
  //此方法用来接收用户键盘输入的一个整数并返回
  private static int input() {
      Scanner in = new Scanner(System.in);
      System.out.println("请输入索引：1-----7");
      int input = in.nextInt();
      return input;
  }
  
  //此方法用来判断传入的索引对应的是星期几
  private static void lookUp(int input) {
      String[] str = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
      for (int i = 0; i < str.length; i++) {
          if ((input - 1) == i) {//当用户输入的索引减一等于i时，输出i所对应数组中的元素
              System.out.println(str[i]);
              break;
          }
      }
  }
  

二、二维数组

1. 二维数组概述及格式

• 概述
  对于一个班的单科成绩我们可以用一个一维数组来存放，那对于所有的科目呢，又该如何去存放，为每一个科目新建一个一维数组还是有点麻烦，这里我们引入二维数组进行存放。
• 思想
  在刚才的一维数组里面我们存放的是一个个具体的数值，比如1,2,3……，也就是说一维数组里存放的是具体的值，那二维数组呢，其实二维数组可以理解为一个特殊的一维数组，这个一维数组里面存放的元素是一个数组而不是具体的值。可以表示为：数据类型[][] 变量名 = {一维数组1,一维数组2,一维数组3……}
• 格式
  • 数据类型[][] 数组名 = new 数据类型[m][n];
  • m表示这个二维数组里面有几个一维数组（维数），必须写上
  • n表示每一个一维数组有几个元素，可写可不写
• 举例
  • int[][] arr = new int[2][3];
  • 定义了一个二维数组arr，这个二维数组有两个元素（一维数组）arr[0]、arr[1]，每个一维数组有3个元素，比如arr[0]中有arr[0][0]、arr[0][1]、arr[0][2]三个元素
• 注意：一下格式也可以表示一维数组，但不常用
  • 数据类型 数组名[][] = new 数据类型[m][n];
  • 数据类型[] 数组名[] = new 数据类型[m][n];

2. 二维数组内存图解

• 直接定义二维数组的元素长度
  
• 使用一维数组给二维数组元素赋值
  

3. 二维数组练习

• 二维数组求和

    ```
    public static void main(String[] args) {
        int[][] num = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
        int sum = 0;
        for (int i = 0; i < num.length; i++) {//外层遍历二维数组的每一个元素
            for (int j = 0; j < num[i].length; j++) {//内层遍历一维数组的每一个元素
                sum += num[i][j];//累加
            }
        }
        System.out.println("数组和是：" + sum);
    }
    
    ```
  

  • 打印杨辉三角，由键盘输入行数

  public static void main(String[] args) {
      int input = input();//得到用户指定的行数
      int[][] triangle = tri(input);//得到指定行数的杨辉三角数，存在二维数组triangle中
      output(triangle);//遍历输出二维数组
  }
  
  //此方法用来得到用户指定行数的杨辉三角数，并存在二维数组中
  private static int[][] tri(int input) {
      int[][] triangle = new int[input][input];//定义用户指定长度的二维数组
      for (int i = 0; i < triangle.length; i++) {//对三角形两边的值赋1
          triangle[i][0] = 1;
          triangle[i][i] = 1;
      }
      for (int i = 2; i < triangle.length; i++) {
          for (int j = 1; j < i; j++) {//对每一行中间值赋值，等于上一行前一列元素与本列元素之和
              triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
          }
      }
      return triangle;//返回该二维数组
  }
  
  //此方法得到并返回用户从键盘输入的整数
  private static int input() {
      Scanner in = new Scanner(System.in);
      System.out.println("请输入杨辉三角的行数：");
      int input = in.nextInt();
      return input;
  }
  
  //此方法遍历输出二维数组（只输出下三角）
  private static void output(int[][] triangle) {
      for (int i = 0; i < triangle.length; i++) {//遍历二维数组元素
          for (int j = 0; j <= i; j++) {//遍历一维数组元素
              System.out.print(triangle[i][j] + "\t");
          }
          System.out.println();
      }
  
  }
  
  

三、递归

1. 递归概述

• 递归就是在方法中调用方法本身的现象
• 注意事项
  • 要有结束的条件，即出口，不然就是死递归
  • 次数不能太多，因为方法要加载进栈，递归次数过多会造成栈溢出

2. 递归思想图解

• 斐波那契数列：1,1,2,3,5,8,13,21,34……
• 可以发现，从第三个数开始，后两个数等于前两个数之和
• 图解
  

3.递归练习

• 打印斐波那契数列第20个数

  public static void main(String[] args) {
      System.out.println(recursive(20));//调用recursive方法求第20个斐波那契数列数
  }
  
  public static int recursive(int n) {
      if (n == 1 || n == 2) {//这个if语句是递归调用终止的条件，当调用到recursive(1)recursive(2)时
          return 1;          //就不再递归调用，给recursive(1)recursive(2)返回一个值1，递归调用结束
      }
      return recursive(n - 1) + recursive(n - 2);//从20往下调用 20=19+18  (19=18+17  18=17+16)
      //一直调用下去，直到调用到1和2为止
  }
  

• 递归调用时一定要注意程序的出口，不然就会形成死递归