Java讲课笔记08：数组

其他 2020-05-25 13:45:35 阅读次数: 0

文章目录

零、本讲学习目标

1、掌握一维数组的定义和使用（遍历、最值、排序）

2、掌握二维数组的定义和使用（遍历、均值、最值）

一、引入数组

1、假设场景

现在需要统计某公司100名员工的工资情况，例如计算平均工资、最高工资等。

2、笨拙的办法

利用前面所学的知识，程序就需要声明100个变量（salary1, salary2, …, salary100），来分别记住每位员工的工资，这样做的话，显得非常麻烦。
a v e r a g e = s a l a r y 1 + s a l a r y 2 + . . . + s a l a r y 100 100 average=\displaystyle\frac{salary1+salary2+...+salary100}{100}

3、优化的办法

可以使用一个数组来记住这100名员工的工资（salary[0], salary[1], …, salary[99]），然后对数组的元素进行操作。

double sum = 0;
double average;
double[] salary[100];
....
for (int i = 0; i < 100; i++) {
    sum = sum + salary[i];
} 
average = sum / 100;
  • 问：程序里为什么要使用数组？
  • 答：为了更方便地处理批量数据。

二、了解数组

1、数组定义

数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

2、数组分类

数组可以分为一维数组和多维数组（最常见的是二维数组）。

三、一维数组

（一）一维数组定义

1、语法格式

数组类型[] 数组名 = new 数组类型[数组长度];   
数组类型[] 数组名 = new 数组类型[]{数组元素0, 数组元素1, ...};  
数组类型[] 数组名 = {数组元素0, 数组元素1, ...};

2、数组定义示例

int[] ids = new int[100];
String[] names = new String[] {"洪艳林", "陈燕文", "郑晓琳", "唐竹龙"};
Object[] student = {1, "张三丰", "男", 20, "15892924560", "[email protected]"};

3、数组定义的内存变化图

在这里插入图片描述

4、数组定义案例演示

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：三种方式定义数组
 * 作者：华卫
 * 日期：2020年4月19日
 */
public class Example801 {
    public static void main(String[] args) {
        // 1. 第一种方式定义数组
        int[] ids = new int[100];
        // 输出整个数组
        System.out.println("ids = " + ids);
        // 输出数组第一个元素
        System.out.println("ids[0] = " + ids[0]);
        // 输出数组最后一个元素
        System.out.println("ids[99] = " + ids[99]);

        // 2. 第二种方式定义数组
        String[] names = new String[] {"洪艳林", "陈燕文", "郑晓琳", "唐竹龙"};
        // 输出整个数组
        System.out.println("names = " + names);
        // 输出数组第一个元素
        System.out.println("names[0] = " + names[0]);
        // 输出数组最后一个元素
        System.out.println("names[3] = " + names[3]);
        
        // 3. 第三种方式定义数组
        Object[] objects = {1, "张三丰", "男", 20, "15892924560", "[email protected]"};
        // 输出整个数组
        System.out.println("objects = " + objects);
        // 输出数组的长度
        System.out.println("数组长度 = " + objects.length);
        // 输出数组第一个元素
        System.out.println("objects[0] = " + objects[0]);
        // 输出数组最后一个元素
        System.out.println("objects[" + (objects.length - 1) +"] = " + objects[objects.length - 1]);
    }
}

运行程序，查看结果：
在这里插入图片描述
直接打印数组变量，并不能输出数组里的数据，输出的是变量类型@哈希码。
数组是一组相同类型的数据，有一个共同的名字，可以通过下标取访问每一个元素。

注意，数组下标是从0开始的，对于上述定义的数组ids，长度是100，因此第一个元素时ids[0]，最后一个元素是ids[99]，访问ids[100]是要出错的，下标越界了。数组ids的长度，可以通过其length属性获取。

第二种数组定义方式，可以再次对数组变量赋值，增删元素：

names = new String[] {"洪艳林", "陈燕文", "郑晓琳", "唐竹龙", "张三丰"};

但是第三种数组定义方式，就不能再次对数组变量赋值，程序编译是要报错：

objects = {1, "张三丰", "男", 20, "15892924560", "[email protected]", "泸州职业技术学院"};

