5、Java语言基础（数组、递归）

满眼星陈ya

于 2021-11-01 15:50:52 发布

阅读量222

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_62520622/article/details/121016116

版权

1、数组概述和定义格式说明

数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致

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

数组定义格式
   格式1：数据类型[] 数组名；
   格式2：数据类型数组名[];
举例：
   int[] a；    定义了一个int类型的数组a；
   int a[];   定义了一个int类型的a数组；

2、数组的初始化动态初始化

A:什么是数组的初始化
   Java中的数组必须先初始化,然后才能使用。
   所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
B:初始化的分类：
   a:动态初始化:   只指定长度，由系统给出初始化值
   b:静态初始化:   给出初始化值，由系统决定长度
   注意事项：这两种方式，只能使用一种，不能进行动静结合
C:动态初始化的格式：
   数据类型[] 数组名 = new 数据类型[数组长度];
   数组长度其实就是数组中元素的个数。
   举例： int[] arr = new int[3];   定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

        int[] arr = new int[3];
        double[] arr2 = new double[4];

Java中的内存分配以及栈和堆的区别

Java虚拟机在执行Java程序的过程中会把它管理的内存划分成若干个不同的数据区域

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

Java虚拟机在执行Java程序的过程中会将其管理的内存划分为若干个不同的数据区域，这些区域有各自
的用途、创建和销毁的时间，有些区域随虚拟机进程的启动而存在，有些区域则是依赖用户线程的启动和
结束来建立和销毁。Java虚拟机所管理的内存包括以下几个运行时数据区域，如图：

3、数组的内存图解1一个数组

4、数组的内存图解2二个数组

5、数组的内存图解3三个引用2个数组

定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
最后，再次输出第一个数组数组名称和元素。

6、数组的初始化静态初始化及内存图

静态初始化的格式：
   格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
       举例： int[] arr = new int[]{1,2,3};
   简化格式：
       数据类型[] 数组名 = {元素1,元素2,…};
       举例： int[] arr = {1,2,3};

length

数组中有一个length属性，可以动态获取数组长度

数组最后一个元素的索引=数组长度-1

7、数组操作的两个常见小问题越界和空指针

    a:ArrayIndexOutOfBoundsException:数组索引越界异常
       原因：你访问了不存在的索引。
   b:NullPointerException:空指针异常
       原因：数组已经不在指向堆内存了。而你还用数组名去访问元素

8、数组的操作1遍历

数组遍历：就是依次输出数组中的每一个元素(正向遍历，反向遍历)

9、数组的操作2获取最值

数组获取最值(获取数组中的最大值或者最小值)

public class Mytest1 {
    public static void main(String[] args) {
        int[] arr=new int[]{10,23,45,745,34,34,55,65,6,56};
        int max = getMax(arr);
        System.out.println("最大值是：" + max);

        int[] arr2=new int[]{21,334,6,45,8,5,4,3346,24};
        int min = getMin(arr2);
        System.out.println("最小值是：" + min);

    }

    private static int getMin(int[] arr2) {
        int min=arr2[0];
        for (int i = arr2.length-1; i >= 0; i--) {
            if(arr2[i]<min){
                min=arr2[i];
            }
        }
        return min;
    }

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

10、数组的操作3反转

数组元素反转(就是把元素对调)

public class Mytest2 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,2,3,4,5,6};
        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;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

11、数组的操作4查表法

数组查表法(根据键盘录入索引,查找对应星期)

public class MyTest {
    public static void main(String[] args) {
        // 案例演示:    数组查表法(根据键盘录入索引,查找对应星期) 根据索引找元素
        //定义字符串数组
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入索引 0--6");
        int index = sc.nextInt();

        String yuansu = getEle(index, week);

        System.out.println(yuansu);


    }

    public static String getEle(int suoyin, String[] arr) {
        if (suoyin >= 0 && suoyin <= 6) {
            String ele = arr[suoyin];
            return ele;
        } else {
            return "你查找的元素不存在，请检查你的索引是否输入正确";
        }
    }
}

输入星期查索引

public class MyTest2 {
    public static void main(String[] args) {
        //定义字符串数组
        //根据元素查索引
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期");
        // nextLine();录入的是字符串
        String s = sc.nextLine();
        int index = getIndexByEle(s, week);

        System.out.println("该元素的索引是：" + index);

    }


