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

Java基础专栏

Java基础（第五期）

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

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

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

1.1 数组初始化

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

1.2 数组的定义格式

格式一：

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

格式二：

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

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

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： 表示数据类型首字母大写   →   @  分隔符   →   后面的就是十六进制内存地址
         */
    }
}

• 注意看一下注释！！！

二、 数组元素访问

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

• 格式：数组名[索引]
• 注意：数组索引从 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 次
        }
    }
}

• 用需求引用知识点，加深和巩固。

三、数组遍历操作

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

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

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

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

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
 */

• 这里使用方法封装功能进行模块化实现功能。

五、数组动态初始化

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

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

默认返回的类型为：

默认值分类：
整数： 0；

​ 小数： 0.0

​ 布尔：false

---

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

​ 字符串： null

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

int[] arr = new int[3];

六、两种初始化的区别

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

应用场景：

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

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

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

• 静态初始化用于明确具体指，不明确个数的场景

需求：求出 班級人数的总分 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);

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

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

一维数组内存图

引用数据类型

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

经过上面的内存图分析：

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

• 知道为什么等于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

8.2 二维数组的遍历

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

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

正确方法：

遍历二维数组的操作：
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]);
            }
        }

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

    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

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

• 注意：动态初始化，我们存放值是不是有点麻烦啊！

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

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

二维数组内存图

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

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