【达内课程】JAVA流程控制语句

for循环

我们用 IntelliJ IDEA 写一个 Java 程序

for (int i = 1; i <= 4; i++) {
	System.out.println("i = " + i);
}

运行程序，结果输出如下：

for 循环的执行顺序用上边的例子说明一下：
1、首先执行 int i = 1，并且只执行一次，定义初始化变量 i，赋值1
2、然后判断 i <= 4 结果为 true，则执行循环体打印 i = 1
3、循环体结束之后，执行 i++，然后 i 变成了2，继续判断 i <= 4 结果为true，则执行循环体打印 i = 2
4、如此循环执行，直到打印 i = 4之后，再执行 i++ 让 i 变成了 5，然后判断 i <= 4 结果为 false，循环结束。
5、这样就完成了 1~4 的输出，当然程序不是固定的，大家也可以把条件 i <= 4 修改为 i < 5，这样也是可以的。

练习：求阶乘、约数、派Π

我们用 Android Studio 写一个 Android 程序

    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10"
        android:inputType="textPersonName" />

    <Button
        android:id="@+id/button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="阶乘" />

    <Button
        android:id="@+id/button2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="约数" />

    <Button
        android:id="@+id/button3"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="π" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:textColor="#222222"
        android:textSize="18sp" />

public class MainActivity extends AppCompatActivity {
    EditText editText;
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //类中定义的变量称为成员变量
        editText = findViewById(R.id.editText);
        textView = findViewById(R.id.textView);
    }

    public void doClick(View view) {

        switch (view.getId()) {
            case R.id.button1:
                f1();
                break;
            case R.id.button2:
                f2();
                break;
            case R.id.button3:
                f3();
                break;
        }
    }

    /**
     * 阶乘
     */
    public void f1() {
        int a = Integer.valueOf(editText.getText().toString());
        int result = a;
        for (int i = a - 1; i >= 1; i--) {
            result = result * i;
        }
        textView.setText(result + "");
    }

    /**
     * 约数
     */
    public void f2() {
        int a = Integer.valueOf(editText.getText().toString());
        textView.setText("");
        for (int i = 1; i <= a; i++) {
            if (a % i == 0) {
                textView.append(i + "\n");
            }
        }
    }

    /**
     * π
     */
    public void f3() {
        int n = Integer.valueOf(editText.getText().toString());
        double sum = 0;
        //a、b是分子、分母，i控制累加次数
        for (int a = 1, b = 1, i = 0; i < n; a *= -1, b += 2, i++) {
            sum += a / (double) b;
        }
        double pi = sum * 4;
        textView.setText(pi + "");
    }
}

运行程序，结果如下：

关于 f1() 阶乘方法的一些说明

阶乘的定义
一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。
自然数n的阶乘写作n!。亦即n!=1×2×3×…×(n-1)×n。
阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。

关于 f2() 求约数的方法的一些说明

约数的定义
约数，又称因数。整数a除以整数b(b≠0)
除得的商正好是整数而没有余数，我们就说a能被b整除，或b能整除a。a称为b的倍数，b称为a的约数。

关于 f3() 求派Π的方法的一些说明

Π的计算方法

观察上边的规律，我们可以得知 计算规律是 加减交替 的，所以 a *= -1 来控制符号变化，分母是 +2 的，所以 b+=2 用来控制分母变化。具体可以一步一步演算下。

练习：循环嵌套
输出如下图案
写一个 Java 程序

for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println("");
        }

进阶练习，输出如下金字塔图形：

for (int i = 1; i <= 5; i++) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println("");
        }

练习：百元买百只鸡
公鸡5元1只
母鸡3元1只
小鸡1元3只
用100元恰好买100只鸡的组合

System.out.println("公鸡5元1只");
        System.out.println("母鸡3元1只");
        System.out.println("小鸡1元3只");
        //能买i只公鸡
        for (int i = 0; i < 20; i++) {
            //买完公鸡剩余钱
            int money = (100 - 5 * i);
            //买j只母鸡
            for (int j = 0; j < money / 3; j++) {
                //买k只小鸡
                int k = (money - 3 * j) * 3;

                if (i + j + k == 100) {
                    System.out.println("花完100元买100只鸡，要买" + i + "只公鸡，" + j + "只母鸡，" + k + "只小鸡");
                }
            }
        }

