java 02 流程控制

java流程控制

用户交互Scanner

Java提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner 是Java5的新特征，我们可以通过Scanner类来获取用户的输入。
基本语法:
Scanner S = new Scanner(System. in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

• next():

  • 1、一定要读取到有效字符后才可以结束输入。
  • 2、对输入有效字符之前遇到的空白值（空格），next() 方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白值（空格）作为分隔符或者结束符。
  • 4、 next() 不能得到带有空格的字符串。

  public class Test {
      public static void main(String[] args) {
          //创建一个扫描器对象，用于接收键盘数据
          Scanner s = new Scanner(System.in);
          System.out.println("使用next方式接收-请输入: ");
          if (s.hasNext()) {    //判断用户有没有输入数据
              //使用next方式接收
              String str = s.next();//这行代码程序会等待用户输入完毕
              System.out.println("输出的内容为: " + str);
          }
          s.close();//凡是IO流的类，如果不关闭它就会一直占用资源，要关闭节省资源。
      }
  }
  

  next方式接收：如果不输入有效字符不会结束，会换行，输入（ 123456 789）会得到（123456），前面的空格会自动去掉，后面的空格和值也会被去掉。

• nextLine():

  • 1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
  • 2、可以获得空白。

  public class Test2 {
      public static void main(String[] args) {
          Scanner s = new Scanner(System.in);
          System.out.println("使用nextLine方式接收");
          if (s.hasNextLine()) {    //判断用户有没有输入数据
              //使用nextLine方式接收
              String str = s.nextLine();//这行代码程序会等待用户输入完毕
              System.out.println("输出的内容为: " + str);
          }
          s.close();//凡是IO流的类，如果不关闭它就会一直占用资源，要关闭节省资源。
      }
  }
  

  nextLine方式接收：（ 123456 789）会得到（ 123456 789）空格不会被去掉，敲回车来结束。不能换行

Scanner进阶使用

判断输入的数据类型是返回true，不是返回false。
hasNext();方法判断是否有数据获取不到空格，可以换行；
hasNextLine;方法判断是否有数据能获取到空格，因为以回车键结束不能换行；
nextInt();方法判断是否为int类型；
nextFloat();方法判断是否为float类型；
hasNextLong();方法判断是否为long类型;
hasNextDouble();方法判断是否为double类型;
更多可以方法查看JDK帮助文档

代码示例：

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数: ");
        if (scanner.hasNextInt()) {
            i = scanner.nextInt();
            System.out.println("整数数据:" + i);
        } else {
            System.out.println("输入的不是整数数据! ");
            System.out.println("请输入小数: ");
            f = scanner.nextFloat();
            if (scanner.hasNextFloat()) {
                f = scanner.nextFloat();
                System.out.println("小数数据: " + f);
            } else {
                System.out.println("输入的不是小数数据! ");
            }
        }
        scanner.close();
    }
}

顺序结构

JAVA的基本结构就是顺序结构。除非特别指明，否则就按照顺序一句一句执行。

• 顺序结构是最简单的算法结构。
• 语句与语句之间,框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

代码是从下到上一句一句执行就是顺序结构

public class Test {
    public static void main(String[] args) {
        System.out.println("hello1");//hello1
        System.out.println("hello2");//hello2
        System.out.println("hello3");//hello3
        System.out.println("hello4");//hello4
        System.out.println("hello5");//hello5
    }
}

选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示。

if单选择结构

if（布尔表达式）{
//如果布尔表达式的值为true则进入
}

if单选择结构语法:

if (true){	//if(布尔表达式)
    //如果布尔表达式为true将执行的语句
   System.out.println("进入if结构");
}

if双选择结构

if（布尔表达式）{
//如果布尔表达式的值为true则进入
}else{
//如果布尔表达式的值为false则进入
}

if双选择结构语法:

if (true){
    System.out.println("true");
}else{
    System.out.println("false");
}

switch多选择结构

多选择结构还有一个实现方式就是switch case语句。
switch case语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

switch语句中的变量类型可以是:

• byte、short、 int 或者char。
• 从Java SE 7开始switch支持字符串String类型了，同时case标签必须为字符串常量或字面量。

public class Test {
    public static void main(String[] args) {
        String next = "A";
        switch (next){
            case "A":
                System.out.println("选择了A");
                break;
            case "B":
                System.out.println("选择了B");
                break;
            case "C":
                System.out.println("选择了C");
                break;
            case "D":
                System.out.println("选择了D");
                break;
            default:
                System.out.println("选择没有以上的数值");
        }
    }
}

