java中的选择（包括条件表达式）和循环语句（包括foreach循环语句）

小鱼儿 2022-02-28 02:03 395阅读 0赞

在我们敲代码的时候经常会遇到要使用选择语句和循环语句的时候，因为合理的使用这些语句能有效的提高我们代码的质量和性能。  
接下来我们说说这些语句！

### 1、选择语句 ###

先来说说java的关系操作符：

<table> 
 <thead> 
 <tr> 
 <th align="center">java操作符</th> 
 <th align="center">数学符号</th> 
 <th align="center">名称</th> 
 <th align="center">试例 (半径为1)</th> 
 <th align="center">结果（值是布尔值）</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="center">&lt;</td> 
 <td align="center">&lt;</td> 
 <td align="center">小于</td> 
 <td align="center">radius &lt; 0</td> 
 <td align="center">false</td> 
 </tr> 
 <tr> 
 <td align="center">&lt;=</td> 
 <td align="center"> ≤ \leq ≤</td> 
 <td align="center">小于等于</td> 
 <td align="center">radius &lt;= 0</td> 
 <td align="center">false</td> 
 </tr> 
 <tr> 
 <td align="center">&gt;</td> 
 <td align="center">&gt;</td> 
 <td align="center">大于</td> 
 <td align="center">radius &gt; 0</td> 
 <td align="center">true</td> 
 </tr> 
 <tr> 
 <td align="center">&lt;</td> 
 <td align="center"> ≥ \geq ≥</td> 
 <td align="center">大于等于</td> 
 <td align="center">radius &gt;= 0</td> 
 <td align="center">true</td> 
 </tr> 
 <tr> 
 <td align="center">=</td> 
 <td align="center">=</td> 
 <td align="center">等于</td> 
 <td align="center">radius == 0</td> 
 <td align="center">false</td> 
 </tr> 
 <tr> 
 <td align="center">！=</td> 
 <td align="center"> ≠ \neq ̸=</td> 
 <td align="center">不等于</td> 
 <td align="center">radius ！= 0</td> 
 <td align="center">true</td> 
 </tr> 
 </tbody> 
</table>

注意：***相等的关系操作符是两个等号(==)，而不是一个等号（=），后者时赋值操作符！***

一般得在其他编程语言中这几种关系操作符都是相同的。

### java的选择语句中有6种语句 ###

##### 1、单分支if语句 #####

##### 2、双分支if-else 语句 #####

##### 3、嵌套if语句 #####

##### 4、多分支if - else语句 #####

##### 5、switch语句 #####

##### 6、条件表达式 #####

#### if语句 ####

语法：  
if(布尔表达式)\{  
语句（组）；  
\}  
if语句只会是表达式为真时才会执行里面的语句（组）。  
当花括号内只有一条语句时，则可以省略花括号。下面的if-else语句亦是如此。

#### 双分支if-else语句 ####

语法：

> if(布尔表达式)\{  
> 布尔表达式为真时执行的语句（组）；  
> \}  
> else\{  
> 布尔表达式为假是执行的语句（组）；  
> \}

流程图如下：

Created with Raphaël 2.2.0开始布尔表达式条件为真时执行的语句（组）结束条件为假时执行的语句（组）yesno

#### 嵌套的if语句与多分支if-else语句 ####

嵌套的if-else语句其实就是if-else语句的多重使用，用于解决多重选择问题。  
而多分支if-else语句也是用于实现多重选择。在实际写代码过程中如需解决多重选择问题，如果使用这两种语句写建议使用多分支if-else语句，这样更有逻辑感！  
两者的区别，请看下面代码：

//嵌套的if-else语句
    		if(score >= 90.0)
    			System.out.println("A");
    		else
    			if(score>= 80.0)
    				System.out.println("B");
    			else
    				if(score >= 70.0)
    					System.out.println("C");
    				else
    					if(score >= 60.0)
    						System.out.println("D");
    					else
    						System.out.println("F");
    		/**多分支的if-else语句，这个的层次感分明，让人看着都舒服*/
    		if(score >= 90.0)
    			System.out.println("A");
    		else if(score >= 80.0)
    			System.out.println("B");
    		else if(score >= 70.0)
    			System.out.println("C");
    		else if(score >= 60.0)
    			System.out.println("D");
    		else
    			System.out.println("F");

#### switch语句 ####

**switch语句是基于变量或表达式的值来执行语句。**

**应用** ：当需选择值来做表达式判断时可用switch语句

语法：

> switch(switch表达式)\{  
> case 值1：语句（组）1；  
> break;  
> case值2：语句（组）2；  
> break；  
> case值3：语句（组）3；  
> break;  
> …  
> case值n：语句（组）n;  
> break;  
> default：默认情况下执行的语句（组）；  
> \}

