文章目录
零、本讲学习目标
1、掌握一维数组的定义和使用(遍历、最值、排序)
2、掌握二维数组的定义和使用(遍历、均值、最值)
一、引入数组
1、假设场景
现在需要统计某公司100名员工的工资情况,例如计算平均工资、最高工资等。
2、笨拙的办法
利用前面所学的知识,程序就需要声明100个变量(salary1, salary2, …, salary100),来分别记住每位员工的工资,这样做的话,显得非常麻烦。
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)选择法排序实现步骤
选择法排序(降序): 个数排序,经过 轮比较。
- 第 轮是第 个数跟剩下的 个数比较,让第 个数成为本轮最大者,要比较 次;
- 第 轮是第 个数跟剩下的 个数比较,让第 个数成为本轮最大者,要比较 次;
- ……
- 第 轮是第 个数与剩下的 个数比较,让第 个数成为本轮最大者,要比较 次。
- 总比较次数:
(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)冒泡法排序实现步骤
冒泡法排序(降序): 个数排序,经过 轮比较。
- 第 轮是 个数里相邻两个数比较,如果后者比前者大就交换,要比较 次,本轮最小者“浮”到第 个位置;
- 第 轮是前 个数里相邻两个数比较,如果后者比前者大就交换,要比较 次,本轮最小者“浮”到第 个位置;
- ……
- 第 轮是前 个数里相邻两个数比较,如果后者比前者大就交换,要比较 次,本轮最小者“浮”到第 个位置;
- 总比较次数:
(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个数
斐波那契数列,又称黄金分割数列,指的是这样一个数列:
在数学上,斐波纳契数列以递推的方法定义:
在现代物理、准晶体结构、化学等领域,斐波纳契数列都有直接的应用,为此,美国数学会从1963起出版了以《斐波纳契数列季刊》为名的一份数学杂志,用于专门刊载这方面的研究成果。
3、编写歌手大赛评分程序
学校举行流行歌手大赛,有10个评委,要求分数在0到10之间,去掉一个最高分,再去掉一个最低分,剩下的8个分数求平均,就是参赛选手的得分,假设有5位参赛选手,编程计算各位选手的得分。
4、利用二维数组打印杨辉三角形
杨辉三角,是二项式系数在三角形中的一种几何排列,中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲,帕斯卡(1623 ~ 1662)在1654年发现这一规律,所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年,比贾宪迟600年。
直角三角形格式输出杨辉三角形:
等腰三角形格式输出杨辉三角形:
——答疑解惑——
- 有同学在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);
}
}
运行程序,结果如下: