• Java基础（第五期）： 一维数组 && 二维数组 && 数组 && 引用数据类型在内存中的存储图解

    Java基础专栏

    文章目录

    Java基础（第五期）

    一、数组介绍和静态初始化

    数组（Array）：数组指的是一种容器，可以用来存储同种数据类型的多个值。

    今后若要操作多数据，同种数据类型就可以考虑数组。

    1.1 数组初始化
    • 初始化：就是在内存中，为数组开辟空间，并将数据存入容器中的过程。
    1.2 数组的定义格式

    格式一：

    数据类型[] 数组名
int[] array

    • 1
    • 2

    格式二：

    数据类型 数组名[]
int array[]

    • 1
    • 2
            // 创建一个整数类型的数组变量
        int[] array;
        int array1 [];

    • 1
    • 2
    • 3
    1.3 数组的静态初始化格式

    一种是完整格式，一种是简化格式

    package com.liujintao.array;

public class ArrayDemo1 {
    public static void main(String[] args) {
        arrayTest1();
    }

    public static void arrayTest1() {
        // 完整写法
        int[] arr1 = new int[]{11,22,33};
        double[] arr3 = new double[] {11,22,33};

        // 简写方法
        int[] arr2 = {11,22,33};
        double[] arr4 = {11,22,33};

        System.out.println(arr2);
        System.out.println(arr4);

        /*
            [I@58ceff1    →  [ : 表示数组类型   →    I： 表示数据类型首字母大写   →   @  分隔符   →   后面的就是十六进制内存地址
            [D@7c30a502     →  [ : 表示数组类型   →    I： 表示数据类型首字母大写   →   @  分隔符   →   后面的就是十六进制内存地址
         */
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 注意看一下注释！！！

    二、 数组元素访问

    想要访问数组里面的元素，就只有用到索引。

    • 格式：数组名[索引]
    • 注意：数组索引从 0 开始
    package com.liujintao.array;
    /*
        数组元素索引：
            数组名[索引号]
            索引号从0开始哦！
     */
public class ArrayDemo2 {
    public static void main(String[] args) {
        arrayTest();
    }

    public static void arrayTest()   {
        int [] arr = {11,22,33,44,55};
        // 1、访问数组 元素 33
        System.out.println(arr[2]); // 33

        // 2、判断数组中第一个元素是奇数还是偶数
        if (! (arr[0] % 2 == 0)) {
            System.out.println("是奇数");
        } else {
            System.out.println("是偶数");
        }

        // 3、修改数组中第三个元素为 66
        arr[2] = 66;
        System.out.println(arr[2]);  // 66

        // 4、根据数组中第四个元素，System.out.pritnln多少次
        for (int i = 1; i <= arr[3]; i++) {
            System.out.println("Hello World"); // 输出 44 次
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 用需求引用知识点，加深和巩固。

    三、数组遍历操作

    遍历：就是将数组里面的所有元素进行访问。

    length：动态的获取数组长度。

    package com.liujintao;
    /*
        数组遍历：
            将数组每一个（所有）的内容，取出来进行操作。
     */
public class ArrayTest1 {
    public static void main(String[] args) {
        printArray();
    }

    public static void printArray() {
        int[] arr = {11, 22, 33, 44, 55};
        // 注意 length：是数组的长度，用法就是直接点（注意数组下标越界）
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • length的使用需要注意。这样防止写死。在很多编程语言中都会有的。

    四、数组遍历求和等练习

    1.求出数组中所有偶数元素的和

        /*
        需求： 对数组中的偶数元素 做求和操作。
            每一个：就得用遍历
     */
    public static void getSum() {
        int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
        int sum = 0;
        // 使用技巧： 遇到数组和循环，初始值从0开始，并且最大条件就用length，不行我们再改
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0) {
                sum += arr[i];
                System.out.println(arr[i]);
            } else {
                sum += arr[i]; // 595
            }
        }
        System.out.println("数组中所有的偶数和为：" + sum);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    2.数组求最大值

    需求：数组有 5 个元素，，请找出数组中的最大值并打印。

    package com.liujintao.array;
    /*
        需求：数组有 5 个元素，，请找出数组中的最大值并打印。
     */
public class ArrayTest2 {
    public static void main (String[] args) {
        int[] arr = {5, 44, 33, 55, 22};
        int result = getMax(arr); // 只需要传递数组名
        System.out.println("数组中最大值为：" + result);  // 55
    }

    public static int getMax(int[] arr) { // 这里使用整数类型的数组变量接收
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    3、处理班级学生成绩

    成绩为： int[] arr = {100, 50, 20, 90, 90};

    1、找出数组最大值，并打印

    2、找出数组最小值，并打印

    3、求总成绩，并打印

    4、计算出平均值，并打印

    5、统计低于平均值的元素个数

    package com.liujintao.test;

public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr = {100, 50, 20, 90, 90};
        handleSchool(arr);

    }

    public static void handleSchool(int[] arr) {
        int max = handleMax(arr);
        int min = handleMin(arr);
        int sum = handleSum(arr);
        double average = handleAverage(arr);
        int count = handleCount(arr, average);

        System.out.println("最高分为：" + max);
        System.out.println("最低分为：" + min);
        System.out.println("总成绩为：" + sum);
        System.out.println("平均成绩为：" + average);
        System.out.println("低于平均分的个数为：" + count);
    }

    // 1、求最大值
    public static int handleMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }


    // 2、求最小值
    public static int handleMin(int[] arr) {
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        return min;
    }

    // 3、求总成绩
    public static int handleSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    // 4、求平均值
    public static double handleAverage(int[] arr) {
        double average = 0;
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return average = sum / arr.length;  // 自动转换
    }

    // 5、统计低于平均值的个数
    public static int  handleCount(int[] arr, double average) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < average) {
                count++;
            }
        }
        return count;
    }
}

/*
    运行结果为：
        最高分为：100
        最低分为：20
        总成绩为：350
        平均成绩为：70.0
        低于平均分的个数为：2
 */

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 这里使用方法封装功能进行模块化实现功能。

    五、数组动态初始化

    动态初始化：就是在我们创建数组初始化的时候，系统会默认分配默认值（初始值）

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

    默认返回的类型为：

    默认值分类：
    整数： 0；

    ​ 小数： 0.0

    ​ 布尔：false

    ​ 字符： ’\u0000‘ → Unicode字符 → 打印的话就是空白

    ​ 字符串： null

    ​ 引用数据类型： null （数组、类、接口）都是引用数据类型

    int[] arr = new int[3];


    • 1
    • 2

    六、两种初始化的区别

    • 动态初始化：手动指定数组长度，有系统给出默认初始值
    • 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组长度。

    应用场景：

    • 动态初始化用于明确个数，不明确具体值

    需求1：输入5名学生的成绩，并打印出来。

        public static void handleInput() {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[5];
        System.out.println("请输入5名学生的成绩：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "名学生的成绩：");
            arr[i] = sc.nextInt();
            System.out.println("第" + (i + 1) + "名学生的成绩为：" + arr[i]);
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    需求2：产生10个 1- 100 之间的随机数，并且求出最小值。

        public static int getRandomMin() {
        Random r = new Random();

        int[] arr = new int[10]; // 动态初始化数组长度（因为我们知道了长度）
        for (int i = 0; i < arr.length; i++) {
            int num = r.nextInt(100) + 1;
            arr[i] = num;
        }
        // 得到是个随机数，求出数组中的最小值
        int min = 0;
        for (int i = 1;i < arr.length; i++) {
            min = arr[i];
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        return min;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 静态初始化用于明确具体指，不明确个数的场景

    需求：求出 班級人数的总分 100,50,20,40,90

    int[] arr = {100, 50, 20, 40, 90};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum += arr[i];
}
System.out.println("班级总成绩为：" + sum);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    七、数组内存图和方法参数传递

        public static void main (String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        System.out.println("调用change方法之前：" + arr[0]);   // 11
        change(arr);
        System.out.println("调用change方法之前：" + arr[0]);   // 66
    }
    public static void change(int[] arr) {
        arr[0] = 66;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    一维数组内存图

    引用数据类型

    • 如果是普通数据类型，必须得有return 返回值，否则，修改不了数据哦！

    在这里插入图片描述

    经过上面的内存图分析：

           int[] arr = {11, 22, 33, 44, 55};
        int[] arr1 = arr;
        arr1[0] = 99;
        System.out.println(arr[0]); // 99

    • 1
    • 2
    • 3
    • 4
    • 知道为什么等于99吗？

    不知道的继续往上看内存图。

    八、二维数组静态初始化

    • 二维数组是一种容器，该容器用于存放一维数组。

    存放多组数据，又属于同种数据，那么就可以考虑二维数组来进行维护。

    8.1 二维数组的静态初始化

    定义二维数组和使用二维数组。

    // 语法定义格式   
int[][] arr = {
                {11, 22, 33},
                {33, 44, 55}
        };

// 访问二维数据里面的一维数组
System.out.println(arr[0]);  // [I@58ceff1 (存放在堆空间二维数组里面的地址)


// 访问二维数组里面的一维数组
System.out.println(arr[0][0]); // 11

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    8.2 二维数组的遍历

    下面这样操作直接遍历的是一维数组的地址

            for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);     // 打印的是一维数组的地址
        }

    • 1
    • 2
    • 3

    正确方法：

    遍历二维数组的操作：
    1、先遍历二维数组拿到每一个一维数组。
    2、然后遍历一维数组中的下标即可。

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    二维数组练习：
    需求：对一个任意一个整数类型的二位数组求和：

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


        int result = getSum(arr);
        System.out.println("二维数组的和为：" + result);   // 二维数组的和为：198


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    8.3 二维数组动态初始化

    二维数组动态初始化：
    格式： 数据类型[][] 数组名 = new 数据类型[m][n]
    + m: 这个二位数组中可以存放多少个一维数组（一维数组地址）
    + n：指定一维数组可以存放多少个元素

                   // 如下就是动态创建一个二维数组
            int[][] arr = new int[2][3];

            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    System.out.println(arr[i][j]);    // 打印结果为 0 0 0 0 0 0
                }
            }
        }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 注意：动态初始化，我们存放值是不是有点麻烦啊！

    那么此时我们可以将一维数组赋值给二维数组

            // 将提前定义好的一维数组，赋值给二维数组
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {4, 5, 6};
        int[][] arr = new int[2][3];
        arr[0] = arr1;
        arr[1] = arr2;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    二维数组内存图

    在这里插入图片描述

    • Java基础（第五期）到此结束…

    下期综合的练习数组和巩固联系。下期见！

  • 相关阅读:
    [python3] 责任链模式
    File 类和 IO 流
    使用 Java 解析 Apache 日志文件
    北游项目笔记
    “四大高手”为你的 Vue 应用程序保驾护航
    实验18.RIP路由引入
    电商数据采集分析全流程分享
    2022-Java 后端工程师面试指南 -(SSM）
    Playwright测试自动化工具
    【数据结构与算法】常见排序算法（Sorting Algorithm）
  • 原文地址：https://blog.csdn.net/Forever_Hopeful/article/details/134253089