Java基础学习2:【流程控制语句、数组】

  • A+
所属分类:Java Java基础

第三节【流程控制语句】

第一章 流程控制

1.1 概述

在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。也就是说,程序的流程对运行结果 有直接的影响。所以,我们必须清楚每条语句的执行流程。而且,很多时候我们要通过控制语句的执行顺序来实现 我们要完成的功能。

1.2 顺序结构

public static void main(String[] args){
//顺序执行,根据编写的顺序,从上到下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
}

第二章 判断语句

2.1 判断语句1–if

  • if语句第一种格式: if
if(关系表达式){
    语句体;
}
  • 执行流程
    • 首先判断关系表达式看其结果是true还是false
    • 如果是true就执行语句体
    • 如果是false就不执行语句体

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args){
System.out.println("开始");
// 定义两个变量
int a = 10;
int b = 20;
//变量使用if判断
if (a == b){
System.out.println("a等于b");
}
int c = 10;
if(a == c){
System.out.println("a等于c");
}
System.out.println("结束");
}

2.2 判断语句2–if…else

  • if语句第二种格式: if…else
if(关系表达式) {
   语句体1;
}else {
   语句体2;
}
  • 执行流程
    • 首先判断关系表达式看其结果是true还是false
    • 如果是true就执行语句体1
    • 如果是false就执行语句体2

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args){
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 1;
if(a % 2 == 0) {
System.out.println("a是偶数");
} else{
System.out.println("a是奇数");
}
System.out.println("结束");
}

2.3 判断语句3–if..else if…else

  • if语句第三种格式: if…else if …else
if (判断条件1) {
执行语句1;
} else if (判断条件2) {
执行语句2;
}
...
}else if (判断条件n) {
执行语句n;
} else {
执行语句n+1;
}
  • 执行流程
    • 首先判断关系表达式1看其结果是true还是false
    • 如果是true就执行语句体1
    • 如果是false就继续判断关系表达式2看其结果是true还是false
    • 如果是true就执行语句体2
    • 如果是false就继续判断关系表达式…看其结果是true还是false
    • 如果没有任何关系表达式为true,就执行语句体n+1。

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args) {
//比较两个数字的大小
int x = 3;
int y = 4;
if (x > y) {
System.out.println(x + "大于" + y);
} else if (x < y) {
System.out.println(x + "小于" + y);
} else {
System.out.println(x + "等于" + y);
}
}

2.4 语句练习

  • 指定考试成绩,判断学生等级
    • 90-100 优秀
    • 80-89 好
    • 70-79 良
    • 60-69 及格
    • 60以下 不及格
public static void main(String[] args) {
int score = 100;
if(score<0 || score>100){
System.out.println("你的成绩是错误的");
}else if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
}}
  • 根据x的取值 , 输出y的值
    • x <= 0 时 , y = x
    • 0 < x <= 10 时 , y = 2 * x
    • x > 10 时 , y = 3 * x
public static void main(String[] args) {
// 根据给定的x的值,计算出y的值并输出。
// 定义变量
int x = 11;
int y;
if (x <= 0) {
y = x;
} else if (x > 0 && x <= 10) {
y = 2 * x;
} else {
y = 3 * x;
}
System.out.println("y的值是:" + y);
}

2.5 if语句和三元运算符的互换

在某些简单的应用中,if语句是可以和三元运算符互换使用的。

public static void main(String[] args) {
int a = 10;
int b = 20;
//定义变量,保存a和b的较大值
int c;
if(a > b) {
c = a;
} else {
c = b;
}
//可以上述功能改写为三元运算符形式
c = a > b ? a:b;
}

第三章 选择语句

3.1 选择语句–switch

  • switch语句格式
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
  • 执行流程
    • 首先计算出表达式的值
    • 其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结 束。
    • 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args) {
//定义变量,判断是星期几
int weekday = 6;
//switch语句实现选择
switch(weekday) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}

switch语句中,表达式的数据类型,可以是byte,short,int,char,enum(枚举),JDK7后可以接收字符串。