循环结构

while循环

while语句需要满足条件才能进入循环。
while是最基本的循环。
while循环语法：

while（布尔表达式） {
//循环内容
}
只要布尔表达式为true,循环就会- -直执行下去。

用while循环打印1~100：

public class Test {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
        }
    }
}

do...while循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
do...while循环和while循环相似，不同的是，do...while 循环至少会执行一次。
do...while循环语法：

do {
//代码语句
}while（布尔表达式）;

用do...while循环打印1~100：

public class Test {
    public static void main(String[] args) {
        int i = 0;
        do {
            i++;
            System.out.println("i="+i);
        }while (i<100);
    }
}

While和do-While的区别:

• while先判断后执行。dowhile是先执行后判断!
• do...while保证循环体会被至少执行一次!这是他们的主要差别。

代码：

public class Test {
    public static void main(String[] args) {
        int i = 0;
        while (i<0){
            System.out.println(i);
            i++;
        }
        System.out.println("分割线====");
        do {
            System.out.println(i);
            i++;
        }while (i<0);
    }
}

for循环

for循环执行的次数是在执行前就确定的。
for循环语法：

for（初始化;布尔表达式;迭代）{
//代码语句
}

for双重循环语法：

for（初始化;布尔表达式;迭代）{
//代码语句
for（初始化;布尔表达式;迭代）{
//代码语句
}a
}

for双重循环外层循环一次，内层循环一遍。

public class Test1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            System.out.println("--------i循环"+i+"次");
            for (int j = 1; j <= 3;j++){
                System.out.println("j循环"+j+"次");
            }
        }
    }
}

用for循环打印1~100：

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

关于for循环有以下几点说明:
最先执行初始化步骤。可以声明一种类型， 但可初始化一个成多个面环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为true. 循环体被执行。如果为false. 循环终止。开始执行循环体后面的语句。执行一次面环后，更新面环控制变量(迭代因子控制面环变量的增减。再次检测布尔表达式。循环执行上面的过程。
for死循环：

public class Test {
    public static void main(String[] args) {
        int a = 0;
        for ( ; ; ) {
            a++;
            System.out.println(a);
        }
    }
}

增强for循环

这里我们先只是见一面，做个了解，之后数组我们重点使用
Java5引入了一种主要用于数组或集合的增强型for循环。
Java增强for循环语法格式:

for（声明语句:表达式）{
//代码句子
}

增强for循环循环遍历数组：

public class Test {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50}; //定义了一个数组
        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

break、continue、goto

break：

（终止循环）
break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
(break语句也在switch语句中使用)
循环输出1到10，循环到6用barek结束循环：

public class Test1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
            if (i==6){
                System.out.println("i=6,结束循环");
                break;
            }
            System.out.println("i不等于6，循环中...");
        }
    }
}

break使用标签：
aa标签结束外层循环，如果不加标签则是结束内层循环。

public class Test1 {
    public static void main(String[] args) {
        aa:for (int i = 1; i <=3; i++) {
            System.out.println("i="+i);
            for (int j = 0; j<=3;j++){
                if (j==2){
                    System.out.println("j==2");
                    break aa;//aa标签结束外层循环，如果不加标签则是结束内层循环。
                }
                System.out.println("j===="+j);
            }
        }
    }
}

continue：

（结束本次循环进入下次循环）
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

循环输出10以内2的整除数（如果不是2的整除数则输出"不是2整除数"）：

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <=10; i++) {
            if (i%2==0){
                System.out.println(i);
                continue;
            }
            System.out.println("不是2整除数");
        }
    }
}

continue使用标签：
当内层循环到第2次时内层循环不会循环第3次，而是利用标签跳到外层循环。

public class Test1 {
    public static void main(String[] args) {
        aa:for (int i = 1; i <= 3; i++) {//当内层循环到第2次时内层循环不会循环第3次，而是利用标签跳到外层循环。
            System.out.println("--------i循环"+i+"次");
            for (int j = 1; j <= 3;j++){
                if (j==2){
                    System.out.println("···j循环第2次");
                    continue aa;
                }
                System.out.println("j循环"+j+"次");
            }
        }
    }
}

关于goto关键字
goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用; Java没有goto。然而，在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子---带标签的break和continue。
“标签" 是指后面跟-个冒号的标识符，例如: label:（上面的例子中的aa就是标签，标签名自定义）
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用,它们就会中断到存在标签的地方。