关于第三种方式定义数组，可以对照一下Python的列表操作：
在这里插入图片描述
第一种定义数组方式，定义的整型数组，并没有给元素赋初值，默认值是0，当然不同类型数组元素的初始值并不相同。

5、Java中不同数据类型元素的初始值

在这里插入图片描述

6、案例演示不同类型数组元素的默认值

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：演示不同类型数组元素的默认值
 * 作者：华卫
 * 日期：2020年4月19日
 */
public class Example802 {
    public static void main(String[] args) {
        byte[] bytes = new byte[10];
        System.out.println("byte类型数组元素的默认值：" + bytes[0]);

        short[] shorts = new short[10];
        System.out.println("short类型数组元素的默认值：" + shorts[0]);

        int[] ints = new int[10];
        System.out.println("int类型数组元素的默认值：" + ints[0]);

        long[] longs = new long[10];
        System.out.println("long类型数组元素的默认值：" + longs[0]);

        float[] floats = new float[10];
        System.out.println("float类型数组元素的默认值：" + floats[0]);

        double[] doubles = new double[10];
        System.out.println("double类型数组元素的默认值：" + doubles[0]);

        char[] chars = new char[10];
        System.out.println("char类型数组元素的默认值：" + chars[0]);

        boolean[] booleans = new boolean[10];
        System.out.println("boolean类型数组元素的默认值：" + booleans[0]);

        String[] strings = new String[10];
        System.out.println("String类型数组元素的默认值：" + strings[0]);
    }
}

运行程序，查看结果：
在这里插入图片描述
在使用数组时，如果不想使用这些默认初始值，可以显式地为这些元素赋值，当然也可以对定义数组时的指定初始值进行修改。

7、给数组元素赋初值或修改数组元素已有值

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：演示给数组元素赋值
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example803 {
    public static void main(String[] args) {
        // 1. 第一种方式定义数组
        int[] ids = new int[100];
        // 输出数组第一个元素
        System.out.println("ids[0] = " + ids[0]);
        // 给数组第一个元素赋值进行初始化
        ids[0] = 1000;
        // 再次输出数组第一个元素
        System.out.println("ids[0] = " + ids[0]);

        // 2. 第二种方式定义数组
        String[] names = new String[] {"洪艳林", "陈燕文", "郑晓琳", "唐竹龙"};
        // 输出数组第一个元素
        System.out.println("names[0] = " + names[0]);
        // 修改数组第一个元素的值
        names[0] = "张三丰";
        // 再次输出数组第一个元素
        System.out.println("names[0] = " + names[0]);

        // 3. 第三种方式定义数组
        Object[] objects = {1, "张三丰", "男", 20, "15892924560", "[email protected]"};
        // 输出数组第一个元素
        System.out.println("objects[0] = " + objects[0]);
        // 修改数组第一个元素的值
        objects[0] = 903213;
        // 再次输出数组第一个元素
        System.out.println("objects[0] = " + objects[0]);
    }
}

运行程序，查看结果：
在这里插入图片描述
无论是给数组元素赋初值，还是修改数组元素的值，格式都一样：数组名[下标] = 元素值。

对照一下Python类修改列表的元素值：
在这里插入图片描述

8、使用数组时的注意事项

（1）避免数组下标越界异常

每个数组的索引（下标）都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错（ArrayIndexOutOfBoundsException，即数组角标越界异常）。
在这里插入图片描述

（2）避免数组空指针异常

在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现错误（NullPointerException，即空指针异常）。
在这里插入图片描述

（二）数组常见操作

在程序开发中，数组的应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作，如数组的遍历、最值的获取、数组的排序等，进行详细地讲解。

1、数组遍历

（1）数组遍历的含义

在操作数组时，经常需要依次访问数组中的每个元素，这种操作成为数组的遍历。
利用while循环和for循环都可以实现数组的遍历，其中for循环，除了我们以前学习的for循环，还有一种增强for循环，是JDK1.5开始引入的一种循环方式。

（2）案例演示：统计10个学生的平均分

在这里插入图片描述

方法一、不采用数组完成任务
package net.hw.lesson08;