运行程序，结果如下：

if

顺序判断多个条件，只要执行了其中1个分支，就跳出if语句

if(条件1){
	//如果符合条件1，则执行条件1，然后跳出整个if语句	
}else if(条件2){
	//如果符合条件2，则执行条件2，然后跳出整个if语句		
}else{
	//如果条件1/2都不符合，则执行else里的语句		
}

练习：判断符号函数
要求，输入一个整数，如果输入正数，返回1；
如果输入负数，返回-1；
如果输入0，返回0；

我们用 IntelliJ IDEA 写一个 Java 程序

public class Main {

    public static void main(String[] args) {
        System.out.println("请输入整数：");
        int a = new Scanner(System.in).nextInt();

        int r = f(a);
        System.out.println(r);
    }

    static int f(int x) {
        if (x > 0) {
            return 1;
        } else if (x < 0) {
            return -1;
        } else {
            return 0;
        }
    }
}

运行程序，结果如下：

break

中断循环（跳出循环）

练习：产生>0.999的随机浮点数

//产生[0,1)的随机浮点数
    	/*double d = Math.random();
    	System.out.println(d);*/

        //需要打印出>0.999的浮点数
        for (int i = 0; ; i++) {
            double d = Math.random();
            if (d > 0.999) {
                System.out.println("第" + i + "次" + d);
                break;
            }
        }

运行程序，结果如下：

上面是在单循环中的应用场景，我们还会碰到多循环时的情况，首先写一个双循环程序，每行输出数字 0-7，输出 5 行：

for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print(j);
            }
            System.out.println();
        }

正常情况下运行程序，结果如下：

当我们使用 break

for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                if (j == 6) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }

运行结果如下：

可以看出 break 只能跳出1层循环

continue

Java continue 语句用来结束当前循环，并进入下一次循环，即仅仅这一次循环结束了，不是所有循环结束了，后边的循环依旧进行。

练习：跳过某个数字的输出

int[] numbers = {1, 2, 3, 4, 5, 6};
        for (int i = 0; i < numbers.length; i++) {
            if (i == 3) {
                continue;
            }
            System.out.println("Count is: " + i);
        }

运行程序，结果如下：

练习：带标签的 continue 程序测试

for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println(j);
            }
            System.out.println("test");
        }
        System.out.println("finish");

正常情况下输出

不使用标签的 continue

for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == 2) {
                    continue;
                }
                System.out.println(j);
            }
            System.out.println("test");
        }
        System.out.println("finish");

使用标签的 continue

outer:
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == 2) {
                    continue outer;
                }
                System.out.println(j);
            }
            System.out.println("test");
        }
        System.out.println("finish");

运行程序结果如下：

我们可以看到会连同外循环一起 break 掉，所以"test"没有打印。

continue 和 break 的区别
continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

练习：输入整数n，求n内质数数量

public class Main {
    public static void main(String[] args) {
        System.out.println("输入整数n，求n内质数数量");
        int n = new Scanner(System.in).nextInt();
        int r = f(n);
        System.out.println(r);
    }

    static int f(int n) {
        //count为记数，假设2是已知质数，count默认为1
        int count = 1;

        outer:
        for (int i = 3; i <= n; i++) {
            //最多除到i的开方，为避免开放后漏除，所以开方后+1
            //至于为什么可以打电话问问你们的小学体育老师,看看他是怎么教你数学的...
            double max = Math.sqrt(i) + 1;
            for (int j = 2; j < max; j++) {
                //i能被j整除
                if (i % j == 0) {
                    //直接跳出最外层循环
                    continue outer;
                }
            }
            count++;
        }
        return count;
    }
}

运行程序结果如下：

质数的定义
质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
100以内的质数有25个，分别是2、3、5、7、11、13、17、19、23、29、31、37、41、43、47、53、59、61、67、71、73、79、83、89、97

关于求质数方法的一些说明
根据质数的定义，我们可以使用 for 循环把输入的数字 N 用从 2 ~ N-1 范围的数开始除，如果都不能整除，说明是质数。所以假如我们输入 50，假设 2 是已知的质数，那么从 3 开始，
3 需要除 2
4 需要除 3、2
5 需要除 4、3、2
…
50 需要除 49、48、…、2

所以编写程序如下：

static int f(int n) {
        //count为记数，假设2是已知质数，count默认为1
        int count = 1;
        outer:
        for (int i = 3; i <= n; i++) {
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            count++;
        }
        return count;
    }

但这样做循环次数比较多，为了提高效率可以先将数字开平方，因为如果一个数不是素数是合数， 那么一定可以由两个自然数相乘得到， 其中一个大于或等于它的平方根，一个小于或等于它的平方根，并且成对出现。

while

while循环的一般语法是：

while( 表达式 ){
	语句；
}

其中，表达式是循环条件，语句为循环体。while语句的语义是：计算表达式的值，当值为真（非0）时，执行循环体语句，一旦条件为假，就停止执行循环体。如果条件在开始时就为假，则不执行循环体语句直接退出循环

练习：产生>0.99的随机浮点数需要的次数

int count = 0;
        double d = 0;
        while (d < 0.99) {
            d = Math.random();
            System.out.println("产生的随机数为："+d);
            count++;
        }
        System.out.println(count + "次结束：" + d);

运行程序，结果如下：

程序中的 d = Math.random(); 非常重要，这条语句通过修改 d 的值来修改循环条件，直到 d 的值大于 0.99，循环条件为假时退出循环。也就是说，循环条件中的变量，需要在循环中重新赋值，以逐渐改变循环条件的值，直到循环条件为假；否则循环将永远不会停止，这种循环称为“死循环”或者“无限循环”。
while(true)就是无限循环语句。因为括号中的条件为 true，所以永远不会跳出循环，除非语句块中有break语句才都能跳出循环。

练习：猜数字
随机产生1-1000范围内的整数，让用户猜数字，并提示猜结果的大小，直到猜对为止

//new Random().nextInt(1000)产生[0,1000)范围的随机整数
        //1+new Random().nextInt(1000)产生[1,1000]
        int r = 1 + new Random().nextInt(1000);
        System.out.println(r);
        while (true) {
            System.out.println("猜");
            int c = new Scanner(System.in).nextInt();
            if (c > r) {
                System.out.println("大");
            } else if (c < r) {
                System.out.println("小");
            } else {
                System.out.println("对");
                break;
            }
        }

运行程序如下：

do…while

do{
    执行语句；
}while(条件表达式);

do…while特点是条件无论是否满足，循环体至少被执行一次。

do…while 和 while 的不同
do…while 循环是先执行一次，再判断
while循环是先判断，再执行。如果条件不成立一次都不执行 ，而do…while循环是不管条件成不成立都先执行一次

double d = 1;
        do {
            System.out.println("条件为false，也运行了一次");
        } while (d < 0.99);

运行结果如下：

switch

关于 switch 的语法可以查看 Java switch case 语句

这里只说几个重要的点：
1、switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了
2、case 标签必须为字符串常量或字面量，可以是运算表达式，但一定要符合正确的类型。不能是变量，即便变量在之前进行了赋值，JVM依然会报错。
3、每个 case 后必须跟 break，否则程序会继续执行下一条 case 语句，直到出现 break 语句
case后为变量或表达式，只能是一个确切的值

练习：分数转换为五档分制
分数分为5个级别，分数大于等于90，小于等于100，为A。分数大于等于70，小于90，为B。规则如下：

A[90,100]
B[70,90)
C[60,70)
D[20,60)
E[0,20)

我们来写一个 Android Demo

XML代码

<EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="请输入分数"
        android:inputType="number" />

    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doClick"
        android:text="转换" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="18sp"
        android:textColor="#222222"
        android:gravity="center" />

java代码

public void doClick(View view) {
        TextView tv = findViewById(R.id.textView);
        EditText et = findViewById(R.id.editText);

        tv.setText(f(Integer.parseInt(et.getText().toString())));
    }

    String f(int s) {
        String r = "";
        if (s < 0 || s > 100) {
            return "填写有误";
        }
        switch (s / 10) {
            case 10:
            case 9:
                r = "A";
                break;
            case 8:
            case 7:
                r = "B";
                break;
            case 6:
                r = "C";
                break;
            case 5:
            case 4:
            case 3:
            case 2:
                r = "D";
                break;
            case 1:
            case 0:
                r = "E";
                break;
        }
        return r;
    }

运行结果如下：