在本文中，我们可以看到如何用Java实现基本的流控制结构/语句：

决策结构：if , if – else, switch;

**循环块的结构：**do while，while–do，enhanced–for；

循环控制指令：break, continue;

使用控制结构，我们可以编写执行不只是指令线性序列的程序。

在Java中如何使用if–then控制语句

条件流控制结构 if–then，具有以下形式：

if(条件)
    语句

或者

if(条件){
    语句1;
    语句2;
}

其中 条件是一个值为 true或*false *的布尔表达式或变量。例如 30>10或10==30。

在Java中，不接受基于具有数值的表达式或变量的条件。例如，以下表达式在C/C++中有效，但在Java中无效：

int valoare = 10;
if(valoare)
    System.out.println("大于0!");

会报编译错误： 不兼容类型 : incompatible types.。

为了说明if then子句，我们确定一个数字是否为负数，如果为负数，则更改其符号：

int negativeNumber = -22;
boolean isNumber = true;

if(isNumber)
    System.out.println("It's a number";);

if(negativeNumber < 0)
{
    System.out.println("It's a negative one! Change it.");
    negativeNumber = (-1) *negativeNumber;
    System.out.println(negativeNumber);
}

在Java中如何使用if–then–else控制语句

if–else控制子句的格式如下：

if(条件){
    语句1;
    语句2;
}
else{
    语句3;
    语句4;
}

如果我们想知道两个数字的最小值：

int vb1 = 10;
int vb2 = 20;
int min;
if(vb1 < vb2)
    min = vb1;
else
    min = vb2;

还可以通过条件运算符?:来实现：

条件 ? 条件为true时执行的语句 : 条件为flase时执行的语句

上一个例子变成：

 min = vb1 < vb2 ? vb1 : vb2;

在Java中如何使用do–while循环

重复结构do-while实现了一个后处理循环，因为在循环块的末尾检查退出/留在循环中的条件。
结构将至少运行一次循环块中的迭代语句：

do{
    语句1;
    语句2;
} while(条件);

例如，如果我们想计算N！（前提是N>1）在ado-while中：

// 计算n的阶乘
int nFactorial = 1;
int i = 0;
int n = 5;
do
{
    i++;
    nFactorial = nFactorial *i;
}while(i < n);
// 输出结果
System.out.println(n+"! = "+nFactorial);

如何在Java中使用while–do循环

重复结构while-do实现一个预处理周期，因为在执行循环块中的第一条语句之前，检查退出/留在循环中的条件：

while(条件){
    语句1;
    语句2;
}

// 计算n的阶乘
int nFactorial = 1;
int i = 0;
int n = 5;
while (i < 5)
{
    i++;
    nFactorial = nFactorial *i;
}
System.out.println(n+"! = "+nFactorial);

如何在Java中使用for循环

for重复结构实现了一个预先设置好的循环结构，就像do while一样。for结构效率更高，因为迭代和初始化语句包含在结构中而不是块中：

 for(初始化; 条件; 迭代语句){
     语句1;
     语句2;
 }

例如，要计算数组中元素的和：

int[] vector = {1,2,3,4,5};
int sum = 0;
for(int j = 0; j < vector.length; j++)
    sum += vector[j];
System.out.println("The sum is "+sum);

在for控制结构中，可以编写多个由（逗号）分隔的迭代和初始化语句：

for(初始化语句1,初始化语句2; 条件; 迭代语句1,迭代语句2){
    语句1;
    语句2;
}

for语句元素：初始化、迭代和条件是可选的。下一个例子是合法的，但在某些情况下，我们必须决定for循环何时将使用break结束。

for( intialization; ; )
for( ; condition; iteration )
for( ; ; iteration)
for( ; ; ) // 死循环

在初始化语句中声明的变量是For块的局部变量，在外部不可见：

for ( int i=0; i<10 ; i++ ) {

}
// compile-error, cannot resolve symbol: i
// 编译错误，无法解决符号:i
System.out.println("value of i: " + i );

如何在Java中使用 增强的for循环

重复的增强的for结构实现了一个预处理循环。这个结构是在Java5.0中引入的，它允许更简单的语法和更快的实现（类似.net中的 foreach形式））。此结构只能用于遍历实现java.lang.Iterable语言接口。

for ( variable: iterable_collection )
{
    语句1;
    语句2;
}

使用增强型的for重写前面的示例：

sum = 0;
for(int value: vector)
{
    suma += value;
}
System.out.println("总和是："+sum);

如何在Java中使用switch语句

switch条件结构实现了一个具有多个分支的条件结构。它替换了一个比多个 if-then-else 子句更有效的结构。

switch (变量) {
case 常量值1:
    语句1;
    break;
case 常量值2:
    语句2;
    break;
...
default:
    语句;
}

每个case子句必须用 break指令关闭，因为它提供了退出 switch结构的方法。

例如，通过switch语句测试变量值比通过多个if语句更容易。

int testValue = 2;
switch(testValue)
{
    case 1:
        System.out.println("值是1");
        break;
        case 2:
        System.out.println("值是2");
        break;
        case 3:
        System.out.println("值是3");
        break;
        case 4:
        System.out.println("值是4");
        break;
    default:
        System.out.println("其他值");
}

通过运行上面的例子，我们得到了这样一条消息： 值是2。

如果我们不使用break指令，那么前面的示例将显示：

值是2
值是3
值是4
其他值

如何在Java中使用 break和continue语句

break语句停止由for、do while、while do实现的当前循环块。另外，如果在switch结构中使用它，它将关闭最后一个case子句。

continue指令将挂起for，do while，while do循环块的当前迭代，并将执行下一次迭代。

例如，让我们确定给定数组中所有元素为正数的和：

         int[] intValues = {10,12,5,-4,3,-1,23};
         int positiveSum = 0;
         for(int j = 0; j < intValues.length; j++)
         {
             if(intValues[j] < 0)   // 如果是负数，则直接进行下一次迭代
                 continue;          
            
             // 计算其他值的和
             positiveSum+=valoriInt[j];
         }
         System.out.println("正数的和为： "+positiveSum);

或者，让我们确定第一次出现的负值：

int[] intValues = {10,12,5,-4,3,-1,23};
int negativeValue = 0;
for(int j = 0; j < intValues.length; j++)
{
    if(intValues[j] < 0)
    {
        // 如果是第一个负数，则保存其值
        negativeValue = intValues[j];
        // 并终止循环
        break;
    }
}
System.out.println("第一个负数是"+negativeValue);