import java.util.Scanner;
/**
 * 功能：输入10个学生成绩，求平均分
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example806 {
    public static void main(String[] args) {
        // 声明部分       
        double score; // 学生成绩
        double sum = 0; // 总分
        double average; // 平均分
        final int N = 10; // 符号常量：学生人数
        Scanner sc = new Scanner(System.in);

        // 处理部分
       for (int i = 1; i <= N; i++) { 
            System.out.print("输入第" + i + "个学生成绩：");
            score = sc.nextDouble();
            sum += score; // 累加语句         
        }
        average = sum / N; // 计算平均分

        // 输出部分
        System.out.println(N + "个学生的平均分：" + average);
    }
}

运行程序，查看结果：
在这里插入图片描述
本例故意定义了一个符号常量N，用来保存学生人数，你觉得这样做有什么好处呢？

不采用数组固然可以计算出10个学生的平均分，但是这个程序有很大的缺点，由于没有保存10个学生的成绩信息，以后要求10个学生的最高分或最低分，或者要给学生成绩排序，就没有办法完成。因为只有一个score简单变量，保存的是最后一个学生的成绩。

方法二、采用数组完成任务
package net.hw.lesson08;

import java.util.Scanner;
/**
 * 功能：输入10个学生成绩，求平均分
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example806 {
    public static void main(String[] args) {
        // 声明部分
        double[] scores = new double[10];
        double sum = 0, average;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        for (int i = 0; i < scores.length; i++) {
            System.out.print("scores[" + i + "] = ");
            scores[i] = sc.nextDouble();
        }

        // 处理部分
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        average = sum / scores.length; // 计算平均分

        // 输出部分
        System.out.println(scores.length + "个学生的平均分：" + average);
    }
}

运行程序，查看结果：
在这里插入图片描述
本例通过一个for循环实现了数组的遍历，累加求和，然后求均值。想一想，如何让平均分只保留两位小数。

完成相同的任务，采用Python的代码如下：
在这里插入图片描述

（3）课堂练习：采用while循环求10个学生成绩平均分

2、数组最值

（1）数组最值的含义

在操作数组时，经常需要获取数组的最值，于是数组的范围：[最小值，最大值]。

（2）案例演示：求10个学生成绩最高分，并确定谁得了最高分

在这里插入图片描述

package net.hw.lesson08;

import java.util.Scanner;

/**
 * 功能：求10个学生成绩的最高分，
 *      并且确定是谁得了最高分。
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example807 {
    public static void main(String[] args) {
        // 声明部分
        int[] scores = new int[10]; // 成绩数组
        int maxScore; //最高分
        Scanner sc = new Scanner(System.in); // 扫描器

        // 输入部分
        for (int i = 0; i < scores.length; i++) {
            System.out.print("scores[" + i + "] = ");
            scores[i] = sc.nextInt();
        }

        // 处理部分
        maxScore = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }

        //输出部分
        System.out.println("\n最高分 = " + maxScore);
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] == maxScore) {
                System.out.println("scores[" + i + "] = " + maxScore);
            }
        }
    }
}

运行程序，查看结果：
在这里插入图片描述
求数组元素最值，肯定是要遍历数组全部元素，通过比较获取最大值，然后再次遍历数组，确定哪些位置的数组元素是最大值。从输出结果可以看出，第三个和第七个数组元素是最大值98。

采用Python完成相同的任务：
在这里插入图片描述

（3）课堂练习：求10个学生成绩最低分，并确定谁得了最低分

将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。常见排序算法：快速排序、希尔排序、堆排序、直接选择排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。
在这里插入图片描述

3、数组选择法排序

（1）选择法排序含义

选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

（2）选择法排序实现步骤

选择法排序（降序）： n n 个数排序，经过 n − 1 n-1 轮比较。

  • 第 1 1 轮是第 1 1 个数跟剩下的 ( n − 1 ) (n-1) 个数比较，让第 1 1 个数成为本轮最大者，要比较 ( n − 1 ) (n-1) 次；
  • 第 2 2 轮是第 2 2 个数跟剩下的 ( n − 2 ) (n-2) 个数比较，让第 2 2 个数成为本轮最大者，要比较 ( n − 2 ) (n-2) 次；
  • ……
  • 第 ( n − 1 ) (n-1) 轮是第 ( n − 1 ) (n-1) 个数与剩下的 1 1 个数比较，让第 ( n − 1 ) (n-1) 个数成为本轮最大者，要比较 1 1 次。
  • 总比较次数： ( n − 1 ) + ( n − 2 ) + . . . + 2 + 1 = n ( n − 1 ) 2 = O ( n 2 ) (n-1)+(n-2)+...+2+1 = \displaystyle \frac{n(n-1)}{2}=O(n^2)

（3）演示排序算法步骤

在这里插入图片描述

（4）案例演示：采用选择法降序排列数组

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：演示选择法排序（降序）
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example808 {
    public static void main(String[] args) {
        // 声明数组
        int[] arr = {71, 54, 58, 29, 31, 78, 2, 77, 82};

        // 1. 选择排序前，先循环打印数组元素
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        // 2. 进行选择排序
        // 2.1 外层循环定义需要比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 2.2 内层循环定义第i轮需要进行的比较
            for (int j = i + 1; j < arr.length; j++) {
                // 比较第i个元素与剩下的数组元素
                if (arr[i] < arr[j]) {
                    // 下面三行代码用于交换两个元素的值
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        // 3. 完成选择排序后，再次循环打印数组元素
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行程序，查看结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在Java中交换两个变量的值需要引入第三个中转变量：
在这里插入图片描述
但是Python可以不引入第三个变量而交换两个变量的值，比其它语言来得更简洁：
在这里插入图片描述

4、数组冒泡法排序

（1）冒泡法排序含义

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

（2）冒泡法排序实现步骤

冒泡法排序（降序）： n n 个数排序，经过 n − 1 n-1 轮比较。

  • 第 1 1 轮是 n n 个数里相邻两个数比较，如果后者比前者大就交换，要比较 ( n − 1 ) (n-1) 次，本轮最小者“浮”到第 n n 个位置；
  • 第 2 2 轮是前 ( n − 1 ) (n-1) 个数里相邻两个数比较，如果后者比前者大就交换，要比较 ( n − 2 ) (n-2) 次，本轮最小者“浮”到第 ( n − 1 ) (n-1) 个位置；
  • ……
  • 第 ( n − 1 ) (n-1) 轮是前 2 2 个数里相邻两个数比较，如果后者比前者大就交换，要比较 1 1 次，本轮最小者“浮”到第 2 2 个位置；
  • 总比较次数： ( n − 1 ) + ( n − 2 ) + . . . + 2 + 1 = n ( n − 1 ) 2 (n-1)+(n-2)+...+2+1 = \displaystyle \frac{n(n-1)}{2}

（3）演示排序算法步骤

在这里插入图片描述

（4）案例演示：采用冒泡法降序排列数组

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：演示冒泡法排序（降序）
 * 作者：华卫
 * 日期：2020年4月24日
 */