***注意：***  
1、switch表达式必须是一个能计算出一个char、byte、short、 int或者String型值，而且必须用括号括住。  
2、case后的值的必须与switch表达式的值具有相同的数据类型，且case后的值不可含有变量，如不可出现1+x。  
3、关键字break是可选的，break语句会立即终止switch语句。当switch表达式的值与case的值匹配会执行该条case开始的语句，直到遇到break语句或到达该switch语句的结束。  
4、break语句与默认情况（default）都是可选的，即可按要求不写。

#### 条件表达式 ####

**应用** : 如果要求中只有两到三个判断可采用条件表达式

1、固定式：变量 = (布尔表达式)？值1 ：值2；  
2、值1和值2中又可以是条件表达式，可以嵌套条件表达式。如 变量 = (布尔表达式)？值1 ： (布尔表达式2)？值2：值3；  
3、当括号内的表达式为真则变量为冒号前面的值，否则为冒号后面的值。  
4、符号？和：在表达式中同时出现。他们构成一种条件操作符，因为操作符数有三个，所以称为三元操作符（ternary operator）。它们是java中唯一的三元操作符。

##### 常见错误与陷阱 #####

**1、对布尔值的冗余测试**  
为了检验测试条件中的布尔型变量是true还是false,像下图的“==true”是多余的；

> if (even == true)
> 
> > System.out.println(“It is even.”);

下面的代码会比上面的好，避免了误将“==”写成“=”的可能，直接测试布尔变量。

> if (even)
> 
> > System.out.println(“It is even.”);

**2、悬空else出现的歧义**

int i = 1,j = 2,k = 3;
    		if(i > j)
    			if(i > k)
    				System.out.println("A ");
    		else
    			System.out.println("B ");

这里的缩进表明else子句是匹配第一个if子句，但实际上是匹配第二个if子句。这就是悬空else歧义。**在同一块中，else总是与它最近的if子句匹配。**  
上一个图的代码是不打印任何东西的。下图的代码会打印出B。

int i = 1,j = 2,k = 3;
    		if(i > j){
        
    			if(i > k)
    				System.out.println("A ");
    		}
    		else
    			System.out.println("B ");

**3、两个浮点数值的相等比较测试**  
因为浮点数是具有有限的计算精度，涉及浮点读书的计算可能引入取整错误。因此两个浮点数值的相等测试并不可靠。如下面代码返回值并不是你期望的true，而是false。

> double x = 1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1;  
> System.out.println("x == 0.5 ");

这里x并不能精确到等于0.5，而是0.5000000000000001。.虽然不能依赖于两个浮点数值的相等测试，但是可以通过测试两个数的差距小于某个阈值，来比较它们是否已经足够接近。也就是，对于一个非常小的值&，如果|x-y|<ε,那么x和y非常接近。ε是一个读为“epsilon”的希腊字母，常用于表示个非常小的值。通常，将ε设为10\-14 来比较两个double类型的值，而设为10\-7来比较两个float类型的值。如下面的代码：

final double EPSILON = 1E-14;//1E-14表示10的负14次方
 		double x=1.0-0.1-0.1-0.1-0.1-0.1;
 		//Math.abs(x - 0.5)方法用于返回(x - 0.5)的绝对值
 		if (Math.abs(x - 0.5) < EPSILON)
 			System. out.println(x +"is approximately 0.5");

将显示0.5000000000000001近似0.5。

### 2、循环语句 ###

##### 1、while循环语句 #####

##### 2、do-while循环语句 #####

##### 3、for循环语句 #####

##### 4、foreach循环语句（Java5以后加的循环语句） #####

#### while循环语句 ####

注：while循环在条件为真的情况下，重复的执行语句。  
语法：

> while(循环继续条件)\{  
> //循环体  
> 语句（组）；  
> 用于控制循环的附件条件；  
> \}

int score = 0;
 		int i = 1;
 		//循环语句
 		while(i <10) {
 
 			score += i;
 			i ++;//控制循环的附加条件
 		}
 		System.out.println("score is " + score);//score is 45

**注意**：在循环条件那要特别注意是小于还是小于等于后面的固定值。

#### do-while循环语句 ####

注：do-while 循环和while循环基本一样，不同的是它先执行循环体一次，然后判断循环继续条件。  
do-while循环是while循环的变体。如果循环中的语句至少执行一次建议使用do-while循环。  
语法：

> do\{  
> //循环体  
> 语句（组）；  
> \}while(循环继续条件)；

注意在写完循环继续条件后要加“ ；”。  
下面这种情况用do-while比用while较好，因为需要先提示。

int data;
    		int sum = 0;
    		Scanner input = new Scanner(System.in);
    		//循环语句
    		do {
        
    			System.out.print("Enter an integer(the input ends if it is 0):");//当输入0是循环结束
    			data = input.nextInt();
    			sum+=data;
    		}while(data !=0);
    		
    		System.out.println("sum is " + sum);

#### for循环 ####

注：for循环具有编写循环的简明语法。  
语法：  
for（初始操作；循环继续条件；每次迭代后的操作）\{  
//循环体  
语句（组）；  
\}  
注：**for（ ； ；）\{\}小括号当中的两个分号不能少。**  
do-while循环、while循环和for循环的三者比较：

