选择结构、循环结构以及数组

一、选择结构

什么是选择结构

​

​ 选择结构：生活中我们经常需要做判断，然后才能决定是否做某件事情。java程序从实际生活出发，诞生了选择结构，很好的解决了在编程时遇到的问题。

​ 选择结构是满足某个条件就执行某部分代码，否则不执行。

1、if 选择结构

语法

if(条件){
	//代码块
}

​ if后面的小括号里的条件是一个表达式，并且表达式的值必须为boolean类型的值。

执行顺序

​ 先判断后执行 。先判断条件，当条件为true 时，执行if{}里面的代码 否则不执行

流程图

2、if —else结构

语法

if(条件){
	//代码块1
}else{
	//代码块2
}

执行顺序

​ if—else 与if 结构执行顺序相同，但是if—else中当条件不满足时，执行else后面的{}里的代码块

流程图

3、多重if结构

语法

if(条件1){
	//代码块1
}else if(条件2){
	//代码块2
}else{
	//代码块3
}

执行顺序

首先判断条件1是否成立，如果成立的话执行代码块1，之后的都不会执行。条件1如果不成立的话跳过代码块1，再判断条件2，如果成立的话执行代码块2，之后的都不会执行。如果条件1和2都不满足的话最后执行else里面的代码块3。执行顺序是连续的，而不是跳跃的。

注意：多重选择结构可以有多个else if块也可以没有，完全取决于需要。else块最多有一个或者没有。

流程图

4、嵌套if结构

语法

if(条件1){
	if(条件2){
		//代码块1
	}else{
		//代码块2
	}
}else{
	//代码块3
}

执行顺序

只有当满足外层if选择结构时，才会判断内层if的条件，然后按照if—else语法的执行顺序执行。

注意：else总是与它前面最近的那一个缺少else块的if配对。

流程图

​ 小结：

​ if选择结构：可处理单一或组合条件的情况。

​ if—else结构：可处理简单的条件分支情况。

​ 多重if结构：可处理连续区间的条件分支情况。

​ 嵌套if结构：可以处理复杂的条件分支情况。

5、switch选择结构

语法

switch(表达式){
	case 常量1:
		//代码块1
		break;
	case 常量2:
		//代码块2
		break;
	······
	default：
        //代码块n
        break;
}

关键字

关键字	意思
switch	开关
case	情况
default	默认
break	停止

和if结构的区间判断不同，switch结构是用来做等值判断的，小括号里面放的是表达式，数据类型可以是int、short、byte、char、枚举类型、String（从JDK1.7之后才支持String）。

case后面跟一个固定的值，数据类型与switch小括号里的数据类型一致。case块可以有多个，顺序可以改变，但是每一个case块后面的常量必须不同，当switch中的表达式与其中一个case后的常量相等时，就执行那一个case后面的代码块

default为默认值，当switch中没有一个case块的值与表达式相同时，就执行default后面的代码块，通常default块放在末尾，也可以省略。

break表示跳出当前结构，也可以省略。

注意事项

1、switch结构只能做等值判断，而且只能是整型或字符型的等值判断。

2、每个case块后的代码块后面可以有一组语句，case和default后面紧跟冒号，不能漏写，否则编译不通过。

3、在case块后面的break是可以省略的，还可以让多个case块执行同一条语句，所以对于每一个case块的结尾，都要想一想是否需要跳出整个switch结构，当你需要跳出switch结构时，break则不能省略

选择结构常用的逻辑运算符：

运算符	汉语名称	表达式	说明
&&	与、并且	条件1&&条件2	两个条件同时为真，则结果为假；两个条件有一个为假，则结果为假
||	或、或者	条件1||条件2	两个条件有一个为真，则结果为真；两个条件同时为假。则结果为假
!	非	！条件	条件为真时，结果为假；条件为假时结果为真

还有一个运算符，叫三目运算符：

语法结构：(条件) ？true : false

​ 条件前面需要变量接受真假的结果，"？“后面跟的是条件为真时的输出结果，”:"后面跟的是条件为假时的输出结果

二、循环结构

什么是循环

循环就是重复的做某件事情，循环结构就是在什么条件成立时不断地做某件事情。

首先，循环不是无休止进行的，满足一定条件的时候才会继续，称为“循环条件”，循环条件不满足的话，循环就退出；其次，循环结构时反复进行相同的或者类似的一系列操作，称为“循环操作”。

循环结构包括循环条件和循环操作。

1、while循环

语法：

while(循环条件){
	//循环操作
}

while后面的小括号中是一个boolean类型的表达式，{}里面的语句统称为循环操作，又称为循环体。