public class Example809 {
    public static void main(String[] args) {
        // 声明数组
        int[] arr = {71, 54, 58, 29, 31, 78, 2, 77, 82};

        // 1. 选择排序前，先循环打印数组元素
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        // 2. 进行冒泡排序
        // 2.1 外层循环定义需要比较的轮数
        for (int i = 1; i < arr.length; i++) {
            // 2.2 内层循环定义第i轮需要进行的比较
            for (int j = 0; j < arr.length - i; j++) {
                // 比较相邻两个元素
                if (arr[j] < arr[j + 1]) {
                    // 下面三行代码用于交换两个元素的值
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 3. 完成冒泡排序后，再次循环打印数组元素
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行程序，查看结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5、利用Arrays类的sort方法实现数组排序（只需了解）

JDK1.8 API下载链接：https://pan.baidu.com/s/1p4a2WPjDLAikOp5oCjW2PQ 提取码：w3re
在这里插入图片描述
我们可以利用java.util.Arrays类的sort方法来实现数组排序。
在这里插入图片描述

package net.hw.lesson08;

import java.util.Arrays;

/**
 * 功能：利用Arrays类的sort方法实现数组排序
 * 作者：华卫
 * 日期：2020年4月25日
 */
public class Example810 {
    public static void main(String[] args) {
        // 声明数组
        int[] arr = {71, 54, 58, 29, 31, 78, 2, 77, 82};

        // 1. 排序前，先循环打印数组元素
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        // 2. 利用Arrays类的sort方法排序数组
        Arrays.sort(arr);

        // 3. 完成排序后，再次循环打印数组元素
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行程序，查看结果：
在这里插入图片描述
采用Arrays类的sort方法排序数组，默认是升序排列，如果要实现降序排列，可以利用Collections.reverseOrder()作为sort方法的第二参数，演示如下：
在这里插入图片描述
还可以利用Comparator接口来实现降序排列：
在这里插入图片描述
其实，Python列表也提供sort()方法对列表进行排序：
在这里插入图片描述

在前面讲数组遍历时，提到过增强for循环，下面利用上述案例演示一下如何利用增强for循环输出排序后的数组：
在这里插入图片描述

四、二维数组

（一）引入多维数组的场景

在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？

上面这种场景就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。而在程序中，比较常见的多维数组是二维数组。

（二）二维数组的定义

1、指定二维数组的长度和每个数组的元素个数

int[][] xx = new int[3][4];

上面的代码相当于定义了一个3*4的二维数组，这个二维数组的长度为3，可以将它看成3个int[]类型的一维数组，每个一维数组中的元素又是一个长度为4的一维数组。
在这里插入图片描述

2、只指定二维数组的长度，不确定每个数组的元素个数

int[][] xx = new int[3][];

第二种方式和第一种类似，只是数组中每个元素的长度不确定。
在这里插入图片描述

3、直接使用嵌套大括号“{}”，对二维数组初始化赋值

int[][] xx = {{1, 2}, {3, 4, 5, 6}, {7, 8, 9}};

上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1, 2}、{3, 4, 5, 6}、{7, 8, 9} 。
在这里插入图片描述

（三）二维数组的使用

任务1、演示二维数组的遍历与行列元素的访问

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：演示二维数组的遍历与行列元素的访问
 * 作者：华卫
 * 日期：2020年4月25日
 */
public class Example811 {
    public static void main(String[] args) {
        // 1. 创建3行4列的二维数组
        int[][] a = new int[3][4];

        a[0][0] = 100; // 给第1行第1列元素赋值
        a[1][2] = 150; // 给第2行第3列元素赋值

        System.out.println("a[0][0] = " + a[0][0]);
        System.out.println("a[1][2] = " + a[1][2]);

        int sum = a[0][0] + a[1][2];
        System.out.println("a[0][0] + a[1][2] = " + sum);

        // 2. 创建3行的二维数组（不规则二维数组）
        int[][] b = new int[3][];
        b[0] = new int[2]; // 第1行包含2个元素
        b[1] = new int[3]; // 第2行包含3个元素
        b[2] = new int[4]; // 第3行包含4个元素

        // 遍历二维数组，初始化每个数组元素
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                b[i][j] = (i + 1) * (j + 1);
            }
        }

        // 遍历二维数组，按行列输出数组元素
        System.out.println("数组b全部元素：");
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j] + "\t");
            }
            System.out.println(); // 换行
        }

        // 3. 静态初始化二维数组
        int[][] c = {{12, 45, 66, 24}, {56, 78, 90, 32}, {32, 44, 56, 98}};

        System.out.println("数组c全部元素：");
        for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[i].length; j++) {
                System.out.print(c[i][j] + " ");
            }
            System.out.println(); // 换行
        }

        System.out.println("第2行第3列元素：" + c[1][2]);

        System.out.print("第3行的全部元素：");
        for (int j = 0; j < c[2].length; j++) {
            System.out.print(c[2][j] + " ");
        }
        System.out.println();

        System.out.println("第3列的全部元素：");
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i][2]);
        }
    }
}

