【Java】流程控制语句和数组

一、流程控制语句

1 流程控制语句分类

顺序结构、判断和选择结构(if, switch)、循环结构(for, while, do…while)

2 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的

 

二、判断和选择结构

1 if语句

1.1 if语句格式1

格式：
if (关系表达式) {
    语句体;	
}
1
2
3
4

1.2 if语句格式2

格式：
if (关系表达式) {
    语句体1;	
} else {
    语句体2;	
}
1
2
3
4
5
6

1.3 if语句格式3

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}
1
2
3
4
5
6
7
8
9
10

2 switch语句

2.1 格式

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}
1
2
3
4
5
6
7
8
9
10
11
12

• 首先计算出表达式的值
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
• 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉

2.2 扩展知识

• default可以放在任意位置，也可以省略

• case穿透：不写break会引发case穿透现象

• switch在JDK12的新特性

int number = 10;
switch (number) {
    case 1 -> System.out.println("一");
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}
1
2
3
4
5
6
7

 

三、循环结构

1 for循环结构

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}
1
2
3

执行流程：

执行初始化语句、执行条件判断语句、执行循环体、执行条件控制语句、执行条件判断……

2 while循环

初始化语句;
while(条件判断语句){
	循环体;
	条件控制语句;
}
1
2
3
4
5

3 do-while循环

do-while语句的特点是先执行，再判断

初始化语句;
do{
    循环体;
    条件控制语句;
}while(条件判断语句);
1
2
3
4
5

 

四、循环高级

1 无限循环

又叫死循环，指循环一直停不下来

for格式

for(;;){
    System.out.println("循环执行一直在打印内容");
}
1
2
3

初始化语句可以空着不写，表示循环之前不定义任何的控制变量

条件判断语句可以空着不写，如果不写，默认表示true，循环一直进行

条件控制语句可以空着不写，表示每次循环体执行完毕后，控制变量不做任何变化

while格式：

while(true){
    System.out.println("循环执行一直在打印内容");
}
1
2
3

小括号里面不能省略，true一定要写，否则报错

do…while格式：

do{
    System.out.println("循环执行一直在打印内容");
}while(true);
1
2
3

小括号里面不能省略，true一定要写，否则报错

2 条件控制语句

break

​不能单独存在，可以用在switch和循环中，表示结束、跳出的意思

for (int i = 1; i <= 5; i++) {
    System.out.println("在吃第" + i + "个包子");
    if(i == 3){
        break;
    }
}
1
2
3
4
5
6

continue

​不能单独存在的，只能存在于循环当中，表示跳过本次循环，继续执行下次循环

for (int i = 1; i <= 5; i++) {
    if(i == 3){
        continue;
    }
    System.out.println("在吃第" + i + "个包子");
}
1
2
3
4
5
6

3 Random

Random跟Scanner一样，也是Java提前写好的类，可以直接使用

1. 导包

import java.util.Random;
导包的动作必须出现在类定义的上边
1
2

2. 创建对象

Random r = new Random ();
1

3. 生成随机数

int number = r.nextInt(随机数的范围);
随机数范围的特点：从0开始，不包含指定值，比如参数为10，生成的范围[0,10)
1
2

 

五、数组

1 数组

数组容器在存储数据的时候，需要结合隐式转换考虑

定义了一个int类型的数组，那么boolean、double类型的数据是不能存到这个数组中的，但是byte类型、short类型、int类型的数据是可以存到这个数组里面的

建议容器的类，和存储的数据类型保持一致

2 数组的定义和初始化

定义

type [] name 或 type name []

静态初始化

type [] name = new type[]{元素1，元素2，元素3，元素4...};

或简化格式为type [] name = {元素1，元素2，元素3，元素4…};`

注意

• new指给数组在内存中开辟了一个空间
• 等号前后的数据类型必须保持一致
• 数组一旦创建之后，长度不能发生变化

int[] arr = new double[]{11,22,33};//错误写法
1

动态初始化

type[] name = new type[length];

//定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];
1
2

数组的默认初始化值：

整数类型：0

小数类型：0.0

布尔类型：false

字符类型：‘\u0000’

引用类型：null

两种初始化方式的区别

静态初始化：int[] arr = {1,2,3,4,5}; 手动指定数组的元素，系统会根据元素的个数计算数组的长度

动态初始化：int[] arr = new int[3];

3 地址值

int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736

double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
1
2
3
4
5

打印数组的时候，实际出现的是数组的地址值，即表示数组在内存中的位置

以[I@6d03e736为例：

[ ：表示现在打印的是一个数组

I：表示现在打印的数组是int类型的

@：一个间隔符号

6d03e736是数组在内存中真正的地址值（十六进制的），但是我们习惯性会把[I@6d03e736这个整体称之为数组的地址值

4 数组元素访问与遍历

元素访问

name[index]

索引的特点：

• 索引一定是从0开始的
• 连续不间断且逐个+1增长

遍历

数组的长度：name.length;

for(int i = 0; i < arr.length; i++){
    sout(arr[i]);
}
1
2
3

5 常见问题

当访问了数组中不存在的索引，就会引发索引越界异常

针对于任意一个数组，索引的范围是0-length-1

public class ArrDemo6 {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,5,5,5,5};
        System.out.println(arr[1]);
        System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
    }
}
1
2
3
4
5
6
7

6 练习

6.1 随机数

生成10个1~100之间的随机数存入数组

int[] arr = new int[10];
//把随机数存入到数组当中
Random r = new Random();

for (int i = 0; i < arr.length; i++) {
    //每循环一次，就会生成一个新的随机数
    int number = r.nextInt(100) + 1;
    //把生成的随机数添加的数组当中
    arr[i] = number;
}
1
2
3
4
5
6
7
8
9
10

6.2 打乱数据

定义一个数组，存入1~5，要求打乱数组中所有数据的顺序

int[] arr = {1, 2, 3, 4, 5};
//循环遍历数组，从0索引开始打乱数据的顺序
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
    //生成一个随机索引
    int randomIndex = r.nextInt(arr.length);
    //拿着随机索引指向的元素 跟 i 指向的元素进行交换
    int temp = arr[i];
    arr[i] = arr[randomIndex];
    arr[randomIndex] = temp;
}

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15