3.2 case的穿透性

在switch语句中,如果case的后面不写break,将出现穿透现象,也就是不会在判断下一个case的值,直接向后运 行,直到遇到break,或者整体switch结束。

public static void main(String[] args) {
int i = 5;
switch (i){
case 0:
System.out.println("执行case0");
break;
case 5:
System.out.println("执行case5");
case 10:
System.out.println("执行case10");
default:
System.out.println("执行default");
}
}

上述程序中,执行case5后,由于没有break语句,程序会一直向后走,不会在判断case,也不会理会break,直接 运行完整体switch。 由于case存在穿透性,因此初学者在编写switch语句时,必须要写上break。

第四章 循环语句

4.1 循环概述

循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复 执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形 成死循环。

4.2 循环语句1–for

for循环语句格式:

for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
  • 执行流程
    • 执行顺序:①②③④>②③④>②③④…②不满足为止。
    • ①负责完成循环变量初始化
    • ②负责判断是否满足循环条件,不满足则跳出循环
    • ③具体执行的语句
    • ④循环后,循环条件所涉及变量的变化情况

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args) {
//控制台输出5次HelloWorld,不使用循环
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
//用循环改进,循环5次
//定义变量从0开始,循环条件为<5
for(int x = 0; x < 5; x++) {
System.out.println("HelloWorld"+x);
}
}
  • 循环练习:使用循环,计算1-100之间的偶数和
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,初始值为0
int sum = 0;
//2.利用for循环获取1‐100之间的数字
for (int i = 1; i <= 100; i++) {
//3.判断获取的数组是奇数还是偶数
if(i % 2==0){
//4.如果是偶数就累加求和
sum += i;
}
}
//5.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}

4.3 循环语句2–while

while循环语句格式:

初始化表达式①
while(布尔表达式②){
循环体③
步进表达式④
}
  • 执行流程
    • 执行顺序:①②③④>②③④>②③④…②不满足为止。
    • ①负责完成循环变量初始化。
    • ②负责判断是否满足循环条件,不满足则跳出循环。
    • ③具体执行的语句。
    • ④循环后,循环变量的变化情况。

Java基础学习2:【流程控制语句、数组】

while循环输出10次HelloWorld:
public static void main(String[] args) {
//while循环实现打印10次HelloWorld
//定义初始化变量
int i = 1;
//循环条件<=10
while(i<=10){
System.out.println("HelloWorld");
//步进
i++;
}
}

while循环计算1-100之间的和:
public static void main(String[] args) {
//使用while循环实现
//定义一个变量,记录累加求和
int sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1‐100的和是:"+sum);
}

4.4 循环语句3–do…while

do…while循环格式

初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②);
  • 执行流程
    • 执行顺序:①③④>②③④>②③④…②不满足为止。
    • ①负责完成循环变量初始化。
    • ②负责判断是否满足循环条件,不满足则跳出循环。
    • ③具体执行的语句
    • ④循环后,循环变量的变化情况

Java基础学习2:【流程控制语句、数组】

输出10次HelloWorld

public static void main(String[] args) {
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}

do…while循环的特点:无条件执行一次循环体,即使我们将循环条件直接写成false,也依然会循环一次。这样的 循环具有一定的风险性,因此初学者不建议使用do…while循环。

public static void main(String[] args){
do{
System.out.println("无条件执行一次");
}while(false);
}

4.5 循环语句的区别

  • for 和 while 的小区别:
    • 控制条件语句所控制的那个变量,在for循环结束后,就不能再被访问到了,而while循环结束还可以继 续使用,如果你想继续使用,就用while,否则推荐使用for。原因是for循环结束,该变量就从内存中消 失,能够提高内存的使用效率。
    • 在已知循环次数的时候使用推荐使用for,循环次数未知的时推荐使用while。

4.6 跳出语句

break

  • 使用场景:
    • 终止switch或者循环 在选择结构switch语句中
    • 在循环语句中
    • 离开使用场景的存在是没有意义的