运行程序，查看结果：
在这里插入图片描述

任务2、求二维数组所有元素的平均值、最大值和最小值

在这里插入图片描述

package net.hw.lesson08;

/**
 * 功能：求二维数组的均值与最值
 * 作者：华卫
 * 日期：2020年4月25日
 */
public class Example812 {
    public static void main(String[] args) {
        // 声明部分
        int[][] a = {
                {12, 45, 66, 24},
                {56, 78, 90, 32},
                {32, 44, 56, 98}
        };
        int sum = 0;
        int average;
        int max, min;

        //处理部分
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                sum += a[i][j];
            }
        }
        average = sum / (a.length * a[0].length);

        max = a[0][0];  // max = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (max < a[i][j]) {
                    max = a[i][j];
                }
            }
        }

        min = a[0][0]; // min = Integer.MAX_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (min > a[i][j]) {
                    min = a[i][j];
                }
            }
        }

        //输出部分
        System.out.println("平均值：" + average);
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
    }
}

运行程序，查看结果：
在这里插入图片描述
说明：average = sum / (a.length * a[0].length);针对规则的二维数组没有问题，但是对于不规则的二维数组（数组每一行的元素个数不同）就是错误的处理方式。

思考题：针对不规则的二维数组，该如何来计算平均值呢？

  • 创建Example812_
package net.hw.lesson08;

/**
 * 功能：求二维数组均值和最值
 * 作者：华卫
 * 日期：2020年05月11日
 */
public class Example812_ {
    public static void main(String[] args) {
        // 声明部分（静态初始化一个二维数组）
        int[][] a = {
                {12, 45},
                {56, 78, 90, 32},
                {32, 44, 56}
        };
        int sum = 0;
        int average;
        int max, min;
        int count = 0;

        // 处理部分
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                sum += a[i][j];
            }
        }
        for (int i = 0; i < a.length; i++) {
            count += a[i].length;
        }
        average = sum / count;

        max = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (max < a[i][j]) {
                    max = a[i][j];
                }
            }
        }

        min = Integer.MAX_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (min > a[i][j]) {
                    min = a[i][j];
                }
            }
        }

        // 输出部分
        System.out.println("元素个数：" + count);
        System.out.println("平均值：" + average);
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
    }
}

在程序开头定义了一个不规则的二维数组，第一行2个元素，第二行4个元素，第三行3个元素，总共有9个元素。
在这里插入图片描述
运行程序，查看结果：
在这里插入图片描述
19计应3班的赖晓桐给出不同计算方法：
在这里插入图片描述
刚才我们静态初始化了一个不规则二维数组，现在我们要问能否动态初始化一个同样的二维数组呢？下面我们给出案例演示。

package net.hw.lesson08;

/**
 * 功能：静态和动态初始化不规则二维数组
 * 作者：华卫
 * 日期：2020年05月11日
 */
public class Example813 {
    public static void main(String[] args) {
        // 静态初始化不规则二维数组
        int[][] a = {
                {12, 45},
                {56, 78, 90, 32},
                {32, 44, 56}
        };

        // 动态初始化不规则二维数组
        int[][] b = new int[3][];
        b[0] = new int[2];
        b[1] = new int[4];
        b[2] = new int[3];

        b[0][0] = 12;
        b[0][1] = 45;
        b[1][0] = 56;
        b[1][1] = 78;
        b[1][2] = 90;
        b[1][3] = 32;
        b[2][0] = 32;
        b[2][1] = 44;
        b[2][2] = 56;

        // 输出二维数组a
        System.out.println("数组a：");
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + "\t");
            }
            System.out.println();
        }

        System.out.println("数组b：");
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

运行程序，结果如下：
在这里插入图片描述

五、课后作业

1、在一维数组中查询某个数

已知一维数组，输入一个数，判断这个数是否在这个数组里，如果在，在哪个位置？
在这里插入图片描述
在这里插入图片描述

2、采用数组，输出斐波拉契数列前30项，每行输出5个数

