[Java语言基础]一维数组、二维数组、递归

老正又来啦~

数组

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

学习数组之前，我们首先得了解一下内存的分配:

栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
堆: 存放的是所有new出来的东西
特点：
 a: 每一个new出来的东西都会为其分配一个地制值。
 b: 每一个变量都有一个默认的值
  byte，short，int，long  -- 0
  float，double          -- 0.0
  char           -- '\u0000'
  boolean     -- false
  引用数据类型  -- null  
 c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
方法区(静态区)
本地方法区:(和系统相关)
寄存器:(cpu使用)

一维数组

 格式1： 数据类型[] 数组名；
 格式2： 数据类型   数组名[];
举例：
int[] a;  定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
推荐使用第一种定义方式。

数组的初始化:

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

一个数组的内存图解：

两个数组的内存图解：

动态初始化和静态初始化的例子：

public class MyTest2 {
    public static void main(String[] args) {
        //动态初始化
        double[] arr = new double[5];
        System.out.println(arr[0]);
        boolean[] booleans = new boolean[2];
        System.out.println(booleans[0]);
        char[] chars = new char[2];
        System.out.println("bbbb"+(chars[0])+"aaaa");
       //静态初始化：由我们给元素赋值，由系统计算长度
       int[] arr2=new int[]{20,10,30,40};
       arr2[0]=100;
        System.out.println(arr2[0]);
        //数组的静态初始化的简写方式
        int[] arr3={200,300,400};
        System.out.println(arr3[0]);
      }
  }

一维数组的遍历：

public class MyTest {
    public static void main(String[] args) {
        //遍历数组中的元素
        int[] arr={10,20,30,40,50,60};
         showArray(arr);
       }
         public static void showArray(int[] arr){
        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个元素
 举例：
  int[][] arr = new int[3][];
  arr[0] = new int[2];
  arr[1] = new int[3];
  arr[2] = new int[1];
  没有直接给出一维数组的元素个数，可以动态的给出。没写n就是系统不会自动初始化一维数组的元素

---

其他格式：
  a:数据类型 数组名[][] = new 数据类型[m][n];
  b:数据类型[] 数组名[] = new 数据类型[m][n];
  这两种格式不推荐使用

注意：
我们定义两个变量时可以这么来定义：int x,y;
那么定义数组时可以这样吗？ int[] x,y[];

区别是:
int[] x,y[];//定义了两个数组 一个是一维数组x ，一个是二维数组y

静态初始化：

格式:
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
 简化版:
  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  举例: 
   int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
   int[][] arr = {{1,2,3},{5,6},{7}};

两种动态初始化的二维数组的内存图解：

二维数组的初始化：

public class ArryDemo2 {
    public static void main(String[] args) {
        //定义二维数组
        int[][] arr2 = new int[3][2];//动态初始化n给出的
        System.out.println(arr2);
        System.out.println(arr2[0]);

	int[][] arr3 = new int[2][];//动态初始化n没给的
        System.out.println(arr3);
        System.out.println(arr3[0]);

	int[][] arr1 =new int[][]{{12,3},{56},{2,45,89}};//静态初始化
	int[][] arr ={{12,3},{56},{2,45,89}};//简化写法
	}
      }

二维数组的遍历

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{10, 20, 30}, {5, 6}, {6, 8}};
        //二维数组的遍历
        //外循环控制的是二维数组的长度，其实就是一维数组的个数。
        //内循环控制的是一维数组的长度。
        for (int i = 0; i < arr.length;i++){
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }

打印杨辉三角：

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        /*
        需求：打印杨辉三角形(行数可以键盘录入)
        1
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1
        */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数");
        int n = scanner.nextInt();
        //构建二维数组
        int[][] arr = new int[n][n]; //
        //1.把第一元素和最后一个元素置为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
        }
        //2.算出中间元素
        //从第三行开始，从第二列开始，中间的数等于上一行的前一列和本列之和
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j <= i; j++) {
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }
        //3，打印出三角形
        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个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

public class MyTest2 {
    public static void main(String[] args) {
        //  这组数据 斐波那契数列：1 1 2 3 5 8 13 21 从第三个数开始，后面的每个数 等于他前两个数之和
        int sum = rabbit(20);
        System.out.println(sum);
    }
    private static int rabbit(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return rabbit(n - 1) + rabbit(n - 2);
        }
    }
}

再见-_-||