public static void main(String[] args) {
for (int i = 1; i<=10; i++) {
//需求:打印完两次HelloWorld之后结束循环
if(i == 3){
break;
}
System.out.println("HelloWorld"+i);
}
}

continue

  • 使用场景:结束本次循环,继续下一次的循环
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}

第五章 扩展知识点

5.1 死循环

  • 死循环:也就是循环中的条件永远为true,死循环的是永不结束的循环。例如:while(true){}。在后期的开发中,会出现使用死循环的场景,例如:我们需要读取用户输入的输入,但是用户输入多少数据我们并 不清楚,也只能使用死循环,当用户不想输入数据了,就可以结束循环了,如何去结束一个死循环呢,就需要使用 到跳出语句了。

5.2 嵌套循环

  • 所谓嵌套循环,是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环,就是嵌套循环。总 共的循环次数=外循环次数*内循环次数
  • 嵌套循环格式
for(初始化表达式①; 循环条件②; 步进表达式⑦) {
for(初始化表达式③; 循环条件④; 步进表达式⑥) {
执行语句⑤;
}
}
  • 嵌套循环执行流程:
    • 执行顺序:①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
    • 外循环一次,内循环多次。
    • 比如跳绳:一共跳5组,每组跳10个。5组就是外循环,10个就是内循环。
  • 练习:使用嵌套循环,打印5*8的矩形
public static void main(String[] args) {
//5*8的矩形,打印5行*号,每行8个
//外循环5次,内循环8次
for(int i = 0; i < 5; i++){
for(int j = 0; j < 8; j++){
//不换行打印星号
System.out.print("*");
}
//内循环打印8个星号后,需要一次换行
System.out.println();
}
}

第四节【IDEA、方法】

展开

第一章 开发工具IntelliJ IDEA

注:见我另一篇教程(开发工具IntelliJ IDEA 的安装和使用

第二章 方法

2.1 回顾–方法的定义和调用

前面的课程中,使用过嵌套循环输出矩形,控制台打印出矩形就可以了,因此将方法定义为 void ,没有返回值。 在主方法 main 中直接被调用。

public class Method_Demo1 {
public static void main(String[] args) {
print();
}
private static void print() {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 8; j++) {
System.out.print("*");
}
System.out.println();
}
}
}

print方法被main方法调用后直接输出结果,而main方法并不需要print方法的执行结果,所以被定义为void。

2.2 定义方法的格式详解

修饰符 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
  • 修饰符: public static 目前固定写法
  • 返回值类型: 表示方法运行的结果的数据类型,方法执行后将结果返回到调用者
  • 参数列表:方法在运算过程中的未知数据,调用者调用方法时传递
  • return:将方法执行后的结果带给调用者,方法执行到 return ,整体方法运行结束

小贴士:return 结果; 这里的”结果”在开发中,我们正确的叫法成为方法的返回值

2.3 定义方法的两个明确

  • 需求:定义方法实现两个整数的求和计算。
    • 明确返回值类型:方法计算的是整数的求和,结果也必然是个整数,返回值类型定义为int类型。
    • 明确参数列表:计算哪两个整数的和,并不清楚,但可以确定是整数,参数列表可以定义两个int类型的 变量,由调用者调用方法时传递
public class Method_Demo2 {
public static void main(String[] args) {
// 调用方法getSum,传递两个整数,这里传递的实际数据又称为实际参数
// 并接收方法计算后的结果,返回值
int sum = getSum(5, 6);
System.out.println(sum);
}
/*
定义计算两个整数和的方法
返回值类型,计算结果是int
参数:不确定数据求和,定义int参数.参数又称为形式参数
*/
public static int getSum(int a, int b) {
return a + b;
}
}

程序执行,主方法 main 调用 getSum 方法,传递了实际数据 5和6 ,两个变量 a和b 接收到的就是实际参数,并 将计算后的结果返回,主方法 main 中的变量 sum 接收的就是方法的返回值。

2.4 调用方法的流程图解

Java基础学习2:【流程控制语句、数组】