斐波那契数列，又称黄金分割数列，指的是这样一个数列： 0 、 1 、 1 、 2 、 3 、 5 、 8 、 13 、 21 、 34 、 … … 0、1、1、2、3、5、8、13、21、34、…… 在数学上，斐波纳契数列以递推的方法定义： F ( 0 ) = 0 ， F ( 1 ) = 1 ， F ( n ） = F ( n − 1 ) + F ( n − 2 ) （ n ≥ 2 ， n ∈ N ∗ ） F(0)=0，F(1)=1，F(n）=F(n-1)+F(n-2)（n≥2，n∈N*） 在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从1963起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。
在这里插入图片描述

3、编写歌手大赛评分程序

学校举行流行歌手大赛，有10个评委，要求分数在0到10之间，去掉一个最高分，再去掉一个最低分，剩下的8个分数求平均，就是参赛选手的得分，假设有5位参赛选手，编程计算各位选手的得分。
在这里插入图片描述

4、利用二维数组打印杨辉三角形

杨辉三角，是二项式系数在三角形中的一种几何排列，中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623 ~ 1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

a [ i ] [ 0 ] = 1 ， i ∈ N a[i][0]=1，i\in N
a [ i ] [ i ] = 1 ， i ∈ N a[i][i]=1，i\in N
a [ i ] [ j ] = a [ i − 1 ] [ j − 1 ] + a [ i − 1 ] [ j ] ， i ≥ 2 ， 1 ≤ j < i a[i][j]=a[i-1][j-1]+a[i-1][j]，i\ge2，1\le j\lt i
在这里插入图片描述
直角三角形格式输出杨辉三角形：
在这里插入图片描述
等腰三角形格式输出杨辉三角形：
在这里插入图片描述

——答疑解惑——

  • 有同学在CSDN私信求解。题目涉及到字符串、数组与循环相关知识。

已知字符串s=‘苹果:12个;梨:20个;桔子:35个;香蕉:18个;’，试编写程序，实现以下功能：

1、根据输入的水果，查询个数。(假设用户输入的水果在字符串中均存在) 例如：输入’苹果’，输出‘苹果总共有12个。’
2、计算梨和香蕉这两种水果的总个数，并将结果输出。 3、将字符串s中的桔子替换成橙子，并将替换后的结果输出。

  • 1、根据输入的水果，查询个数
    在这里插入图片描述
package net.hw.fruit;

import java.util.Scanner;

public class Exercise01 {
    public static void main(String[] args) {
        String fruit;
        Scanner sc = new Scanner(System.in);
        String s = "苹果:12个;梨:20个;桔子:35个;香蕉:18个;";

        s = s.substring(0, s.length() - 1);
        String[] fruits = s.split(";");

        System.out.print("输入水果：");
        fruit = sc.next();

        if (s.contains(fruit)) {
            for (int i = 0; i < fruits.length; i++) {
                if (fruits[i].contains(fruit)) {
                    String[] data = fruits[i].split(":");
                    System.out.println(data[0] + "总共有" + data[1]);
                }
            }
        } else {
            System.out.println("输入的水果不存在！");
        }
    }
}

运行程序，结果如下：
在这里插入图片描述
再运行程序，结果如下：
在这里插入图片描述

  • 2、计算梨和香蕉这两种水果的总个数，并将结果输出
    在这里插入图片描述
package net.hw.fruit;

import java.util.Scanner;

public class Exercise02 {
    public static void main(String[] args) {        
        String s = "苹果:12个;梨:20个;桔子:35个;香蕉:18个;";

        s = s.substring(0, s.length() - 1);
        String[] fruits = s.split(";");

        int count = 0;
        for (int i = 0; i < fruits.length; i++) {
            if (fruits[i].contains("梨")) {
                String[] data = fruits[i].split(":");
                count += Integer.parseInt(data[1].substring(0, data[1].length() - 1));
            }
            if (fruits[i].contains("香蕉")) {
                String[] data = fruits[i].split(":");
                count += Integer.parseInt(data[1].substring(0, data[1].length() - 1));
            }
        }
        System.out.println("梨与香蕉的总个数：" + count);
    }
}

运行程序，结果如下：
在这里插入图片描述

  • 3、将字符串s中的桔子替换成橙子，并将替换后的结果输出
    在这里插入图片描述
package net.hw.fruit;

public class Exercise03 {
    public static void main(String[] args) {
        String s = "苹果:12个;梨:20个;桔子:35个;香蕉:18个;";

        String s1 = s.replace("桔子", "橙子");

        System.out.println("替换前：" + s);
        System.out.println("替换后：" + s1);
    }
}

运行程序，结果如下：
在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/howard2005/article/details/105623877
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022