执行顺序

1. 声明并初始化循环变量。
2. 判断条件是否满足，如果满足则执行循环操作；否则退出循环。
3. 执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环。

实际上while结构第一次判断条件不满足时，则会直接跳出循环，一边都不会执行。这是while循环结构的特点：先判断，后执行。

流程图

使用while循环解决问题的步骤如下：

1. 分析循环条件和循环操作
2. 套用while语法写出代码
3. 检查循环能否退出

注意：永远不会退出的循环称为“死循环”。“死循环”是编程中应极力避免出现的情况，所以对于循环，编写后要仔细检查循环能否退出。

2、do-while循环结构

语法

do{
	//循环操作
}while(循环条件);

执行顺序

与while结构不同，do-while结构的执行顺序如下：

1. 声明并初始化循环变量
2. 执行一遍循环操作
3. 判断循环条件，如果条件满足，则循环继续执行，否则退出循环。

根据do-while的执行顺序可以看出循环操作至少执行一遍。

do-while 的特点是：先执行，后判断。

流程图

3、for循环

语法

for(表达式1;表达式2;表达式3){
	//循环操作
}

for是此循环的关键字。每个表达式的含义如下表

表达式	形式	功能	举例
表达式1	赋值语句	循环的初始部分，为循环变量赋初值	int i = 0
表达式2	条件语句	循环结构的循环条件	i < 100
表达式3	迭代	通常用来修改循环变量的值	i++

在语法上，for循环的三个表达式都可以省略，但表达式后面的分号不能省略。如果省略了表达式，要注意保证循环能够正常运行。例如

int i = 0;
for(;i < 100;){
	i++;
}

如上代码块也是能够正常运行的。

执行顺序

1. 执行初始部分
2. 进行循环条件判断
3. 根据循环条件判断结果。如果为true则执行循环体；如果为false，则退出循环，后面的步骤都不执行
4. 执行迭代部分，改变循环变量值
5. 重复2~5步，直至退出循环

可见：在for循环中，表达式1只执行了一次。

流程图

4、二重循环

二重循环简单来说就是一个循环体内又包含一个完整的循环结构。

以上的三种循环都可以互相嵌套

语法如下

//while与while循环嵌套
while(循环条件1){
    //循环操作1
    while(循环条件2){
        //循环操作2
    }
}
//do-while与do-while循环嵌套
do {
    //循环操作1
    do{
        //循环操作2
    }while(循环条件2);
}while(循环条件1);
//for与for循环嵌套
for(循环条件1){
    //循环操作1
    for(循环条件1){
        //循环操作2
    }
}
//while 与for循环嵌套
while(循环条件1){
    //循环操作1
    for(循环条件2){
        //循环操作2
    }
}

上面四种形式中，循环条件1和循环操作1对应的循环称为外层循环。循环条件2和循环操作2对应的循环被称为内层循环

执行顺序

在二重循环中，外层循环变量执行一次，内层循环变量要从初始值到结束值变化一遍。内层循环结束后才执行外层循环的语句。

示例：

public class Demo{
    public static void main(String [] args){
        for(int i = 0; i <= 9 ; i++){
            for(int j = 1 ; j <= i ; j++){
                System.out.print(j +"*"+ i +"="+ j * i +" ");
            }
            System.out.print("\n");
        }
    }
}

以上代码块输出的是九九乘法表外层循环控制行数，内层循环控制输出的内容，i行上有i个公式，所以输出的是九九乘法表。

循环结构里的跳转语句：

break：

break语句用于终止某个循环，使程序跳到循环体外的下一条语句。在循环体中位于break后面的语句将不再执行，循环也停止执行。通常与if选择结构一起使用。break语句可以用于switch选择结构以及循环结构中。

continue：

continue语句只能用于循环结构，代表跳过本次循环进入下次循环。在for循环中遇到continue语句时先跳转到迭代部分，然后判断条件，条件为true时则进入下一次循环，否则终止循环。在while循环结构中遇到continue语句则直接判断条件。

在二重循环中break语句与continue语句的区别：

	continue 												break
for(...){												for(...){
    for(...){													for(...){
        ...														...
        continue;													break;
        //只是用于跳过内层循环的本次循环						//跳出内层循环进入外层循环
    }														}
}													}

由以上可以看出在二重循环中continue语句只是本轮循环的跳过，在哪层循环就跳过哪层。

在二重循环中break语句只是跳过break语句所在的循环。

三、数组

什么是数组