2.5 定义方法练习

练习一

比较两个整数是否相同

  • 分析:定义方法实现功能,需要有两个明确,即 返回值 和 参数列表 。
    • 明确返回值:比较整数,比较的结果只有两种可能,相同或不同,因此结果是布尔类型,比较的结果相 同为true。
    • 明确参数列表:比较的两个整数不确定,所以默认定义两个int类型的参数。
public class Method_Demo3 {
public static void main(String[] args) {
//调用方法compare,传递两个整数
//并接收方法计算后的结果,布尔值
boolean bool = compare(3, 8);
System.out.println(bool);
}
/*
定义比较两个整数是否相同的方法
返回值类型,比较的结果布尔类型
参数:不确定参与比较的两个整数
*/
public static boolean compare(int a, int b) {
if (a == b) {
return true;
} else {
return false;
}
}
}

练习二

计算1+2+3…+100的和

  • 分析:定义方法实现功能,需要有两个明确,即 返回值 和 参数 。
    • 明确返回值:1~100的求和,计算后必然还是整数,返回值类型是int
    • 明确参数:需求中已知到计算的数据,没有未知的数据,不定义参数
public class Method_Demo4 {
public static void main(String[] args) {
//调用方法getSum
//并接收方法计算后的结果,整数
int sum = getSum();
System.out.println(sum);
}
/*
定义计算1~100的求和方法
返回值类型,计算结果整数int
参数:没有不确定数据
*/
public static int getSum() {
//定义变量保存求和
int sum = 0;
//从1开始循环,到100结束
for (int i = 1; i <= 100; i++) {
sum = sum + i;
}
return sum;
}
}

练习三

实现不定次数打印

  • 分析:定义方法实现功能,需要有两个明确,即 返回值 和 参数 。
    • 明确返回值:方法中打印HelloWorld即可,没有计算结果,返回值类型void。
    • 明确参数:打印几次不清楚,参数定义一个整型参数
public class Method_Demo5 {
public static void main(String[] args) {
//调用方法printHelloWorld,传递整数
printHelloWorld(9);
}
/*
定义打印HelloWorld方法
返回值类型,计算没有结果 void
参数:不确定打印几次
*/
public static void printHelloWorld(int n) {
for (int i = 0; i < n; i++) {
System.out.println("HelloWorld");
}
}
}

2.6 定义方法的注意事项

  • 定义位置,类中方法外面。
  • 返回值类型,必须要和 return 语句返回的类型相同,否则编译失败 。
// 返回值类型要求是int
public static int getSum() {
return 5;// 正确,int类型
return 1.2;// 错误,类型不匹配
return true;// 错误,类型不匹配
}
  • 不能在return后面写代码,return意味方法结束,所有后面代码永远不会执行,属于无效代码。
public static int getSum(int a,int b) {
return a + b;
System.out.println("Hello");// 错误,return已经结束,这里不会执行,无效代码
}

2.7 调用方法的三种形式

  • 直接调用:直接写方法名调用
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}
  • 赋值调用:调用方法,在方法前面定义变量,接收方法返回值
public static void main(String[] args) {
int sum = getSum(5,6);
System.out.println(sum);
}
public static int getSum(int a,int b) {
return a + b;
}
  • 输出语句调用:
  • 在输出语句中调用方法, System.out.println(方法名())
public static void main(String[] args) {
System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
return a + b;
}
  • 不能用输出语句调用 void 类型的方法。因为方法执行后没有结果,也就打印不出任何内容
public static void main(String[] args) {
System.out.println(printHello());// 错误,不能输出语句调用void类型方法
}
public static void printHello() {
System.out.println("Hello");
}

2.8 方法重载

  • 方法重载:指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符和返 回值类型无关。
  • 参数列表:个数不同,数据类型不同,顺序不同。
  • 重载方法调用:JVM通过方法的参数列表,调用不同的方法。

2.9 方法重载练习

练习一

比较两个数据是否相等。参数类型分别为两个 byte 类型,两个 short 类型,两个 int 类型,两个 long 类型,并 在 main 方法中进行测试。