    public static int getIndexByEle(String ele, String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //判断两个字符串，字面上的内容是否一样，不要用 == 号 ，用 equals()方法来判断
            if (arr[i].equals(ele)) {  //星期一 == 星期一  判断字面上内容是否相同，判别不出来，要调用 equals()方法来判断
                return i;
            }
        }

        return -1; //-1 约定俗成 -1 表示没找到
    }
}

12、二维数组概述和格式1

二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组

二维数组格式1
   数据类型[][] 变量名 = 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:以下格式也可以表示二维数组
       a:数据类型数组名[][] = new 数据类型[m][n];
       b:数据类型[] 数组名[] = new 数据类型[m][n];
       这两种格式不推荐使用
   B:注意下面定义的区别
       int x,y;
       int[] x,y[];

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


public class MyTest2 {
    public static void main(String[] args) {

        int[][] arr = new int[2][3];
        System.out.println(arr[0]); //取的是二维数组中的第一个一维数组
        System.out.println(arr[1]); //取的是二维数组中的第二个一维数组

        arr[0][0] = 20;
        arr[0][1] = 30;
        arr[0][2] = 40;
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);

        arr[1][0] = 90;
        arr[1][1] = 100;
        arr[1][2] = 600;
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);

        //引用数据类型：数组，类，接口，都属于引用数据类型， 简单些，需要new的都属于引用数据类型。
    }
}

二维数组格式1的内存图解

13、二维数组格式2及其内存图解

二维数组格式2
   数据类型[][] 变量名 = new 数据类型[m][];
       m表示这个二维数组有多少个一维数组
       这一次没有直接给出一维数组的元素个数，可以动态的给出。
   举例：
       int[][] arr = new int[3][];
       arr[0] = new int[2];
       arr[1] = new int[3];
       arr[2] = new int[1];

public class Mytest {
    public static void main(String[] args) {
        int[][] arr=new int[2][];
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        int[] aa=new int[2];
        aa[0]=10;
        aa[1]=11;
        arr[0]=aa;

        int[] bb=new int[2];
        bb[0]=20;
        bb[1]=30;
        arr[1]=bb;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
    }
}

14、二维数组格式3的讲解及其内存图解

二维数组格式3
       数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
   简化版:
       数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
   这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
       举例:
           int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
           int[][] arr = {{1,2,3},{5,6},{7}};

15、二维数组练习1遍历

需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度

public class Mytest1 {
    public static void main(String[] args) {
        int[][] arr=new int[][]{{10,20},{30,40,50},{60,70,80}};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

16、二维数组练习2求和

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

public class Mytest2 {
    public static void main(String[] args) {
        int[][] arr = new int[4][3];

        arr[0] = new int[]{22, 66, 44};
        arr[1] = new int[]{77, 33, 88};
        arr[2] = new int[]{25, 45, 65};
        arr[3] = new int[]{11, 66, 99};

        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum = sum + arr[i][j];
            }
        }

        System.out.println("总销售额" + sum + "万元");
    }
}

需求：打印杨辉三角形(行数可以键盘录入)

       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，我们把列数也先定义为n。
   这个n的数据来自于键盘录入。
   B:给这个二维数组任何一行的第一列和最后一列赋值为1
   C:按照规律给其他元素赋值
       从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
   D:遍历这个二维数组。

import java.util.Scanner;

public class MyTest {
    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];
        //1.首尾元素为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            //arr[i][arr.length - 1] = 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];
            }
        }
        //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();
        }
    }
}

17、递归

递归的概念

A:递归概述: 方法定义中调用方法本身的现象
B:递归注意事项
要有出口，否则就是死递归
次数不能太多，否则就内存溢出

递归求阶乘的代码实现及内存图解

A:案例演示
   需求：求5的阶乘
   循环实现
   递归实现
B:画图演示:   递归实现求5的阶乘的内存图

满眼星陈ya

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
5、Java语言基础（数组、递归）

1、数组概述和定义格式说明数组是存储多个变量(元素)的东西(容器) 这多个变量的数据类型要一致数组概念数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器数组既可以存储基本数据类型，也可以存储引用数据类型数组定义格式格式1：数据类型[] 数组名；格式2：数据类型数组名[];举例： int[] a；定义了一个int类型的数组a； int a[]; 定义了一个int类型的a数组...
复制链接

扫一扫