Java架构师成长之道之程序流程控制

时间：2019-08-11 01:06:21 阅读：109 评论：0 收藏：0 [点我收藏+]

Java架构师成长之道之程序流程控制

Java架构师成长之道

4.1 程序流程控制概述

之前编写的绝大多数程序都是顺序执行，也就是从main函数开始，由上到下一行一行的执行，也被称为顺序结构。
在生活中除了顺序结构以外还有选择结构、循环结构，例如在淘宝购物时登录账号就是一个选择结构，如果输入的正确的用户名和密码才能购买商品，否则就会提示用户名密码错误。
而在淘宝首页的Banner就是一个循环结构,在指定的时间内循环切换图片。

在Java中，支持if/else和switch case两种选择结构，同时支持while，do...while,for循环以及JDK1.5以后支持foreach循环，同时还支持带标签的循环结构以及通过使用break,continue来中断循环。

4.2 使用Scanner类实现程序交互

平常在使用PC浏览电商网站时，如果想要购买商品通常需要输入用户名和密码来登录系统。
而登录的目的正是验证账号的合法性，在Java中可以使用Scanner类来模拟用户的输入数据，
可以读取的数据类型是boolean,byte,short,int,long,String,double等等，可以通过IDEA的Structure视图查看Scanner类的源码支持读取的类型。
技术图片

在Java程序中如果想要使用一个类，必须使用import关键字加上类的包名+类名+分号实现

import java.util.Scanner;

Java默认为所有的源文件导入java.lang包下的类，因此在之前编写的Java程序中使用的String,System等类无需使用import导入。
Java开发中常用的包还有util,io,nio,text,time等等。同学们有时间可以多去看看这些包下的源码实现，提升自己的编程功底。
技术图片

在导入之后便可以通过new关键字创建Scanner对象来模拟键盘，
同时在Scanner构造器中传入System.in作为数据的来源，表示来源于控制台

Scanner input =new Scanner(System.in);

使用Scanner读取用户信息并输出到控制台

package net.ittimeline.java.core.control;

import java.util.Scanner;

/**
 * 读取用户输入数据实现程序交互
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 17:49
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ScannerTest {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你的年龄");
        int age=input.nextInt();

        System.out.println("请输入你的身高");
        double height=input.nextDouble();

        System.out.println("请输入你的姓名");
        String name=input.next();

        System.out.println("你是男生么?");
        boolean genderFlag=input.nextBoolean()?Boolean.TRUE:Boolean.FALSE;

        if(genderFlag){
            System.out.printf("你的年龄是%d,你的姓名是%s,你的性别是男生，你的身高是%.2f",age,name,height);
        }
        else{
            System.out.printf("你的年龄是%d,你的姓名是%s,你的性别是女生，你的身高是%.2f",age,name,height);

        }
    }
}

交互效果

关于Scanner类的更多介绍以及使用方式，可以查阅JDK的API文档
技术图片

4.3 自定义PrintUtils类

PrintUtils类位于java-core-util模块中，使用Maven管理项目，关于Maven和IntelliJ IDEA的使用后面会详细介绍

工程模块总览以及PrintUtils概览

该类主要是对于System类的PrintStream对象封装，结合JDK1.5的静态导入特性，可以实现更加"简洁的数据输出"，方便程序调试

package net.ittimeline.java.core.util.lang;

/**
 * 控制台打印输出工具类
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:53
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class PrintUtils {


    /**
     * 打印输出对象的内容并换行
     * @param object
     */
    public static void println(Object object){
        System.out.println(object);
    }
    /**
     * 打印输出对象们的内容并换行
     * @param objects
     */
    public static void println(Object...objects){
        for (Object object:objects){
            println(object);
        }
    }



    /**
     * 打印分割
     */
    public static  void println(){
        System.out.println();
        System.out.println("*********************楚河汉界*********************");
    }

    /**
     * 打印输出对象的内容不换行
     * @param object
     */
    public static void print(Object object){
        System.out.print(object);
    }

    /**
     * 按照指定的格式打印输出内容
     * @param format
     * @param args
     */
    public static void printf(String format,Object...args){
        System.out.printf(format,args);
    }
}

4.4 选择结构if/else

if/else用于布尔类型的变量或者表达式作为条件判断来进行程序流程控制，if/else语句有如下三种形式

单if语句

单分支选择

if(true){
    //执行代码块的内容
}

使用Math.random()方法随机生成1-6的整数，然后判断大小

package net.ittimeline.java.core.control;
import static java.lang.System.out;
/**
 * if单选择结构
 *
 * if(true){
 *
 * }
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 10:27
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class Lottery {

    public static void main(String[] args) {

        //返回一个0.0-1.0(不包含1.0)之间的小数
        double dbl=Math.random();
        out.println("dbl ="+dbl);

        //产生1-6之间的随机数
        int number=(int)(dbl*6)+1;
        out.println("number = "+number);

        int target=3;
        if(number<=target){
            out.println("小");
        }


    }
}

使用Math.random()随机生成1-6的3个整数，判断手气

package net.ittimeline.java.core.control;
import static java.lang.System.out;
/**
 * 单if选择结构
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 10:33
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class Lottery2 {

    public static void main(String[] args) {
        double dbl=Math.random();
         int i,j,k;
         //创建三个1-6之间的随机整数数
         i = (int)(dbl*6)+1;
         j = (int)(dbl*6)+1;
         k = (int)(dbl*6)+1;


        out.println("i = "+i +" j = "+j +" k = "+k );


         //求三个随机数的和
         int point=i+j+k;

        out.println("point  = "+point);

        //根据随机数的和判断输出的内容
         if(point>15){
             out.println("今天手气很不错");
         }

         //只要满足if的bool表达式，就会执行代码块{}中的内容
         if(point>=10&&point<=15){
             out.println("今天手气一般");
         }
         if(point<10){
             out.println("今天手气不好");
         }

    }
}

if/else语句(二选一)

if/else

if(true){
    //执行代码块的内容
}
else{
    //执行代码块的内容
}

使用Math.random()产生1-6之间的随机整数，判断大小

package net.ittimeline.java.core.control;
import static java.lang.System.out;

/**
 * if/else择结构
 *
 * if(true){
 *
 * }
 * else{
 *
 * }
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 10:27
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class Lottery3 {

    public static void main(String[] args) {

        //返回一个0.0-1.0(不包含1.0)之间的小数
        double dbl=Math.random();
        out.println("dbl ="+dbl);

        //产生1-6之间的随机数
        int number=(int)(dbl*6)+1;
        out.println("number = "+number);

        int target=3;
        if(number<=target){
            out.println("小");
        }
        else{
            out.println("大");
        }


    }
}

判断用户输入的年份是否是闰年

package net.ittimeline.java.core.control.ifstatement;

import java.util.Scanner;

/**
 * 判断用户输入的年份是不是闰年
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 17:58
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class LeapYearCheck {

    public static void main(String[] args) {
        //创建虚拟键盘
        Scanner input =new Scanner(System.in);
        System.out.println("请输入年份");
        int year=input.nextInt();
        /**
         * 闰年判断的公式
         * 年份能被4整除不能被100整除 或者 年份不能被400整除
         * 
         * 2016 2020 都是闰年
         */
        boolean flag=(year%4==0&&year%100!=0)||year%400==0;
        if(flag){
            System.out.printf("你输入的年份%d是闰年",year);
        }
        else{
            System.out.printf("你输入的年份%d不是闰年",year);
        }


    }
}

使用if/else模拟淘宝登录

package net.ittimeline.java.core.control.ifstatement;


import java.util.Scanner;

/**
 * 模拟淘宝登录
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 18:09
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class TaobaoLogin {

    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);


        System.out.println("请输入你的用户名");
        String name =input.next();
        System.out.println("请输入你的密码");
        String password=input.next();

        String targetName="tony";
        String targetPassword="123456";

        if(targetName.equals(name)&&targetPassword.equals(password)){
            System.out.println("欢迎登录淘宝");
        }
        else{
            System.out.println("用户名或者密码输入错误，请检查");
        }


    }
}

用户名或者密码输入正确的运行结果
技术图片

if/else if /else(多选一)

if/else if /else

if(true){
    //执行代码块的内容
}
else if(true){
    //执行代码块的内容
}
else if(true){
    //执行代码块的内容
}
else{
    //执行代码块的内容
}

根据随机生成的年龄判断是青少年、中年、还是老年人

package net.ittimeline.java.core.control;

import java.util.Random;

/**
 * 年龄判断
 * if(){
 *
 * }
 * else if(){
 *
 * }
 * else{
 *
 * }
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 12:27
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class Age {

    public static void main(String[] args) {
        Random random=new Random();
        int age=random.nextInt(110)+1;
        System.out.println("age = "+age);
        if(age<=6){
            System.out.println("你是儿童");
        }
        else if(age>=7&&age<=14){
            System.out.println("你是少年");

        }
        else if(age>=15&&age<=35){
            System.out.println("你是青年人");
        }
        else if(age>=36&&age<=60){
            System.out.println("你是中年人");
        }
        else if(age>60){
            System.out.println("你是老年人");

        }
        else{
            System.out.println("无法识别你的年龄");
        }
    }
}

比较两个数的大小，如果大于返回1，小于返回-1，等于返回0

package net.ittimeline.java.core.control;
import static java.lang.System.out;

/**
 * if(){
 *     
 * }
 * else if(){
 *     
 * }
 * else{
 *     
 * }
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:43
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class IfElseIfElse {

    /**
     * 多选一
     * 用于比较两个数的大小
     * if/else if /else
     * @param testval
     * @param target
     * @return
     */
    static int test(int testval,int target){
        if(testval>target){
            return +1;
        }
        else if(testval<target){
            return -1;

        }
        else{
            return 0;
        }
    }

    public static void main(String[] args) {
        out.println(test(10,5));
        out.println(test(5,10));
        out.println(test(5,5));

    }
}

使用if/else if/else模拟相亲现场

package net.ittimeline.java.core.control.ifstatement;

import java.util.Scanner;