public class Method_Demo6 {
public static void main(String[] args) {
//定义不同数据类型的变量
byte a = 10;
byte b = 20;
short c = 10;
short d = 20;
int e = 10;
int f = 10;
long g = 10;
long h = 20;
// 调用
System.out.println(compare(a, b));
System.out.println(compare(c, d));
System.out.println(compare(e, f));
System.out.println(compare(g, h));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}

练习二

判断哪些方法是重载关系。

public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

练习三

模拟输出语句中的 println 方法效果,传递什么类型的数据就输出什么类型的数据,只允许定义一个方法名 println 。

public class Method_Demo7 {
public static void println(byte a) {
System.out.println(a);
}
public static void println(short a) {
System.out.println(a);
}
public static void println(int a) {
System.out.println(a);
}
public static void println(float a) {
System.out.println(a);
}
public static void println(boolean a) {
System.out.println(a);
}
public static void println(String a) {
System.out.println(a);
}
// long double char都是可以的...
}

第五节【数组】

展开

第一章 数组定义和访问

1.1 容器概述

案例分析

现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。假设该公司有50名员工,用前面所学 的知识,程序首先需要声明50个变量来分别记住每位员工的工资,然后在进行操作,这样做会显得很麻烦,而且错 误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中,统一操作。

容器概念

  • 容器:是将多个数据存储到一起,每个数据称为该容器的元素。
  • 生活中的容器:水杯,衣柜,教室

1.2 数组概念

  • 数组概念: 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。

1.3 数组的定义

方式一 : 指定长度

  • 格式:

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

  • 数组定义格式详解:
    • 数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
    • [] : 表示数组。
    • 数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组。
    • new:关键字,创建数组使用的关键字。
    • 数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
    • [长度]:数组的长度,表示数组容器中可以存储多少个元素。
    • 注意:数组有定长特性,长度一旦指定,不可更改。
      • 和水杯道理相同,买了一个2升的水杯,总容量就是2升,不能多也不能少。
  • 举例:

定义可以存储3个整数的数组容器,代码如下:

int[] arr = new int[3];

方式二 : 指定元素

  • 格式:

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};

  • 举例:

定义存储1,2,3,4,5整数的数组容器。

int[] arr = new int[]{1,2,3,4,5};

方式三 : 指定元素简洁方式

  • 格式:

数据类型[] 数组名 = {元素1,元素2,元素3…};

  • 举例:

定义存储1,2,3,4,5整数的数组容器

int[] arr = {1,2,3,4,5}

1.4 数组的访问

  • 索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引(index),可以通过数组的索引访问到数组中的元素。
  • 格式:

数组名[索引]

  • 数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的 长度,语句为: 数组名.length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数 组的最大索引值为 数组名.length-1 。
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性,输出结果是5
System.out.println(arr.length);
}
  • 索引访问数组中的元素:
    • 数组名[索引]=数值,为数组中的元素赋值
    • 变量=数组名[索引],获取出数组中的元素
public static void main(String[] args) {
//定义存储int类型数组,赋值元素1,2,3,4,5
int[] arr = {1,2,3,4,5};
//为0索引元素赋值为6
arr[0] = 6;
//获取数组0索引上的元素
int i = arr[0];
System.out.println(i);
//直接输出数组0索引元素
System.out.println(arr[0]);
}

第二章 数组原理内存图

2.1 内存概述

内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中的,在硬盘中的程 序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。 Java虚拟机要运行程序,必须要对内存进行空间的分配和管理。

2.2 Java虚拟机的内存划分

为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

  • JVM的内存划分:

Java基础学习2:【流程控制语句、数组】

2.3 数组在内存中的存储

一个数组内存图

public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[[email protected]
}