int i = 0;
 		int sum = 0;
 		//三个循环都实现相同的功能，把i的值全加起来
 		do {
 
 			sum += i;
 		}while(i < 10);
 		
 		while(i < 10) {
 
 			sum +=i;
 		}
 		
 		for(int i = 0;i < 10; i ++) {
 
 			sum +=i;
 		}

###### 在敲代码时该采用哪种循环？ ######

while循环和for循环都被称为前测循环，因为继续条件在循环体执行之前检测的；而do-while循环固然就叫后测循环，原因与前两个刚好相反。

这三种循环语句并没有什么好坏之差，只是各有各更适合的应用场景而已。在敲代码时建议使用自己觉得最自然、最舒服的循环语句。

一般的如果已经知道循环要重复的次数，就采用for循环；如无法确定重复次数，就采用while循环；如检验**继续条件前**需要执行循环体，就用do-while循环代替while循环。

在数组中要读取数组的各个元素一般使用for循环，因为简单明了！

#### foreach循环语句 ####

在java1.5中java开发者又新增了一个循环语句——foreach循环语句：for语句的特殊简化版本，**主要执行遍历功能的循环**。  
foreach循环语句是java1.5的新特征之一，在遍历数组、集合方面，foreach为开发者提供了极大的方便。  
foreach循环语句的语法格式如下：

> for(类型 变量名 ：集合)\{  
> 语句块；  
> \}

其中，“类型”为集合\*\*元素的类型**，“变量名”表示集合中的每个元素，“集合”是**被遍历的集合对象或数组\*\*。每执行一次循环语句，循环变量就读取集合中的一个元素。  
流程图如下：

Created with Raphaël 2.2.0开始是否包含元素执行的语块结束yesno

下面是使用foreach循环语句实现一、二和三维数组的遍历和输出。  
闲话多说无益，上代码：

public class foreac {
        
    
    	public static void main(String[] args) {
        
    		// TODO Auto-generated method stub
    		
    		/**
    		 * 声明一个一维数组nu
    		 * 并初始化数组值为 1、2*/
    		int[] nu = {
        1,2};
    		//使用foreach循环来实现遍历数组元素的功能，并将值逐一赋个number1且逐一输出数组元素的值
    		for(int numbe1 : nu) 
    			System.out.print(numbe1 + "\t");//\t是Tab键，表示空出几个空格的意思
    		
    		System.out.println("\n");// \n换行符,使输出这一维数组的元素值与输出下面二维数组的元素值不同行
    		/**
    		 * 声明一个二维数组in
    		 * 并初始化数组元素的值为
    		 * 1、2
    		 * 3、4*/
    		int[][] in = {
        {
        1,2},{
        3,4}};
    		for(int[] number : in)//第一个foreach语句是遍历二维数组中的第一行的所有元素，这些元素又暂时形成数组number
    			for(int number1 : number) //第二个foreach语句就遍历在第一个foreach语句中形成的数组元素，并将值逐一赋个number1
    				System.out.print(number1 + "\t");
    			
    		System.out.println("\n");
    		
    		/**
    		 * 声明一个三维数组Value
    		 * 并初始化数组元素的值
    		 * (三维数组是立体的，从正面看过去看到一个二维数组，即
    		 * 第一行：567,789,336,229
    		 * 第二行：890,995,668,867
    		 * 下面的如777,899,868,796
    		 * 		999,984,848,888
    		 * 则被第一行和第二行的数值遮住（这里只能靠自己的想像力了）)*/
    		int count =0;		//声明一个变量来计算读取到第几个元素
    		double[][][] Value ={
        {
        {
        567,789,336,229},{
        890,995,668,867}},
    				  {
        {
        777,899,868,796},{
        999,984,848,888}},
    				  {
        {
        912,800,809,706},{
        909,904,868,898}}};	
    		for(double[][] number : Value)//第一个foreach语句是遍历三维数组中的第一面的所有元素，这些元素又暂时形成二维数组number
    			for(double[] number1 : number)//第一个foreach语句是遍历二维数组(number)中的第一行的所有元素，这些元素又暂时形成一维数组numbe1
    				//第二个foreach语句就遍历一维数组numbe1的数组元素，并将值逐一赋个number2
    				for(double number2 : number1) {
        
    					count ++;//迭代计算读取到第几个元素
    					System.out.print(number2 + "\t");
    					if(count % 8 ==0)//当读取到第8个和8的倍数的个数时，输出的元素换行
    						System.out.println("\n");
    				}
    	}
    
    }

上面代码的运行结果，如下图：  
![使用foreach语句实现的一、二和三维数组的输出结果，上面代码的输出结果][foreach]

注：以上为我个人学习的一些分享，对于以上内容如有疑问的地方欢迎评论，如有不当的地方也请在评论区评论为我指出问题，谢谢！

[foreach]: /images/20220228/79bfe85c2d80466e833180b7e9576c3b.png