/**
 * 相亲现场
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 22:55
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class Marry {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入你的身高:(cm)");
        int height = input.nextInt();

        System.out.println("请输入你的财富:(千万)");
        double wealth = input.nextDouble();

        System.out.println("请输入你是否帅:(true/false)");
        boolean isHandsome = input.nextBoolean();


        //三个条件全满足
        if (height >= 180 && wealth >= 1 && isHandsome) {
            System.out.println("我一定要嫁给他!!");
        }
        //三个满足一个
        else if (height > 180 || wealth >= 1 || isHandsome) {
            System.out.println("嫁吧，比上不足比下有余");
        }
        //一个都不满足
        else {
            System.out.println("不嫁");
        }
    }
}

在进行复杂业务开发时，还会使用到嵌套的if/else

if(true){
    if(true){
        //执行代码块
        }
    else{
        //执行代码块
    }
}
else{
    //执行代码块
}

使用嵌套if和三元运算符求出三个整数的最大值

package net.ittimeline.java.core.operator.ternary;

/**
 * 求三个数中的最大值
 * 分别使用if/else if和三元运算符
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 16:58
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class GetMaxNumber {

    public static void main(String[] args) {

        int i=277;
        int j=20;
        int k=-99;

        int max=0;
        if(i>j){
            if(i>k){
                max=i;
            }
            else{
                max=k;
            }
        }

        System.out.println("使用if/else if实现求三个整数的最大值 max = "+max);

        max= i>j&&i>k?i:k;

        System.out.println("三个数中的最大值是"+max);
    }
}

使用死循环while和if/else实现将用户输入的三个整数排序
这里为什么要用死循环while呢？是为了方便测试各种数据排序场景

package net.ittimeline.java.core.control.ifstatement;

import java.util.Scanner;

/**
 * 使用If/else给用户输入的整数排序 按照从大到小
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 13:11
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class IfElseSort {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        while (true) {

            System.out.println("请输入第一个整数");
            int first = input.nextInt();

            System.out.println("请输入第二个整数");
            int second = input.nextInt();

            System.out.println("请输入第三个整数");
            int third = input.nextInt();


            //第一个数最小
            if (first < second && first < third) {
                if (second < third) {
                    System.out.println(first + " < " + second + " < " + third);
                } else if (second > third) {
                    System.out.println(first + " < " + third + " < " + second);
                }
            }

            //第二数最小
            else if (second < first && second < third) {
                if (first > third) {
                    System.out.println(second + " < " + third + " < " + first);

                } else if (first < third) {
                    System.out.println(second + " < " + first + " < " + third);

                }
            }
            //第三个数最小
            else if (third < first && third < second) {
                if (first > second) {
                    System.out.println(third + " < " +second + " < " + first);

                } else if (first < second) {
                    System.out.println(third + " < " + first + " < " + second);

                }
            }
        }


    }

}

4.5 选择结构switch/case

switch语句由一个表达式和多个case语句以及default语句组成，switch语句中表达式的数据类型只能是byte,short,char和int以及枚举(enum)类型，不能是boolean类型，否则会编译出错，同时在JDK7以后switch语句支持String类型。case之后只能声明常量值，不能声明范围,break关键字表示跳出switch语句，根据实际业务场景是可选的。而default语句类似于if/else的else语句，也是可选的，位置也是灵活的，但是通常放到最后一个case语句下面。

switch语句的执行流程
首先计算switch表达式的值，然后拿switch表达式的值和case语句的常量值和进行相等性判断，如果相等则会执行对应的case语句中的代码块，直到执行case语句中的break后跳出switch语句。
如果每个case语句的值和switch语句表达式的值不相等，则会执行default语句的代码块，直到遇到break结束switch语句。

switch(expression){
    case constant value :
        //代码块
        break;
    
    case constant value :
        //代码块
        break;
    
    case constant value :
        //代码块
        break;
    
    default :
        //代码块
        break;
}

使用switch/case实现等值判断

package net.ittimeline.java.core.control.switchstatement;

/**
 * switch case使用
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-05 10:58
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchTest {


    public static void main(String[] args) {
        //变量或者表达式的值只能是byte,short,char,int,enum,String
        int number=0;
        switch (number){
            case 1:
                System.out.println("number =1");
                //每一个case都需要break,break表示跳出switch语句
                break;
            case 2:
                System.out.println("number =2");

                break;
            case 3:
                System.out.println("number =3");
                break;
            case 4:
                System.out.println("number =4");
                break;
                //如果所有的case都不匹配，则会进入default
            default:
                System.out.printf("number =%d",number);

        }
    }
}

虽然Java没有强制规定每个case语句必须加上break，而C#(微软推出的一门编程语言)是规定case语句必须加上break。程序在执行时可能会得到错误的结果。

package net.ittimeline.java.core.control.switchstatement;

/**
 * switch not with case
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 13:12
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchDemo2 {

    public static void main(String[] args) {

        for (int i = 0; i <7 ; i++) {
            switch (i){
                case 1:
                    System.out.println("case 1");
                case 2:
                    System.out.println("case 2");
                case 3:
                    System.out.println("case 3");
                case 4:
                    System.out.println("case 4");
                case 5:
                    System.out.println("case 5");
                default:
                    System.out.println("default");

            }
        }
    }
}

程序运行结果
default
case 1
case 2
case 3
case 4
case 5
default
case 2
case 3
case 4
case 5
default
case 3
case 4
case 5
default
case 4
case 5
default
case 5
default
default

如果想要获取正确的运行结果，需要在case语句加上break，当执行到break时表示退出switch语句

package net.ittimeline.java.core.control.switchstatement;

/**
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 13:10
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchDemo {

    public static void main(String[] args) {
        for (int i = 0; i < 7; i++) {
            switch (i) {
                case 1:
                    System.out.println("case 1");
                    break;
                case 2:
                    System.out.println("case 2");
                    break;
                case 3:
                    System.out.println("case 3");
                    break;
                case 4:
                    System.out.println("case 4");
                    break;
                case 5:
                    System.out.println("case 5");
                    break;
                default:
                    System.out.println("default");
                    break;


            }

        }
    }
}

为什么Java不强制开发人员在使用switch/case时不强制加上break呢，因为有些场景虽然是不同的case值，但是执行的业务逻辑是一样的。

根据月份判断季节

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * 根据用户输入的月份判断季节
 *
 * 1,2,12是冬季
 * 3，4，5是春季
 * 6，7，8是夏季
 * 9，10，11是秋季
 * 12，1，2是冬季
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 18:23
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class JudegMonth {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入月份");
        int month = input.nextInt();

        switch (month) {
            case 1:
            case 2:
            case 12:
                System.out.printf("当前月份%d是冬季",month);
                break;
            case 3:
            case 4:
            case 5:
                System.out.printf("当前月份%d是春天",month);
                break;
            case 6:
            case 7:
            case 8:
                System.out.printf("当前月份%d是夏季",month);
                break;
            case 9:
            case 10:
            case 11:
                System.out.printf("当前月份%d是秋季",month);
                break;


        }
    }
}

根据用户输入的年月日判断是当年的第几天

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * 利用switch不带break的特性
 * 根据用户输入的年月日判断是当年的第几天
 * 如果switch case 不加break,程序会执行匹配到的case直到遇到break或者switch执行结束
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 09:41
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class GetDaysByMonthDay {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);


        System.out.println("请输入年份");
        int year = input.nextInt();


        //统计总天数
        int sumDays = 0;


        //判断用户输入的年份是否是闰年

        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            //如果是闰年 一年有366天
            System.out.printf("%d年是闰年\n", year);
            sumDays += 1;
        }


        System.out.println("请输入月份");

        int month = input.nextInt();

        System.out.println("请输入日(几号)");

        int day = input.nextInt();


        switch (month) {

            case 12:
                sumDays += 31;
            case 11:
                sumDays += 30;
            case 10:
                sumDays += 31;
            case 9:
                sumDays += 30;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 31;
            case 6:
                sumDays += 30;
            case 5:
                sumDays += 31;
            case 4:
                sumDays += 30;
            case 3:
                sumDays += 31;
            case 2:
                sumDays += 28;
            case 1:
                sumDays += day;

        }


        System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
    }
}

判断字符是元音还是辅音

package net.ittimeline.java.core.control.switchstatement;

import java.util.Random;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;

/**
 * 判断字符是元音还是辅音
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 12:42
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class VowelsAndConsonants {

    public static void main(String[] args) {
        Random random=new Random(88);
        for (int i=0;i<100;i++){
            //产生97-122之间的随机数
            int c=random.nextInt(26)+‘a‘;
            //打印 字符对应的数字以及是元音还是辅音
            print((char)c+", "+c);

            switch (c){
                //元音
                case ‘a‘:
                case ‘e‘:
                case ‘i‘:
                case ‘o‘:
                case ‘u‘:
                    print(",vowel");
                    break;
                case ‘y‘:
                case ‘w‘:
                    //有时候是元音
                    print(",Sometimes a vowel");
                    break;
                    //默认是辅音
                default:
                    print(",consonant");
            }
            println();
        }

    }
}

在JDK7以前，switch/case语句的条件表达式的类型只能支持byte,short,int,char和enum，而String是日常开发中最常用的数据类型，在JDK7后switch/case终于支持String。

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * JDK7新特性-switch支持String类型
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 18:32
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchString {


    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        String description;
        System.out.println("请输入你的性别");
        String gender = input.next();

        /**
         * 根据输入的性别生成招呼用语
         */
        switch (gender) {
            case "男":
                description = "你好,先生";
                break;
            case "女":
                description = "你好,女士";
                break;
            default:
                description="你好";
                break;
        }

        System.out.println(description);
    }
}

但是由于switch/case语句的case 值是不能重复的，在使用String时尤其要注意。因为在Java中字符串可以使用Unicode字符来替换，也可能造成case值重复。

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * JDK7新特性-switch支持String类型
 * case 值 重复
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-04 18:32
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchString2 {


    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        String description;
        System.out.println("请输入你的性别");
        String gender = input.next();

        /**
         * 根据输入的性别生成招呼用语
         */
        switch (gender) {
            case "男":
                //字符串男对应的unicode编码就是\u7537
           // case "\u7537":
                description = "你好,先生";
                break;

            case "女":
                description = "你好,女士";
                break;
            default:
                description="你好";
                break;
        }

        System.out.println(description);
    }
}

使用switch/case实现基于字符和字符串的小写字母转大写字母

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * 使用switch/case分别基于字符串和字符实现将小写字母转换为大写字母
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-05 15:34
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class SwitchLowerCaseUpperCase {

    public static void main(String[] args) {


        Scanner input = new Scanner(System.in);
        System.out.println("请输入需要转换的小写字母:");
        String lowercase = input.next();
        String uppercase = "";
        switch (lowercase) {
            case "a":
            case "b":
            case "c":
            case "d":
            case "e":
            case "f":
            case "g":
            case "h":
            case "i":
            case "j":
            case "k":
            case "l":
            case "m":
            case "n":
            case "o":
            case "p":
            case "q":
            case "r":
            case "s":
            case "t":
            case "u":
            case "v":
            case "w":
            case "x":
            case "y":
            case "z":
                //直接使用String类封装的toUpperCase方法实现小写字母转大写字母
                uppercase = lowercase.toUpperCase();
                break;
        }

        //输出转换结果 这里的%s表示字符串
        System.out.printf("基于字符串小写字母%s转换为大写字母的结果是%s\n", lowercase, uppercase);

        //获取输入字符串中的第一个字符
        Character ch = lowercase.charAt(0);
        switch (ch) {
            case ‘a‘:
            case ‘b‘:
            case ‘c‘:
            case ‘d‘:
            case ‘e‘:
            case ‘f‘:
            case ‘g‘:
            case ‘h‘:
            case ‘i‘:
            case ‘j‘:
            case ‘k‘:
            case ‘l‘:
            case ‘m‘:
            case ‘n‘:
            case ‘o‘:
            case ‘p‘:
            case ‘q‘:
            case ‘r‘:
            case ‘s‘:
            case ‘t‘:
            case ‘u‘:
            case ‘v‘:
            case ‘w‘:
            case ‘x‘:
            case ‘y‘:
            case ‘z‘:
                //小写字母的编码减去32就是大写字母的编码
                int upperCaseNumber = (int) ch - 0x20;
                //将数字转换为对应的字符
                Character uppperCase = Character.valueOf((char) upperCaseNumber);
                //输出转换结果，这里的%c表示字符
                System.out.printf("基于字符 小写字母%c转换为大写字母的结果是%c\n", ch, uppperCase);
                break;

        }


    }
}

switch/case和if/else语句的比较

凡是可以使用switch/case的结构，都可以使用if/else转换。反之不成立
选择结构中，即可以使用switch/case，又可以使用if/else时，优先使用switch case，因为switch/case执行效率稍高
switch case适合做等值判断，if/else适合做区间判断。

package net.ittimeline.java.core.control.switchstatement;

import java.util.Scanner;

/**
 * 根据用户输入的分数判断等级
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 10:46
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class GetGradeByScore {

    public static void main(String[] args) {

        Scanner input= new Scanner(System.in);
        System.out.println("请输入你的分数");
        int score=input.nextInt();
        String ifElseGrade=getGradeByScoreIfElse(score);
        System.out.printf("if else结构实现  分数%d对应的等级是%s\n",score,ifElseGrade);
        String switchCaseGrade=getGradeByScoreSwitchCase(score);
        System.out.printf("switch case结构实现  分数%d对应的等级是%s\n",score,switchCaseGrade);


    }


    /**
     * 使用if/else实现根据用户输入的分数获取等级
     * @param score
     * @return
     */
    public static String getGradeByScoreIfElse(int score){
        String grade="";
        if(score>90){
            grade="A";
        }
        else if(score>=70&&score<80){
            grade="B";
        }
        else if(score>=60&&score<70){
            grade="C";
        }
        else if((score<60)){
            grade="D";
        }
        return grade;
    }


    /**
     * 使用if/else实现根据用户输入的分数获取等级
     * @param score
     * @return
     */
    public static String getGradeByScoreSwitchCase(int score){
        String grade="";
        int value=score/10;
        switch (value){

            case 9:
                grade="A";
                break;
            case 8:
            case 7:
                grade="B";
                break;
            case 6:

                grade="C";
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
                grade="D";
                break;
        }
        return grade;
    }
}

4.6 循环结构while和do/while

每个循环结构都有如下四个要素

1.初始化条件
2.循环条件必须是boolean类型
3.循环体
4.迭代条件

而循环结构的执行流程是
循环的执行顺序
1.初始化条件
2.循环条件
3.循环体
4.迭代条件

2.循环条件
3.循环体
4.迭代条件

2.循环条件
3.循环体
4.迭代条件
...

while循环的结构是

while(boolean_expression){
    statement;
    [iterator_statement]
}

当boolean_expression为true时，就会循环执行代码块中的内容，直到遇到boolean_expression为false则会退出while循环。

package net.ittimeline.java.core.control.whilestatement;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;

/**
 * 使用while循环判断随机数是否小于0.99
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 12:46
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class WhileTest {


    /**
     * 定义condition方法作为while循环的条件
     * @return Math.random()是否小于0.99
     */
    static boolean condition(){
        boolean result=Math.random()<0.99;
        println("result = "+result);
        return result;
    }

    public static void main(String[] args) {

        while (condition()){
            println("Inside  ‘while‘");
        }
       println("Exited ‘while‘");
    }
}

使用while循环计算1-100以内的偶数和,借助该程序理解循环的四要素
在写while循环时特别容易忘记写迭代条件，如果while循环没有迭代条件，则会变成死循环，
在程序开发中应该尽量避免出现死循环。

package net.ittimeline.java.core.control.whilestatement;

/**
 * 计算1-100以内的偶数
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 17:28
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class While100EvenNumber {




    public static void main(String[] args) {

        /**
         * 循环四要素
         *
         * 1.初始化条件
         * 2.循环条件 必须是boolean类型
         * 3.循环体
         * 4.迭代条件
         */


        //1.循环的初始条件
        int sum=0;
        int i=1;
        //2.循环条件
        while (i<=100){
            //3.循环体
            if(i%2==0){
                sum+=i;
            }
            //4.循环的迭代条件
            i++;
        }

        System.out.println("1-100以内的偶数和是"+sum);
    }
}

while循环和for循环可以相互替换,使用for循环实现1-100以内的偶数和

package net.ittimeline.java.core.control.forstatement;

/**
 * 求100以内的偶数
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 11:22
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class For100EvenNumber {

    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <=100 ; i++) {

            if(i%2==0){
                sum+=i;
            }
        }

        System.out.println("1-100以内的偶数和是"+sum);
    }
}

do/while循环在日常开发中几乎不怎么用，它和while循环的区别就是至少执行一次循环体的内容

do/while循环和while循环的对比

package net.ittimeline.java.core.control.whilestatement;
import  static net.ittimeline.java.core.util.lang.PrintUtils.*;
/**
 * while循环和do/while循环的区别
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 18:52
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class DoWhileTest {



    /**
     * 测试while循环
     * @param number
     */
    public static void testWhile(int number){

        while (number<10){
            System.out.println(" while循环 number = "+number++);
        }
    }

    public static void testDoWhile(int number){
        do{
            System.out.println(" do while循环 number = "+number++);


        }while (number<10);
    }



    public static void main(String[] args) {

        /**
         * 当while循环和do/while循环都满足循环条件时，while循环和do/while循环是等价的
         */
        int number=1;
        testWhile(number);
        testDoWhile(number);
        /**
         * 当while循环的循环条件不满足时,do...while循环会比while循环多执行一次
         */
        number=10;
        testWhile(number);
        println();
        testDoWhile(number);

    }
}

4.7 循环结构for

for循环是日常开发程序中使用最多的循环结构，与while循环的不同之处在于for循环的循环初始条件(变量)只能在for循环内使用，而while循环的循环初始条件(变量)可以在whiel循环外部使用。

for循环的循环结构也是由之前提到的循环结构四要素组成，执行顺序也和while一样

for(循环的初始条件;循环条件;迭代条件){
    循环体
}

使用for循环输出1-100

package net.ittimeline.java.core.control.forstatement;