以上方法执行,输出的结果是[[email protected],这个是什么呢?是数组在内存中的地址。new出来的内容,都是在堆 内存中存储的,而方法中的变量arr保存的是数组的地址。

输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素

Java基础学习2:【流程控制语句、数组】

两个变量指向一个数组

public static void main(String[] args) {
// 定义数组,存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2,将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}

Java基础学习2:【流程控制语句、数组】

第三章 数组的常见操作

3.1 数组越界异常

观察一下代码,运行后会出现什么结果。

public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[3]);
}

创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运 行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一 旦出现了,就必须要修改我们编写的代码。

Java基础学习2:【流程控制语句、数组】

3.2 数组空指针异常

观察一下代码,运行后会出现什么结果。

public static void main(String[] args) {
int[] arr = {1,2,3};
arr = null;
System.out.println(arr[0]);
}

arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候 会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修 改我们编写的代码。

Java基础学习2:【流程控制语句、数组】

空指针异常在内存图中的表现

Java基础学习2:【流程控制语句、数组】

3.3 数组遍历【重点】

  • 数组遍历: 就是将数组中的每个元素分别获取出来,就是遍历。遍历也是数组操作中的基石
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
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]);
}

以上代码是可以将数组中每个元素全部遍历出来,但是如果数组元素非常多,这种写法肯定不行,因此我们需要改 造成循环的写法。数组的索引是 0 到 lenght-1 ,可以作为循环的条件出现。

public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

3.4 数组获取最大值元素

  • 最大值获取:从数组的所有元素中找出最大值。
  • 实现思路:
    • 定义变量,保存数组0索引上的元素
    • 遍历数组,获取出数组中的每个元素
    • 将遍历到的元素和保存数组0索引上值的变量进行比较
    • 如果数组元素的值大于了变量的值,变量记录住新的值
    • 数组循环遍历结束,变量保存的就是数组中的最大值

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
//定义变量,保存数组中0索引的元素
int max = arr[0];
//遍历数组,取出每个元素
for (int i = 0; i < arr.length; i++) {
//遍历到的元素和变量max比较
//如果数组元素大于max
if (arr[i] > max) {
//max记录住大值
max = arr[i];
}
}
System.out.println("数组最大值是: " + max);
}

3.5 数组反转

  • 数组的反转: 数组中的元素颠倒顺序,例如原始数组为1,2,3,4,5,反转后的数组为5,4,3,2,1
  • 实现思想:数组最远端的元素互换位置。
    • 实现反转,就需要将数组最远端元素位置交换
    • 定义两个变量,保存数组的最小索引和最大索引
    • 两个索引上的元素交换位置
    • 最小索引++,最大索引–,再次交换位置
    • 最小索引超过了最大索引,数组反转操作结束

Java基础学习2:【流程控制语句、数组】

public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
/*
循环中定义变量min=0最小索引
max=arr.length‐1最大索引
min++,max‐‐
*/
for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
//利用第三方变量完成数组中的元素交换
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
// 反转后,遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

第四章 数组作为方法参数

4.1 数组作为方法参数

以前的方法中我们学习了方法的参数,但使用的是基本数据类型。那么作为引用类型的数组能否作为方法的参数进 行传递呢,当然是可以的。

  • 数组作为方法参数传递,传递的参数是数组内存的地址。
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法,传递数组
printArray(arr);
}
/*
创建方法,方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

Java基础学习2:【流程控制语句、数组】

4.2 方法的参数类型区别

代码分析

1. 分析下列程序代码,计算输出结果。

public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a);
System.out.println(b);
change(a, b);
System.out.println(a);
System.out.println(b);
}
public static void change(int a, int b) {
a = a + b;
b = b + a;
}

2. 分析下列程序代码,计算输出结果。

public static void main(String[] args) {
int[] arr = {1,3,5};
System.out.println(arr[0]);
change(arr);
System.out.println(arr[0]);
}
public static void change(int[] arr) {
arr[0] = 200;
}

总结: 方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

历史上的今天
一月
10
  • 资源分享QQ群
  • weinxin
  • 官方微信公众号
  • weinxin
沙海
Java图书管理系统
美女讲师教你学C语言
网站https安全证书安装,伪静态配置
Linux服务器网站环境安装

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: