开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第6天，点击查看活动详情
前言
一、数组定义和访问
1.1 数组的概述
- 数组:是引用数据类型的一种,是一个容器,可以存储同种数据类型的多个数据
- 数组可以存储的数据类型有基本数据类型(4类8种),也可以存储引用数据类型(字符串String,自定义类型Person)
- 数组的长度是固定的,不能改变
1.2 数组的定义格式
- 动态初始化创建数组: 指定数组的长度,数组中有默认的初始化值，数据类型 变量名 = 对象;定义了一个变量:int[] arr1 = new int[5];
- 静态初始化创建数组: 创建一个包含指定元素的数组，数组中存储几个元素,数组的长度就是几。创建一个double类型的数组,里边包含默认值1.1,2.2,3.3 double[] arr2 = new double[]{1.1,2.2,3.3};
- 静态初始化简化模式 创建一个double类型的数组,里边包含默认值1.1,2.2,3.3。 double[] arr4 = {1.1,2.2,3.3};省略了new double[],JVM会默认给我们加上
/*
需求:
1.定义一个byte类型,长度为20的数组(动态)
2.定义一个float类型,里边包含默认值2.2,3.3,8.8的数组(静态)
3.定义一个char类型,里边包含默认值'a','b','c','d','e'的数组(静态)
4.定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
*/
public class Demo02Array {
public static void main(String[] args) {
//1.定义一个byte类型,长度为20的数组(动态)
byte[] arr1 = new byte[20];
//byte arr1[] = new byte[20];
//2.定义一个float类型,里边包含默认值2.2,3.3,8.8的数组(静态)
float[] arr2 = {2.2F,3.3F,8.8F};
//3.定义一个char类型,里边包含默认值'a','b','c','d','e'的数组(静态)
char[] arr3 = {'a','b','c','d','e'};
//4.定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
String[] arr4 = {"张三","李四","王五","赵六","田七"};
}
}
1.3 数组的使用格式
数组的使用主要通过数组名和索引(下标,角标,房间号)来访问数组中的元素
格式: 数组名[索引]
索引的范围:0 到 数组长度-1 数组的长度是20: 索引[0-19]
int[] arr = new int[10];{0,0,0,0,0,0,0,0,0,0}
- 1.取出指定索引处的元素\
- 直接输出 System.out.println(数组名[索引]);
System.out.println(arr[1]); - b.把取出的元素,赋值给一个变量 数组的数据类型 变量名 = 数组名[索引];
int a = arr[1];
- 直接输出 System.out.println(数组名[索引]);
- 2.给指定索引处的元素赋值
数组名[索引] = 数据值;
arr[1] = 88; {0,88,0,0,0,0,0,0,0,0}
public class Demo03Array {
public static void main(String[] args) {
//定义一个长度为10的int类型的数组
int[] arr = new int[10];//{0,0,0,0,0,0,0,0,0,0}
//1.取出指定索引处的元素
// a.直接输出 System.out.println(数组名[索引]);
System.out.println(arr[1]);//0
System.out.println(arr[3]);//0
//b.把取出的元素,赋值给一个变量 数组的数据类型 变量名 = 数组名[索引];
int a = arr[5];
System.out.println("a:"+a);//a:0
//2.给指定索引处的元素赋值
arr[1] = 88;//{0,88,0,0,0,0,0,0,0,0}
arr[2] = 99;//{0,88,99,0,0,0,0,0,0,0}
System.out.println(arr[0]);//0
System.out.println(arr[1]);//88
System.out.println(arr[2]);//99
}
}
/*
需求:
定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
1.直接打印数组中的第二个元素
2.给数中的第二个元素赋值为:"尼古拉斯赵四"
3.把数组中的第二个元素取出来,赋值给一个String类型的变量
4.打印变量的值
*/
public class Demo04Array {
public static void main(String[] args) {
String[] arr = {"张三","李四","王五","赵六","田七"};
//1.直接打印数组中的第二个元素
System.out.println(arr[1]);//李四
//2.给数中的第二个元素赋值为:"尼古拉斯赵四"
arr[1] = "尼古拉斯赵四";//{"张三","尼古拉斯赵四","王五","赵六","田七"};
//3.把数组中的第二个元素取出来,赋值给一个String类型的变量
String s = arr[1];
//4.打印变量的值
System.out.println("s:"+s);//s:尼古拉斯赵四
}
}
1.4数组的遍历
/*
遍历数组(遍历数组):依次打印数组中的元素
*/
public class Demo05Array {
public static void main(String[] args) {
String[] arr = {"张三","李四","王五","赵六","田七","张三","李四","王五","赵六","田七","张三","李四","王五","赵六","田七"};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("-----------------------");
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
System.out.println("-----------------------");
for (int i = 0; i < 5; i++) {
System.out.println(arr[i]);
}
System.out.println("-----------------------");
//数组中有一个属性,叫length,可以获取数组的长度(元素个数)
int len = arr.length;
System.out.println(len);//15
System.out.println("-----------------------");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
1.5.数组操作的常见问题
/*
数组操作的常见问题：
*/
public class Demo07Array {
public static void main(String[] args) {
//1.定义错误
//int[] arr = new int[];//错误，动态初始化没有指定长度
//int[] arr = new int[3]{10,20,30};//错误，静态初始化，不能指定长度
//2.索引越界异常:访问了数组的不存在的索引,就会抛出异常
int[] arr = {10,20,30};//索引:0,1,2
System.out.println(arr[1]);//20
//System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
//3.空指针异常:把数组的值赋值为null,就相当于把数组的房子拆了,就没有了,就不能在使用了
arr = null;
System.out.println(arr[1]);//NullPointerException
}
}
6.数组练习
/*
请定义类,并添加main()方法,按以下要求定义数组：
1. 请定义5个长度的数组,可以存储并打印以下5名学员的姓名：
"杨幂","刘恺威","古力娜扎","柳岩","郭德纲"
2. 请定义5个长度的数组,可以存储并打印5名学员的性别：
'女', '男', '女', '女', '男'
3. 请定义5个长度的数组,可以存储并打印5名学员的身高：
1.65, 1.85, 1.70, 1.68, 1.85
4. 请将以上三个数组"反向遍历",并打印每个元素！！
*/
public class Demo06Test {
public static void main(String[] args) {
String[] arr1 = {"杨幂","刘恺威","古力娜扎","柳岩","郭德纲" };
//遍历数组的快捷键: 数组名.fori 回车
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+" ");
}
System.out.println();//换行
System.out.println("----------------------------------------");
char[] arr2 = {'女', '男', '女', '女', '男'};
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+ " ");
}
System.out.println();
System.out.println("----------------------------------------");
double[] arr3 = {1.65, 1.85, 1.70, 1.68, 1.85};
for (int i = 0; i < arr3.length; i++) {
System.out.print(arr3[i]+" ");
}
System.out.println();
System.out.println("----------------------------------------");
// 4. 请将以上三个数组"反向遍历",并打印每个元素！！
for (int i = arr1.length-1; i >=0 ; i--) {
System.out.println(arr1[i]);
}
}
}
二、数组的常见操作
2.1 选数组中符合条件的元素
需求:有以下数组，存储了6名学员的体重： int[] arr = {120,130,110,125,128,164};请编程计算并打印：大于等于130斤以上的体重值。
/*
常见操作一：挑选
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印：大于等于130斤以上的体重值。
分析:
1.定义数组
2.遍历数组,获取数组中的每一个元素
3.判断元素>=130
4.则打印元素
*/
public class Demo01ArrayTest {
public static void main(String[] args) {
//1.定义数组
int[] arr = {120,130,110,125,128,164};
//2.遍历数组,获取数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//3.判断元素>=130
if(arr[i]>=130){
//4.则打印元素
System.out.println(arr[i]);
}
}
}
}
2.2 数组中元素求和
需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的总体重。
/*
常见操作二：求和
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的总体重。
分析:
1.定义一个数组
2.定义一个int类型的变量,初始值为0,记录累加求和
3.遍历数组,获取每一个元素
4.累加求和
5.遍历结束,打印求和结果
*/
public class Demo02ArrayTest {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {120,130,110,125,128,164};
//2.定义一个int类型的变量,初始值为0,记录累加求和
int sum = 0;
//3.遍历数组,获取每一个元素
for (int i = 0; i < arr.length; i++) {
//4.累加求和
sum+=arr[i];
}
//5.遍历结束,打印求和结果
System.out.println("sum:"+sum);
}
}
2.3 数组中元素求平均值
需求:有以下数组，存储了6名学员的体重： int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的平均体重。
/*
常见操作三：求平均值
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的平均体重。
分析:
1.定义一个数组
2.定义一个int类型的变量,初始值为0,记录累加求和
3.遍历数组,获取每一个元素
4.累加求和
5.遍历结束,使用和/数组的长度,计算平均值
6.打印平均值
*/
public class Demo03ArrayTest {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {120,130,110,125,128,164};
//2.定义一个int类型的变量,初始值为0,记录累加求和
int sum = 0;
//3.遍历数组,获取每一个元素
for (int i = 0; i < arr.length; i++) {
//4.累加求和
sum+=arr[i];
}
//5.遍历结束,使用和/数组的长度,计算平均值
int avg = sum/arr.length;
//6.打印平均值
System.out.println("平均体重为:"+avg);
}
}
2.4 求数组中元素的最大值
需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的最大体重。
/*
常见操作四：求最大值
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的最大体重。
分析:
1.定义一个数组
2.定义一个变量max,把数组的第一个元素赋值给max,最为最大值
3.遍历数组,获取数组中的其他元素
4.使用遍历得到的元素和最大值比较
5.元素>最大值,则把元素赋值给最大值max
6.遍历结束,打印最大值
*/
public class Demo04ArrayTest {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {120,130,110,125,128,164};
//2.定义一个变量max,把数组的第一个元素赋值给max,最为最大值
int max = arr[0];
//3.遍历数组,获取数组中的其他元素
for (int i = 1; i < arr.length; i++) {
//4.使用遍历得到的元素和最大值比较
if(arr[i]>max){
//5.元素>最大值,则把元素赋值给最大值max
max = arr[i];
}
}
//6.遍历结束,打印最大值
System.out.println("max:"+max);
/*
常见操作四：求最小值
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的最小体重。
*/
//2.定义一个变量min,把数组的第一个元素赋值给min,最为最小值
int min = arr[0];
//3.遍历数组,获取数组中的其他元素
for (int i = 1; i < arr.length; i++) {
//4.使用遍历得到的元素和最小值比较
if(arr[i]<min){
//5.元素<最小值,则把元素赋值给最小值min
min = arr[i];
}
}
//6.遍历结束,打印最小值
System.out.println("min:"+min);
}
}
2.5统计符合条件元素的个数
需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印：大于、等于130的元素的个数。
/*
常见操作五：统计
有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印：大于、等于130的元素的个数。
分析:
1.定义一个数组
2.定义一个统计变量,初始值为0
3.遍历数组,获取数组中的每一个元素
4.判断元素是否大于等于130
5.是则统计变量++
6.循环结束,打印统计的个数
*/
public class Demo05ArrayTest {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {120,130,110,125,128,164};
//2.定义一个统计变量,初始值为0
int count = 0;
//3.遍历数组,获取数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//4.判断元素是否大于等于130
if(arr[i]>=130){
//5.是则统计变量++
count++;
}
}
//6.循环结束,打印统计的个数
System.out.println("count:"+count);
}
}
2.6 从控制台接收数据
需求:有以下数组：int[] arr = new int[5];请编程从控制台接收5名学员的年龄，并存储到数组中。遍历数组，打印每个年龄值。
import java.util.Scanner;
/*
常见操作六：从控制台接收数据
有以下数组：int[] arr = new int[5];
请编程从控制台接收5名学员的年龄，并存储到数组中。
遍历数组，打印每个年龄值。
分析:
1.定义一个int类型长度为5的数组
2.创建Scanner对象,为Scanner变量赋值
3.遍历数组,获取数组中的每一个元素
4.使用Scanner类中的方法nextInt,获取用户键盘输入年龄
5.把年龄赋值给元素
6.再一次遍历数组,打印年龄
*/
public class Demo06ArrayTest {
public static void main(String[] args) {
//1.定义一个int类型长度为5的数组
int[] arr = new int[5];
//2.创建Scanner对象,为Scanner变量赋值
Scanner sc = new Scanner(System.in);
//3.遍历数组,获取数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//4.使用Scanner类中的方法nextInt,获取用户键盘输入年龄
System.out.println("请输入第"+(i+1)+"学生的年龄:");
int age = sc.nextInt();
//5.把年龄赋值给元素
arr[i] = age;
}
//6.再一次遍历数组,打印年龄
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2.7 随机数填充数组
需求:有以下数组：int[] arr = new int[5];请编程随机生成5个1—100的整数，并存储到数组中。遍历数组，打印每个值。
import java.util.Random;
/*
常见操作七：随机数填充数组
有以下数组：int[] arr = new int[5];
请编程随机生成5个1—100的整数，并存储到数组中。
遍历数组，打印每个值。
分析:
1.定义一个int类型长度为5的数组
2.创建Random对象,为Random类型的变量赋值
3.遍历数组,获取每一个元素
4.使用Random对象中的方法nextInt,随机获取5个1-100之间的数,给元素赋值
5.再次遍历数组,获取每一个元素
*/
public class Demo07ArrayTest {
public static void main(String[] args) {
//1.定义一个int类型长度为5的数组
int[] arr = new int[5];
//2.创建Random对象,为Random类型的变量赋值
Random r = new Random();
//3.遍历数组,获取每一个元素
for (int i = 0; i < arr.length; i++) {
//4.使用Random对象中的方法nextInt,随机获取5个1-100之间的数,给元素赋值
arr[i] = r.nextInt(100)+1;
}
//5.再次遍历数组,获取每一个元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
三、数组综合案例
3.1 综合案例1-成绩分析系统
需求: 分析学员的成绩，计算：平均分、最高分、最低分，现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。
/*
综合案例1-成绩分析系统
分析学员的成绩，计算：平均分、最高分、最低分
现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。
分析:
1.定义一个数组,存储10个同学的数学成绩
2.定义一个变量sum,初始值为0,记录累加求和
3.定义一个变量max,把数组的第一个元素赋值给max,最为最高分
4.定义一个变量min,把数组的第一个元素赋值给min,最为最低分
5.遍历数组,获取数组中的每一个元素
6.使用sum和元素进行累加求和
7.元素>max,max=元素
8.元素<min,min=元素
9.循环结束之后,根据求和sum,计算平均值
10.打印平均分、最高分、最低分
*/
public class Demo01Test {
public static void main(String[] args) {
//1.定义一个数组,存储10个同学的数学成绩
int[] arr = {100,99,88,98,76,59,100,95,98,2};
//2.定义一个变量sum,初始值为0,记录累加求和
int sum = 0;
//3.定义一个变量max,把数组的第一个元素赋值给max,最为最高分
int max = arr[0];
//4.定义一个变量min,把数组的第一个元素赋值给min,最为最低分
int min = arr[0];
//5.遍历数组,获取数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//6.使用sum和元素进行累加求和
sum+=arr[i];
//7.元素>max,max=元素
if(arr[i]>max){
max = arr[i];
}
//8.元素<min,min=元素
if(arr[i]<min){
min = arr[i];
}
}
//9.循环结束之后,根据求和sum,计算平均值
double avg = sum/(double)arr.length;
//10.打印平均分、最高分、最低分
System.out.println("平均分为:"+avg);
System.out.println("最高分为:"+max);
System.out.println("最低分为:"+min);
}
}
3.2 综合案例2-双色球开奖核心算法
1、出奖号码由6个红球 + 1蓝球组成
2、每个红球是1—33之间的一个数字
3、蓝球是1—16之间的一个数字
4、本题目咱时不考虑：重复、红球排序的问题
import java.util.Random;
/*
综合案例2-双色球开奖核心算法
1、出奖号码由6个红球 + 1蓝球组成
2、每个红球是1—33之间的一个数字
3、蓝球是1—16之间的一个数字
4、本题目咱时不考虑：重复、红球排序的问题
分析:
1.定义一个长度为6的int类型数组,用来存储红球
2.创建Random对象
3.遍历数组,获取数组中每一个元素
4.使用Random获取6个1-33之间的随机数,依次赋值给数组中的元素
6.定义一个变量,使用Random获取1个1-16之间的随机数,给变量赋值
7.遍历数组,打印红球,打印篮球
*/
public class Demo02Test {
public static void main(String[] args) {
//1.定义一个长度为6的int类型数组,用来存储红球
int[] arr = new int[6];
//2.创建Random对象
Random r = new Random();
//3.遍历数组,获取数组中每一个元素
for (int i = 0; i < arr.length; i++) {
//4.使用Random获取6个1-33之间的随机数,依次赋值给数组中的元素
arr[i] = r.nextInt(33)+1;
}
//6.定义一个变量,使用Random获取1个1-16之间的随机数,给变量赋值
int blue = r.nextInt(16)+1;
//7.遍历数组,打印红球,打印篮球
System.out.print("红球:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println("蓝球:"+blue);
}
}
3.3综合案例3-盗墓解密程序
有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；两个小偷在找到墓地后于是就开始研究规则
规则为：一串数字无论正着读还是反着读都是一样的。如：1234321 是有效的；345643 是无效的。请你编程实现该程序的判断。
/*
综合案例3-盗墓解密程序
有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；
两个小偷在找到墓地后于是就开始研究规则
规则为：一串数字无论正着读还是反着读都是一样的。
如：1234321 是有效的；345643 是无效的。
请你编程实现该程序的判断。
分析:
1.定义一个数组,存储小偷输入的密码
2.定义一个布尔类型的变量,初始值为true,作为一个标记,用于判断是否解密成功
3.遍历数组,获取每一个元素
4.在循环中依次比较首尾元素是否相同
5.首尾元素不相同,修改为false,结束循环
6.循环结束了,对布尔值进行判断
true:解密成功
false:解密失败
*/
public class Demo03Test {
public static void main(String[] args) {
//1.定义一个数组,存储小偷输入的密码
int[] arr = {5,4,3,2,1,2,3,4,5};
//2.定义一个布尔类型的变量,初始值为true,作为一个标记,用于判断是否解密成功
boolean flag = true;
//3.遍历数组,获取每一个元素
for (int i = 0; i < arr.length/2; i++) {
//4.在循环中依次比较首尾元素是否相同
if(arr[i]!=arr[arr.length-1-i]){
//5.首尾元素不相同,修改为false,结束循环
flag = false;
break;
}
}
//6.循环结束了,对布尔值进行判断
if(flag==true){
//true:解密成功
System.out.println("恭喜您,解密成功,可以打开墓门了!");
}else{
//false:解密失败
System.out.println("恭喜您,解密失败,陵墓马上就要销毁!");
}
}
}
后记
喜欢我的文章的朋友点点喜欢、收藏，也欢迎朋友们评论区留下你的意见和建议，恕毅在此拜谢！