/**
 * for循环打印输出1-100
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-07-30 16:47
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForTo100 {

    public static void main(String[] args) {
        for (int i =1;i<=100;i++){
            System.out.print(i+" ");
        }
    }
}

使用for循环求1-100以内的和

package net.ittimeline.java.core.control.forstatement;

/**
 * 求1-100以内的和
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 11:24
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class For100Sum {

    public static void main(String[] args) {
        //定义变量保存相加的和
        int sum=0;
        for (int i = 1; i <=100 ; i++) {
            //循环累加
            sum+=i;
        }
        System.out.println("1到100以内的和是"+sum);
    }
}

编写程序从1循环到150，并且每行打印一个值,另外在每个3的倍数行上打印foo, 在每个5的倍数行上打印biz, 在每个7的倍数行上打印baz

 package net.ittimeline.java.core.control.forstatement;

/**
 * 编写程序从1循环到150，并且每行打印一个值
 * 另外在每个3的倍数行上打印foo
 * 在每个5的倍数行上打印biz
 * 在每个7的倍数行上打印baz
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 11:28
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForTo150 {

    public static void main(String[] args) {

        for (int i = 1; i < 150; i++) {

            if (i % 3 == 0) {
                System.out.println(i + " foo ");

            }
            if (i % 5 == 0) {
                System.out.println(i + " biz ");

            }
            if (i % 7 == 0) {
                System.out.println(i + " baz ");

            } else {
                System.out.println(i);

            }

        }
    }
}

输入两个正整数m和n,求其最大公约数和最小公倍数

最大公约数:两个数同时能被除尽的最大值
最小公倍数:同时是两个数的倍数的最小值
比如12和20的最大公约数是4，最小公倍数是60

package net.ittimeline.java.core.control.forstatement;

import java.util.Scanner;

/**
 * 输入两个正整数m和n,求其最大公约数和最小公倍数
 * 最大公约数:两个数同时能被除尽的最大值
 * 最小公倍数:同时是两个数的倍数的最小值
 * 比如12和20的最大公约数是4，最小公倍数是60
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 15:53
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForGreatestCommonDivisorLeastCommonMultiple {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入第一个数");
        int m = input.nextInt();

        System.out.println("请输入第二个数");
        int n = input.nextInt();


        //定义变量保存最大公约数
        int greatestCommonDivisor = 0;

        //定义变量保存最小公倍数
        int leastCommonMultiple = 0;


        int min = m > n ? n : m;
        //求最大公约数

        /**
         * 查找最大公约数 循环的次数 可以在用户输入的两个整数中最小的那个值的次数之内
         * 如果找到了就中断循环
         */
        for (int i = min; i >= 1; i--) {
            if ((n % i) == 0 && (m % i) == 0) {
                System.out.println(" i =" + i);
                greatestCommonDivisor = i;
                break; //跳出for循环
            }
        }
        System.out.printf("%d和%d的最大公约数是%d \n", m, n, greatestCommonDivisor);

        //求最小公倍数
        int num = m * n;
        for (int i = 0; i < num; i++) {

            if (num % m == 0 && num % n == 0) {
                leastCommonMultiple = num / m;
                break; //跳出for循环
            }

        }
        System.out.printf("%d和%d的最小公倍数是%d \n", m, n, leastCommonMultiple);

    }

}

使用for循环输出指定范围内的所有水仙花数字

package net.ittimeline.java.core.control.forstatement;

import java.util.Scanner;

/**
 * 使用for循环输出指定范围内的所有水仙花数字
 *
 *
 * 水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），
 * 水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。
 *
 *
 * 实现思路
 * 首先通过取模运算获取三位数的各个数字
 * 然后使用Math.pow函数实现求各个数字的三次幂运算
 * 再把三个整数的幂运算求和，和用户输入的数字进行比较
 * 如果相等，那就是水仙花数
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 16:46
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForNarcissisticNumber {

    public static void main(String[] args) {

        Scanner input=new Scanner(System.in);
        System.out.println("请输入你要在指定范围内查找的水仙花数【100-999】");



        int number=input.nextInt();
        for (int i=100;i<number;i++){

            int hundereds=i/100;
            int decade=i/10%10;
            int theUnit=i%10;

            int narcissisticNumber=(hundereds*hundereds*hundereds)+(decade*decade*decade)+(theUnit*theUnit*theUnit);


            if(i==narcissisticNumber){
                System.out.printf("你输入的数字%d是水仙花数\n",i);
            }else{
                System.out.printf("你输入的数字%d不是水仙花数\n",i);

            }

        }
    }
}

4.8 死循环

当某些业务场景不知道循环的次数时，可以使用死循环实现.
while循环的死循环结构为

while(true){
    //循环体
}

for循环的死循环结构为

for(;;){
    //循环体
}

从键盘读取个数不确定的数，并判断读入的正数和负数的个数，输入0时结束程序

package net.ittimeline.java.core.control.forstatement;

import java.util.Scanner;

/**
 * for和while死循环应用场景
 * 从键盘读取个数不确定的数，并判断读入的正数和负数的个数，输入0时结束程序
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 19:34
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForWhileDeadLoop {


    public static void main(String[] args) {

        //正数个数的数量
        int  positiveNumberCount=0;
        //负数个数的数量
        int negativeNumberCount=0;

        Scanner input =new Scanner(System.in);


        //使用while循环实现
        while (true){
            System.out.println("while循环 请输入数字");
            int number=input.nextInt();
            if(number>0){
                positiveNumberCount++;

            }
            else if(number<0){
                negativeNumberCount++;
            }

            if (number==0){
                break;//中断并跳出循环
            }

        }

        System.out.printf("while循环输入的正数数量是%d,输入的负数数量是%d\n",positiveNumberCount,negativeNumberCount);

        //使用for循环实现
        for (;;){
            System.out.println("for循环 请输入数字");
            int number=input.nextInt();
            if(number>0){
                positiveNumberCount++;

            }
            else if(number<0){
                negativeNumberCount++;
            }

            if (number==0){
                break;//中断并跳出循环
            }
        }



        System.out.printf("for循环输入的正数数量是%d,输入的负数数量是%d\n",positiveNumberCount,negativeNumberCount);

    }
}

4.9 循环中断-break和continue

break在循环中表示结束循环，如果是嵌套循环，
continue表示结束本次循环，直接进入下一次循环。

break和continue关键字之后的语句都不会再被执行。

break和continue默认结束包含此关键字最近的循环，如果想要break和continue结束外层循环，可以使用带标签的循环实现。

package net.ittimeline.java.core.control.breakcontinue;

import static net.ittimeline.java.core.util.lang.PrintUtils.*;

/**
 * 理解break和continue关键字的作用
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 22:29
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class BreakAndContinueSimple {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 9) {
                break; //跳出当前循环
                // print(" i = "+i); //不可达代码

            }
            if (i % 3 == 0) {
                continue; //结束本次循环，调到下次循环
                // print(" i = "+i); //不可达代码
            }
            println(" i = " + i);
        }
    }
}

理解break和continue关键字在循环中的作用

package net.ittimeline.java.core.control.breakcontinue;

import static net.ittimeline.java.core.util.lang.IntArrayGeneratorUtils.*;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;

/**
 * 循环中断
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 10:45
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class BreakAndContinue {

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            if (i == 76) {
                break;
            }
            if (i % 9 != 0) {
                continue;
            }
            //输出0-75之间能被9整除的数字
            System.out.print(i + " ");
        }
        println();

        //foreach循环
        for (int i : range(100)) {
            if (i == 76) {
                break;
            }
            if (i % 9 != 0) {
                continue;
            }
            //输出0-75之间能被9整除的数字
            System.out.print(i + " ");
        }
        println();

        int i = 0;
        while (true) {
            i++;
            int j = i * 27;
            if (j == 1269) {
                break;
            }

            if (i % 10 != 0) {
                continue;
            }
            System.out.print(i + " ");
        }


    }
}

4.10 JDK1.5新特性-foreach循环

foreach在C#语言中是一个关键字，而Java中的foreach循环是for循环实现的，它通常用于遍历Java中常用的数据结构，例如数组、链表等等。

其循环结构为

for(数据类型 变量名:数据结构){
    循环体
}

这里主要先演示使用foreach遍历数组，关于数组的详细介绍，会在下一章给出。

首先在java-core-util模块中实现一个整型数组生成器

package net.ittimeline.java.core.util.lang;

/**
 * 数组生成器
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 10:47
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class IntArrayGeneratorUtils {

    /**
     * 创建一个指定大小的整数数组
     * @param size
     * @return
     */
    public static int[] range(int size){
        int[] result=new int[size];
        for (int i=0;i<size;i++){
            result[i]=i;
        }
        return result;
    }


    /**
     * 生成一个指定区间的整数数组
     * @param start
     * @param end
     * @return
     */
    public static int[] range(int start,int end){
        int size=end-start;
        int[]result=new int[size];
        for (int i=start;i<size;i++){
            result[i]=start+i;
        }
        return result;
    }


    /**
     * 生成一个指定区间的整数数组
     * @param start 循环的开始条件
     * @param end
     * @param step
     * @return
     */
    public static int[] range(int start,int end,int step){
        int size=(end-start)/step;
        int[] result=new int[size];
        for (int i=0;i<size;i++){
            result[i]=start+(i*step);
        }
        return result;
    }
}

使用foreach遍历整型数组

package net.ittimeline.java.core.control.foreach;
import static net.ittimeline.java.core.util.lang.IntArrayGeneratorUtils.*;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;
/**
 * foreach遍历整型数组
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:19
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForeachInt {

    public static void main(String[] args) {

        for (int i:range(10)){
            print(i+" ");
        }
            println();

        for (int i:range(1,15)){
            System.out.print(i+" ");
        }

        println();

        for (int i:range(1,15,2)){
            System.out.print(i+" ");
        }
    }
}

使用foreach遍历字符串

package net.ittimeline.java.core.control.foreach;

/**
 * 遍历字符串
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:24
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForeachString {
    public static void main(String[] args) {

        String bookName="Java编程思想第四版";
        //字符串的本质是字符数组
        for (char ch:bookName.toCharArray()){
            System.out.print(ch+" ");
        }

    }
}

使用foreach遍历浮点类型数组

package net.ittimeline.java.core.control.foreach;

import java.util.Random;

/**
 * foreach遍历浮点类型数组
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:16
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForeachFloat {

    public static void main(String[] args) {
        Random random=new Random(88);
        float[]floats=new float[10];
        for (int i=0;i<floats.length;i++){
            floats[i]=random.nextFloat();
        }

        for (float f:floats){
            System.out.println("f = "+f);
        }

    }
}

4.11 循环嵌套

当把一个循环结构(循环B)声明在另外一个循环结构(循环A)的循环体中，此时就构成了循环的嵌套，此时循环A被称作为外层循环，循环B被称为内层循环。

嵌套循环的执行流程是外层循环执行一次，内层循环执行一遍。
假设外层循环循环m次，内层循环循环n次，那么内层循环的总次数是m*n次。

package net.ittimeline.java.core.control.forstatement;

/**
 * 理解嵌套循环结构
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 20:02
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForForStructureTest {

    public static void main(String[] args) {
        //外层循环执行一次
        for (int i=1;i<=3;i++){
            //内层循环执行五次
            for (int j=1;j<=5;j++){
                System.out.println("i = "+i +" j = "+j);
            }
        }
    }
}

使用嵌套for循环实现打印九九乘法表

package net.ittimeline.java.core.control.forstatement;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;

/**
 * 循环嵌套
 * 实现九九乘法口诀表
 * 1 * 1 = 1	
 * 1 * 2 = 2	2 * 2 = 4	
 * 1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
 * 1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
 * 1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
 * 1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
 * 1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
 * 1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
 * 1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 19:53
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForForMultiplicationTableTest {

    public static void main(String[] args) {

        int number=9;
        //外层循环控制行
        for (int i=1;i<=number;i++){
            //内层循环控制每行的列
            for (int j=1;j<=i;j++){
                print(j+ " * "+i+" = "+(i*j)+"\t");
            }
            //如果一行执行完则换行
            println("");
        }
    }
}

使用for循环打印菱形

package net.ittimeline.java.core.control.forstatement;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;
/**
 * 使用嵌套for循环打印菱形
 *
 *     *
 *    * *
 *   * * *
 *  * * * *
 * * * * * *
 *  * * * *
 *   * * *
 *    * *
 *     *
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 20:18
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class ForForRhombus {

    public static void main(String[] args) {

        /**
         * 打印菱形实现步骤
         * 首先将菱形拆解为两个等腰三角形
         * 然后分别用两个嵌套循环打印
         * 每个嵌套循环中，外层循环控制行数，内层循环控制输出的内容:即空格和*
         *
         *
         *
         */



        String star="* ";

        /**
         *  第一个for循环
         * 外层控制循环次数 一共是五次,因为等边三角形占了5行
         * 内层循环控制内容 内层循环的第一个循环先打4-i个空格，内层循环的第二个循环打印i
         *
         *
         * * * *
         *    * *
         *   * * *
         *  * * * *
         * * * * * *
         *
         *
         *
         */

        //第一个嵌套for循环

        //外层循环控制行数
        for (int i=0;i<5;i++){

            //内层循环控制每行的内容

            for (int j=0;j<4-i;j++){
                print(" ");
            }
            for (int k=0;k<=i;k++){
                print(star);
            }

            println("");
        }

        /**
         * * * * *
         *  * * *
         *   * *
         *    *
         */

        //总共是9行，上一次循环是5行，这里外层循环就只需要四次

        for (int i=4;i>0;i--){
            //打印空格 空格的个数是4-i
            for (int j=0;j<=4-i;j++){
                print(" ");
            }
            //打印星星
           for (int k=0;k<i;k++){
               print("* ");
           }
        //换行
           println("");
        }



    }
}

使用嵌套for循环实现求1-100以内的质数

package net.ittimeline.java.core.control.forstatement;

/**
 * 查找1-100以内的质数
 * 质数:只能被1和自身整除的数->从2开始，到这个数减1结束为止，都不能被这个数本身整除
 * 最小的质数是2
 * 能被1和自身整除的数字
 * @author liuguanglei 18601767221@163.com
 * @create 2019-07-30 16:53
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class FindPrimesTo100 {
    public static void main(String[] args) {
        int max=100;
        for (int i=2;i<max;i++){
            boolean prime=true;

            for (int j=2;j<i;j++){
                if(i%j==0){
                    prime=false;
                }
            }
            if(prime){
                System.out.println(i+" ");
            }
        }
    }
}

使用嵌套for循环实现求1-100000以内的质数，并统计执行的时间(毫秒数)

package net.ittimeline.java.core.control.forstatement;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;
/**
 * 查找1-100000以内的质数
 * 质数:只能被1和自身整除的数->从2开始，到这个数减1结束为止，都不能被这个数本身整除
   最小的质数是2
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 21:30
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class FindPrimersTo100000 {

    public static void main(String[] args) {

        /**
         * 从2开始，到这个数减1结束为止，都不能被这个数本身整除
         */

        int count=0;
        boolean isPrimer=true;
        //返回当前时间的毫秒数
        long startTime=System.currentTimeMillis();
        int number=10_0000;

        for (int i=2;i<=number;i++){
            for (int j=2;j<i;j++){
                if(i%j==0){
                    isPrimer=false;
                }
            }

            if(isPrimer){
               // System.out.println("i = "+i);
                count++;
            }

            isPrimer=Boolean.TRUE;
        }
        long endTime=System.currentTimeMillis();


        printf("计算%d以内所有的质数耗时毫秒数为%d,质数的数量为%d",number,(endTime-startTime),count);


      // 程序输出结果 计算1-1000000所有的质数耗时毫秒数为11603,质数的数量为9592
    }
}

程序优化之后，再次使用嵌套for循环实现求1-100000以内的质数，并统计执行的时间(毫秒数)

package net.ittimeline.java.core.control.forstatement;

import static net.ittimeline.java.core.util.lang.PrintUtils.printf;

/**
 * 查找1-100000以内的质数
 * 质数:只能被1和自身整除的数->从2开始，到这个数减1结束为止，都不能被这个数本身整除
   最小的质数是2
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-10 21:30
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class FindPrimersTo100000Optimize {

    public static void main(String[] args) {

        /**
         * 从2开始，到这个数减1结束为止，都不能被这个数本身整除
         */

        boolean isPrimer=true;
        int count =0;
        long startTime=System.currentTimeMillis();
        int number=10_0000;
        for (int i=2;i<=number;i++){
            for (int j=2;j<=Math.sqrt(i);j++){
                if(i%j==0){
                    isPrimer=false;
                    break; //优化 支队本身非质数的自然数有效的
                }
            }

            if(isPrimer){
                count++;
            }

            isPrimer=Boolean.TRUE;
        }
        long endTime=System.currentTimeMillis();

        printf("计算%d以内所有的质数耗时毫秒数为%d,质数的数量为%d",number,(endTime-startTime),count);

        //程序输出结果:计算100000以内所有的质数耗时毫秒数为11,质数的数量为9592

    }
}

4.12 循环结构-带标签的循环

在循环嵌套时，如果希望在内层循环中断到外层循环时，可以使用带标签的循环实现。
带标签的循环结构如下所示

outer: for(){

    inner:for(){
        
        break outer;
    }
    
}

带标签的for循环

package net.ittimeline.java.core.control.forlabel;

import static java.lang.System.out;

/**
 * 带标签的for循环
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:46
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class LabeledFor {
    public static void main(String[] args) {
        int i = 0;
        outer:
        for (; true; ) {
            inner:
            for (; i < 10; i++) {
                out.println(" i= " + i);
                if (i == 2) {
                    out.println("continue");
                    continue;
                }
                if (i == 3) {
                    out.println("break");
                    break;
                }
                if (i == 7) {
                    out.println("continue outer");
                    i++;
                    //结束本次循环，调到外层循环
                    continue outer;
                }

                if (i == 8) {
                    out.println("break outer");
                    break outer;
                }
                for (int k = 0; k < 5; k++) {
                    if (k == 3) {
                        out.println("continue inner");
                        continue inner;
                    }
                }

            }

        }
    }
}

带标签的while循环

package net.ittimeline.java.core.control.forlabel;
import static net.ittimeline.java.core.util.lang.PrintUtils.*;
/**
 * 带标签的while循环
 *
 * @author liuguanglei 18601767221@163.com
 * @create 2019-08-02 11:52
 * @website www.ittimeline.net
 * @since JDK11.03
 */
public class LabeledWhile {
    public static void main(String[] args) {
        int i=0;
        outer:
        while(i<9){
           int j=0;
          inner:while (j<9){
               if(j==6){
                   break outer;
               }
               println(" i = "+i+" j = "+j);
               j++;
           }
           i++;
        }
    }
}

Java架构师成长之道之程序流程控制

标签：eee 注意格式实现返回无法外部 com block

原文地址：https://www.cnblogs.com/ittimeline/p/11333312.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行