Java程序中当需要声明的变量太多的时候为了能有效的储存数据，节省空间。针对此类问题提供了有效的解决方法——数组。数组就是在内层空间划出一串连续的空间。数组就是一个变量，用于将相同数据类型的数据存储在内层中。数组中的每一个数据元素都属于同一数据类型。

数组的基本要素

• 标识符。首先，和变量一样，在计算机中，数组也要有一个名称，称为标识符，用于区分不同的数组。
• 数组元素。当数组有了标识符后，要向数组中存放数据，这些数据就是数组元素。
• 数组下标。在数组中，为了正确的得到数组的元素，需要对它们进行编号，这样计算机才能根据编号去存取，这个编号就叫做数组下标。它标明了元素在数组中的位置，数组中的每个元素都可以通过下标来访问。由于元素是按顺序存储的，每个元素固定对应一个下标，因此可以通过下标快速访问到每个元素。
• 元素类型。存储在数组中的数组元素应该为同一数据类型的。
• 数组长度。数组的大小（长度）是数组可以容纳元素的最大数量。定义一个数组的同时也定义了它的大小。如果数组已满但是还继续向数组中存储数据的话，程序就会出错，这称为数组越界。

使用数组的步骤

1、声明数组：

​ 语法：数据类型 [] 数组名; 或者 数据类型 数组名 [];

2、分配空间：

​ 语法：数组名 = new 数据类型[数组长度] ;

​ 在声明的时候同时也能够分配空间

语法：数据类型 [] 数组名 = = new 数据类型[数组长度] ;

数组长度为数组能存放的元素个数。

3、赋值

语法：数组名[下标值]；

在声明的时候同时也能够分配空间并复制，如下所示：

语法：数据类型[] 数组名 = {值1，值2，值3，…，值n};

例如：

int[] scores = {60,70,98,90,76};
int[] scores = new int[]{60,70,98,90,76}；

4、对数据的处理
如果定义的数组是基本数据类型的数组，即int、double、char和boolean类型，在java中定义数组后，若没有指定初始值，则依数据类型的不同，会给数据元素赋一个默认值。如下所示：

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false

当我们需要使用数组长度时，一般用如下的方式：

​ 数组名.length;

注意:数组下标从0开始，而不是从1开始。如果访问数组元素时指定的下标小于0，或者大于等于数组长度，都将出现数组下标越界异常。

数组的应用

数组排序

语法：

Arrays.sort(数组名);

在使用该语法前需要先导入一个包

import java.util.Arrays;

按照上面的语法就能够对数组进行从小到大的排序。

示例：

import java.util.Arrays;
import java.util.Scanner;

public class ScoreSort {
	public static void main(String[] args) {
		int[] scores = new int[5];
		Scanner input = new Scanner(System.in);
		System.out.println("请输入5位学员的成绩：");
		for (int i = 0; i < scores.length; i++) {
			scores [i] = input.nextInt();
		}
		Arrays.sort(scores);
		System.out.println("学员成绩按升序排列");
		for (int i = 0; i < scores.length; i++) {
			System.out.print(scores[i]+" ");
		}
	}
}

以上示例对成绩数组score排序，只需要把数组名score放在sort()方法的括号中，该方法执行后，利用循环输出，就可以将数组score的值从小到大进行排序。

求数组的最大值

这是一个循环的过程，max量依次与数组中的元素 进行比较。如果max小于比较的元素，则执行置换操作。如果max较大，则不执行操作。因此，需要使用循环和选择结构，来进行循环判断，并实现交换值，可以大大的简化代码，提高程序效率

示例：

数组插入元素

首先需要数组的长度足够能插入元素，然后找到插入的元素的下标，之后进行元素后移，最后再赋值给插入的下标。

示例：

import java.util.Scanner;

public class Insert{
	public static void main(String[] args) {
		int [] list = new int[6];
		list[0] = 99;
		list[1] = 85;
		list[2] = 82;
		list[3] = 63;
		list[4] = 60;
		int index = list.length;
		System.out.println("请输入新增成绩：");
		Scanner in = new Scanner(System.in);
		int num = in.nextInt();
		for (int i = 0; i < list.length; i++) {
			if (num > list[i]) {
				index = i;
				break;
			}
		}
		for (int j = list.length-1; j > index; j--) {
			list[j] = list[j-1];
		}
		list[index] = num;
		System.out.println("插入成绩的下标是："+index);
		System.out.println("插入后的成绩信息是：");
		for (int k = 0; k < list.length; k++) {
			System.out.print(list[k] + "\t");
		}
	}
}

总结：

在实际的开发中，数组的应用非常广泛。利用数组解决问题的时候经常与选择结构、循环结构搭配。