/*
数组概念:
java中用来存储多个数据的大容器
特点:
1.可以存储多个数据
2.多个数据的类型必须保持一致
3.数组长度是永远不可以发生改变的
数组变量的定义格式
1.数组变量定义格式一： 推荐使用
数据类型[] 数组名称;
2.数组变量定义格式二： 不推荐使用的
数据类型 数组名称[];
3.练习:
(1)定义一个存储int类型数组的变量arrayA
(2)定义一个存储double类型数组的变量arrayB
(3)定义一个存储char类型数组的变量arrayC
4.关于 int[] arrayA的理解:
(1)这里只是定义一个可以存储一个int数组容器的变量,但是没有向该变量中存储数组容器
(2)相当于教室的门牌号,但是该门牌号并没有对应的教室
*/
public class Demo02ArrayVar {
public static void main(String[] args) {
//(1)定义一个存储int类型数组的变量arrayA
//这里是定义一个变量,只不过该变量是用来存储一个数组容器的,数组容器中都是int数据
int[] arrayA;
//上面只是定义一个存储数组容器的变量,但是没有存储真正的数组容器,
//变量中没有值,是不能用的
//System.out.println(arrayA);
//int arrayA[];
//(2)定义一个存储double类型数组的变量arrayB
//这里是定义一个变量,只不过该变量是用来存储一个数组容器的,数组容器中都是double数据
double[] arrayB;
//(3)定义一个存储char类型数组的变量arrayC
//这里是定义一个变量,只不过该变量是用来存储一个数组容器的,数组容器中都是char数据
char[] arrayC;
}
}
/*
数组的第一种初始化方式(动态初始化: 指定数组长度)
1.格式:
数据类型[] 数组名称 = new 数据类型[长度];
2.格式解释:
(1)左侧数据类型: 表示该数组容器中可以存储什么类型的数据
(2)左侧[]: 代表数组的意思
(3)数组名称: 就是一个标识符,方便使用数组
(4)=: 表示赋值的意思,把=号右侧的数组容器在内存中的地址值,赋值给=号左侧的数组变量
(5)new: JVM在内部创建数组的过程
(6)右侧数据类型: 和左侧保持一致
(7)长度(必须是int类型): 规定了数组容器中可以存储多少个数据
3.练习:
(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC
*/
public class Demo03ArrayInit {
public static void main(String[] args) {
//(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
int[] arrayA = new int[3];
//(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
double[] arrayB = new double[7];
//(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC
char[] arrayC = new char[5];
}
}
/*
数组的第二种初始化方式(标准格式静态初始化: 指定元素)
1.格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...,元素n};
2.注意:
(1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
(2)右侧[]中不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
3.练习:
(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
*/
public class Demo04ArrayInit {
public static void main(String[] args) {
//(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
int[] arrayA = new int[]{100, 200, 300};
//(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
double[] arrayB = new double[]{1.1, 2.2, 3.3, 4.4};
//(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
char[] arrayC = new char[]{'真', '的', '好', '想', '你'};
}
}
/*
数组的第三种初始化方式(简化格式静态初始化: 指定元素)
1.格式:
数据类型[] 数组名称 = {元素1,元素2,...,元素n};
2.练习:
(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
3.注意:
(1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
(2)不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
(3)虽然没有写new,但是底层仍然有new的过程,完成数组的创建
(4)动态初始化和标准格式的静态初始化数组,可以分成两步完成
(5)简化格式静态初始化,只能一步完成,不可以分成两步(java中的用法规定)
*/
public class Demo05ArrayInit {
public static void main(String[] args) {
//(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
int[] arrayA = {100, 200, 300};
//(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
double[] arrayB = {1.1, 2.2, 3.3, 4.4};
//(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
char[] arrayC = {'真', '的', '好', '想', '你'};
int[] array;//定义int类型数组变量
array = new int[3];//正确: 动态初始化可以分成两步完成
array = new int[]{10, 20, 30, 50};//正确: 标准格式静态初始化可以分成两步完成
//array = {100, 200, 300};//错误: java中规定,简化格式静态初始化,不能分成两步完成
}
}
/*
数组的使用:
1.数组名称: 代表数组在内存空间中的地址值,是一个十六进制的int数字
2.索引编号:
(1)数组中的每个数据,称为数组元素
(2)数组为其内部的每个元素进行编号,专业术语叫做索引(角标),从0开始到数组长度减1
(3)索引编号必须是一个>=0的int数据
3.数组元素的访问:
数组名称[索引编号];
array[0]: 代表数组array中索引编号为0的元素
array[2]: 代表数组array中索引编号为2的元素
4.获取数组长度(数组中可以存储元素的个数)
每个数组内部都有一个length属性,其实就是一个int变量,记录了该数组中可以存储的元素的数量
使用格式:
数组名称.length: 获取数组长度,其实一个int数字
注意:
length后面没有(),添加()是错误的
*/
public class Demo02UseArray {
public static void main(String[] args) {
//定义int数组array,并采用标准格式静态初始化
//100的索引编号是0,200的索引编号是1,300的索引编号是2
int[] array = new int[]{100, 200, 300};
System.out.println(array);//数组变量名: 保存数组内存地址值 [I@1540e19d
//输出100
System.out.println(array[0]);//输出数组array中索引为0的元素值:100
//输出200
System.out.println(array[1]);//输出数组array中索引为1的元素值:200
//输出300
System.out.println(array[2]);//输出数组array中索引为2的元素值:300
System.out.println("----------");
//把100修改成1000
array[0] = 1000;//把int数字1000存储到数组array中索引为0的元素中
//把200修改成2000
array[1] = 2000;//把int数字2000存储到数组array中索引为1的元素中
//把300修改成3000
array[2] = 3000;//把int数字3000存储到数组array中索引为2的元素中
//输出1000
System.out.println(array[0]);//输出数组array中索引为0的元素值:1000
//输出2000
System.out.println(array[1]);//输出数组array中索引为1的元素值:2000
//输出3000
System.out.println(array[2]);//输出数组array中索引为2的元素值:3000
//获取数组元素个数(长度)
int count = array.length;
System.out.println("数组中元素个数: " + count);//3
System.out.println("数组中元素个数: " + array.length);//3
System.out.println("数组中元素最大索引: " + (count - 1));//2
System.out.println("数组中元素最大索引: " + (array.length - 1));//2
System.out.println("数组最大索引对应的元素值: " + array[count - 1]);//3000
System.out.println("数组最大索引对应的元素值: " + array[array.length - 1]);//3000
/*
array[array.length - 1]: 表示获取数组元素,[]中是一个索引
先计算[]中的索引值: array.length - 1 --> 长度 - 1 --> 3 - 1 --> 2
再计算array[2]: 3000
*/
System.out.println(array[array.length - 1]);
}
}
/*
数组遍历：
就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
注意for循环的结束条件的两种写法:
<=array.length - 1
<array.length
快捷键:
数组名称.fori: 正着遍历
数组名称.forr: 倒着遍历
*/
public class Demo03EachArray {
public static void main(String[] args) {
//定义int数组array,并采用简化格式初始化
int[] array = {100, 200, 300};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println("---------");
/*
问题:
以上代码重复,只有表示索引的0,1,2数字不同
优化:
使用for循环获取表示索引的0,1,2数字
*/
for (int i = 0; i < 3; i++) {
System.out.println(array[i]);
}
System.out.println("---------");
/*
问题:
以上代码for循环中,表示长度的数字3写死了
优化:
获取数组的长度 数组名称.length
*/
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("---------");
for (int i = 0; i <= array.length - 1; i++) {
System.out.println(array[i]);
}
}
}
/*
需求:
计算一个int数组的元素之和
实现步骤:
1.创建int数组array,并初始化
2.定义int变量sum,初始值0,用来累加求和
3.使用for循环遍历int数组array
4.循环内部把当前元素累加到求和变量sum中
5.循环结束后,输出求和结果sum
*/
public class Demo04SumArray {
public static void main(String[] args) {
//1.创建int数组array,并初始化
int[] array = {100, 200, 300, 400};
//2.定义int变量sum,初始值0,用来累加求和
int sum = 0;
//3.使用for循环遍历int数组array
for (int i = 0; i < array.length; i++) {
//4.循环内部把当前元素累加到求和变量sum中
sum = sum + array[i];
}
//5.循环结束后,输出求和结果sum
System.out.println("数组元素和: " + sum);
//6.计算平局值(不考虑小数部分)
int avg = sum / array.length;
System.out.println("数组元素平均值: " + avg);
}
}
/*
扩展练习:
有个int数组,内部存储元素 8,5,7,13,16,10,11,18,30,15,17
要求:
1.打印所有的偶数数字
2.打印所有的偶数数字之和
3.打印所有的偶数数字的个数
实现步骤:
1.创建int数组array,并初始化
2.定义int变量sum,初始值0,用来求数组偶数元素之和
3.定义int变量count,初始值0,用来统计数组偶数元素个数
4.使用for循环变量int数组array
4.1 循环内部判断如果当前元素是偶数
4.2 输出当前偶数元素
4.3 把当前偶数元素累加到求和变量sum中
4.4 计数器count的值增加1
5.for循环结束后输出结果数据
*/
public class Demo05SumOuArray {
public static void main(String[] args) {
//1.创建int数组array,并初始化
int[] array = {8, 5, 7, 13, 16, 10, 11, 18, 30, 15, 17};
//2.定义int变量sum,初始值0,用来求数组偶数元素之和
int sum = 0;
//3.定义int变量count,初始值0,用来统计数组偶数元素个数
int count = 0;
//4.使用for循环变量int数组array
for (int i = 0; i < array.length; i++) {
//4.1 循环内部判断如果当前元素是偶数
if (array[i] % 2 == 0) {
//4.2 输出当前偶数元素
System.out.println(array[i]);
//4.3 把当前偶数元素累加到求和变量sum中
sum = sum + array[i];//sum += array[i];
//4.4 计数器count的值增加1
count++;
}
}
//5.for循环结束后输出结果数据
System.out.println("以上偶数元素个数: " + count);
System.out.println("以上偶数元素之和: " + sum);
}
}
/*
扩展练习:
有个int数组,内部存储元素 8,5,7,13,16,10,11,18,30,15,17
要求:
1.打印所有的偶数数字
2.打印所有的偶数数字之和
3.打印所有的偶数数字的个数
实现步骤:
1.创建int数组array,并初始化
2.定义int变量sum,初始值0,用来求数组偶数元素之和
3.定义int变量count,初始值0,用来统计数组偶数元素个数
4.使用for循环变量int数组array
4.1 循环内部判断如果当前元素是偶数
4.2 输出当前偶数元素
4.3 把当前偶数元素累加到求和变量sum中
4.4 计数器count的值增加1
5.for循环结束后输出结果数据
*/
public class Demo06SumOuArray {
public static void main(String[] args) {
//1.创建int数组array,并初始化
int[] array = {8, 5, 7, 13, 16, 10, 11, 18, 30, 15, 17};
//2.定义int变量sum,初始值0,用来求数组偶数元素之和
int sum = 0;
//3.定义int变量count,初始值0,用来统计数组偶数元素个数
int count = 0;
//4.使用for循环变量int数组array
for (int i = 0; i < array.length; i++) {
//获取当前元素,保存int变量num中
int num = array[i];
//4.1 循环内部判断如果当前元素是偶数
if (num % 2 == 0) {
//4.2 输出当前偶数元素
System.out.println(num);
//4.3 把当前偶数元素累加到求和变量sum中
sum = sum + num;//sum += array[i];
//4.4 计数器count的值增加1
count++;
}
}
//5.for循环结束后输出结果数据
System.out.println("以上偶数元素个数: " + count);
System.out.println("以上偶数元素之和: " + sum);
}
}
/*
需求:
求三个int数字的最大值
实现步骤:
1.定义3个int变量a,b,c,并分别初始化
2.假设变量a是最大的,保存int变量max中
3.判断如果b的值大于max,说明max中不是最大的了,把b的值赋值给max
4.判断如果c的值大于max,说明max中不是最大的了,把c的值赋值给max
5.输出结果数据max
*/
public class Demo07VarMax {
public static void main(String[] args) {
//1.定义3个int变量a,b,c,并分别初始化
int a = 100, b = 200, c = 300;
//2.假设变量a是最大的,保存int变量max中
int max = a;
//3.判断如果b的值大于max,说明max中不是最大的了,把b的值赋值给max
if (b > max) {
max = b;
}
//4.判断如果c的值大于max,说明max中不是最大的了,把c的值赋值给max
if (c > max) {
max = c;
}
//5.输出结果数据max
System.out.println(a + ", " + b + ", " + c + " 三个数字的最大值: " + max);
}
}
/*
需求:
求int数组元素最大值
实现步骤:
1.定义int数组array,并根据题目需求进行初始化
2.假设索引为0的元素是最大的,保存到int变量max中
3.使用for循环依次获取后面(从索引1开始)的每个元素
3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
3.2 把当前元素值,赋值给max
4.for循环结束后,打印max的值
注意:
1.求数组最大值/最小值/求和/计数,这些变量必须在for循环的前面定义
2.for循环内部完成计算
3.for循环的后面进行打印输出
自己完成最小值
*/
public class Demo08MaxArray {
public static void main(String[] args) {
//1.定义int数组array,并根据题目需求进行初始化
int[] array = {5, 15, 2000, 10000, 100, 4000};
//2.假设索引为0的元素是最大的,保存到int变量max中
int max = array[0];//第一个元素是最大的
//3.使用for循环依次获取后面(从索引1开始)的每个元素
for (int i = 1; i < array.length; i++) {
//3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
if (array[i] > max) {
//3.2 把当前元素值,赋值给max
max = array[i];
}
}
//4.for循环结束后,打印max的值
System.out.println("最大值: " + max);
}
}
/*
一个数组内存图
1.动态初始化数组,元素有默认值
(1)基本类型
整数数组: 0
小数数组: 0.0
布尔数组: false
字符数组: 空白字符
(2)引用类型
所有引用类型数组: null
2.注意
(1)数组变量保存数组在堆内存空间的地址值
(2)通过数组变量中保存的地址值,找到堆内存空间的具体的数组
(3)再通过索引编号,找到要操作的该数组中的具体的某个元素
*/
public class Demo03OneArray {
public static void main(String[] args) {
//创建一个长度为3的int数组array,采用动态初始化的方式
int[] array = new int[3];
System.out.println(array);//数组名代表数组在堆内存中的地址,是一个16进制int数字: [I@1540e19d
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
System.out.println("---------");
//给数组元素赋值
array[0] = 100;
array[1] = 200;
array[2] = 300;
System.out.println(array[0]);//100
System.out.println(array[1]);//200
System.out.println(array[2]);//300
}
}
/*
数组操作的常见问题一:
数组索引越界(超出了范围)异常
1.问题描述:
java中使用java.lang.ArrayIndexOutOfBoundsException类用来描述索引越界问题的
2.产生原因:
当使用int数字作为索引获取数组元素时,索引值已经超出了数组的索引范围,
无法获取该索引对应的元素
(1)打印异常信息
(2)停止程序的执行
3.解决方案:
(1)不使用超出索引范围的int数字来获取数组元素
(2)修改索引越界的数字,让它在数组索引范围内
*/
public class Demo04ArrayProblem {
public static void main(String[] args) {
int[] array = {100, 200, 300};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
/*
代码报错:
java.lang.ArrayIndexOutOfBoundsException类: 描述数组索引越界异常
原因:
数字3作为索引在数组中是不存在的
JVM默认的处理方案:
1.打印出错误(异常)信息,方便程序员修改错误(异常/问题)
2.停止程序的执行
解决方案:
1.不使用超出范围的数字作为索引
2.修改超出范围的数字,让该数字在合理的索引范围内容
*/
System.out.println(array[3]);
System.out.println("game...over...");
}
}
/*
数组操作的常见问题二:
空指针异常
1.问题描述:
java中使用java.lang.NullPointerException类,来描述空指针异常
2.产生原因:
null是引用类型的空常量,可以给任意引用类型的变量赋值,但是一旦引用变量的值是null时,
说明该引用变量已经不再执行堆内存的任何空间,也就不能范围堆内存空间中的元素了
数组变量的值是null时,说明该数组变量已经不再执行堆内存空间的任何数组了,
所以就无法通过索引的方式访问数组元素了,只要访问,就会报出空指针异常
(1)打印异常信息
(2)停止程序的执行
3.解决方案:
(1)不使用值是null的数组变量来获取数组元素
(2)找到数组变量值是null的地方,给数组变量重新赋值,让改数组变量重新指向一个新的数组空间
*/
public class Demo05ArrayProblem {
public static void main(String[] args) {
int[] array = {100, 200, 300};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
/*
null是引用类型空常量,可以给任意引用类型变量赋值
数组变量也是引用变量,但是一旦数组变量被赋值为null,
说明该数组变量不再指向堆内存中的任何数组,
就不能通过该数组变量访问数组元素了,只要访问就会报出空指针异常
*/
array = null;
System.out.println(array);//null
/*
代码报错:
java.lang.NullPointerException类: 描述空指针异常
原因:
数组变量值是null,说明不再指向堆内存中的任何数组,不能访问数组元素,只要访问报出空指针异常
JVM默认的处理方案:
1.打印出错误(异常)信息,方便程序员修改错误(异常/问题)
2.停止程序的执行
解决方案:
1.不使用值为null数组变量访问数组元素
2.给值为null的数组变量重新赋值一个新数组
*/
//array = new int[]{10, 20, 30, 50};
System.out.println(array[0]);
System.out.println("game...over...");
}
}
/*
break的作用:
1.可以使用在循环和switch语句中,其它位置不可用
2.break是用来结束所在的循环的
(1)一旦执行break,本次循环的循环体的后续代码不再执行
(2)一旦执行break,剩余次数的循环也不再执行
(3)相当于从执行break的位置,直接跳转到break所在的循环的后面执行
*/
public class Demo04Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
/*
i的值是5时,if后面()中的表达式i % 5 == 0的结果是true,
就会执行if后面{}中的break,一旦执行break,直接结束所在的for循环,
执行for循环后面的其它语句
1.本次循环break后面的代码不再执行
2.剩余次数的循环也不再执行
*/
if (i % 5 == 0) {
break;
}
System.out.println("HelloWorld....." + i);
}
System.out.println("main....end....");
}
}
/*
continue的作用:
1.提前结束本次循环,继续进行下一次循环
2.continue只影响本次循环,break影响所有循环
3.continue只能使用在循环语句中
*/
public class Demo05Continue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
/*
i的值是5和10的时候,if后面表达式i % 5 == 0的结果为true,
就会执行if后面{}中的代码continue,提前结束本次循环,
继续进行下一次循环
特点:
跳过循环体中continue后面的代码,直接执行的步进表达式
*/
if (i % 5 == 0) {
continue;
}
System.out.println("HelloWorld....." + i);
}
System.out.println("main....end....");
}
}
/*
输出[1,100]之间的数字,满足逢七过规则的数字跳过
数字包含7或者是7的倍数:
包含7: 个位是7 或者 十位是7
7的倍数: 数字%7 == 0
实现步骤:
1.使用for循环获取1到100之间的数字
2.循环内部判断如果满足逢七过规则 不输出
3.循环内部判断如果不满足逢七过规则 输出该数字
*/
public class Demo06FQG {
public static void main(String[] args) {
//1.使用for循环获取1到100之间的数字
for (int num = 1; num <= 100; num++) {
int ge = num % 10;//个位
int shi = num / 10 % 10;//十位
//2.循环内部判断如果满足逢七过规则 不输出
if ((ge == 7 || shi == 7) || (num % 7 == 0)) {
System.out.println("过");
continue;
}
//3.循环内部判断如果不满足逢七过规则 输出该数字
System.out.println(num);
}
}
}
/*
输出[1,100]之间的数字,满足逢七过规则的数字跳过
数字包含7或者是7的倍数:
包含7: 个位是7 或者 十位是7
7的倍数: 数字%7 == 0
实现步骤:
1.使用for循环获取1到100之间的数字
2.循环内部判断如果满足逢七过规则 不输出
3.循环内部判断如果不满足逢七过规则 输出该数字
*/
public class Demo07FQG {
public static void main(String[] args) {
//1.使用for循环获取1到100之间的数字
for (int num = 1; num <= 100; num++) {
int ge = num % 10;//个位
int shi = num / 10 % 10;//十位
//2.循环内部判断如果不满足逢七过规则 输出该数字
if (!((ge == 7 || shi == 7) || (num % 7 == 0))) {
System.out.println(num);
}
}
}
}
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
