跳出循环中break、continue、return 、循环标记方式含义

continue：中止本次循环，继续下次循环。continue以后的循环体中的语句不会继续执行，下次循环继续执行，循环体外面的会执行

break：直接结束一个循环，跳出循环体。break以后的循环体中的语句不会继续执行，循环体外面的会执行

return：return的功能是结束一个方法。 一旦在循环体内执行return，将会结束该方法，循环自然也随之结

循环标记场景：多层循环，如果在里层循环，达到某个条件后，结束指定循环

continue：
continue语句和break语句差不多。不同的是，它不是退出一个循环，而是跳出当前循环，进行下一轮循环。（不往下执行循环内的语句,直接返回最内层的循环开头,并继续执行循环。）

        List<String> c = Arrays.asList("1", "2", "3", "4", "5");
        for (int i = 0; i < 2; i++) {
            for (String s : c) {
                if (s.equals("3")) {
                    continue;
                }
                System.out.print(s + " ");
            }
        }
        //输出 1 2 4 5 1 2 4 5 

break：
break语句只有在循环语句和switch语句中使用才是合法的，经常用来跳出循环，不会执行后续循环，但是会继续执行循环之后的。（跳出所在的循环体， 并且可以执行循环外的程序。）

        List<String> c = Arrays.asList("1", "2", "3", "4", "5");
        for (; ; ) {
            for (String s : c) {
                System.out.print(s + " ");
                if (s.equals("3")) {
                    break;
                }
            }
            System.out.println("跳出内循环");
            break;//跳出当前死循环
        }
        //输出 1 2 3 跳出内循环

return：
（在循环体内执行return，将会结束该方法，循环直接结束。）

        List<String> c = Arrays.asList("1", "2", "3", "4", "5");
        for (; ; ) {
            for (String s : c) {
                System.out.print(s + " ");
                if (s.equals("3")) {
                    return;
                    //这里return后下面都是废物代码，不会运行的
                }
            }

            System.out.println("上面满足条件，return出当前方法了，这里代码是不会执行到的,");
            return;
            // System.out.println("不合法，return;  后不能在写代码");
        }
        //输出 1 2 3

循环标记：搭配break/continue
（使用场景：多层循环，如果在里层循环，达到某个条件后，结束指定循环。）

(1)带标签的continue不往下执行语句,直接返回标签所在处的循环开头,并继续执行该循环.
(2)带标签的break不往下执行语句,直接中断并退出标签所在处的循环.

continue + 标记（声明）

        outFlag1:
        while (true) {
            System.out.println("循环体1");
            outFlag2:
            while (true) {
                System.out.println("循环体2");
                continue outFlag1;
            }
        }
        //通过 debug  先执行  循环体1 到 循环体2 跳到 outFlag1的位置 再次来到 循环体1  依次类推
        //注意这个是死循环 如果能结束它是可以运行结束循环后的代码的

break+ 标记（声明）
这里break outFlag1; 跳到最外层循环的位置，表示这个循环块的代码已运行完毕，就会接着执行循环体后的代码。 那么这里如果 break outFlag2; 陷入了循环体1的死循环中，
它就会依次 输出 循环体1 、 循环体2

        outFlag1:
        while (true) {
            System.out.println("循环体1");
            outFlag2:
            while (true) {
                System.out.println("循环体2");
                break outFlag1;
            }
        }
        System.out.println("break之后执行此次代码");
        //通过 debug  先执行  循环体1 到 循环体2 跳到 outFlag1的位置 结束此次循环 来到  break之后执行此次代码

lamada表达式中foreach使用return

今天在用foreach循环的时候有一个逻辑判断需要跳出循环，但是lambda表达式不能用break也不能用continue，只有return可以用，但是用了之后发现，lambda表达式foreach的return和普通foreach循环的continue效果是一样的

        //lamada表达式中foreach使用return， break会报错
        List c = Arrays.asList("6666", "7777", "8888", "9999");
        c.stream().forEach(str -> {
            if ("8888".equals(str)) {
                return; //此处作用跳出当前循环,继续下一轮 相当于 for循环continue的作用
//                break; //IDEA提示错误
            }
            System.out.println(str);
        });
//输出：6666   7777     9999

lamada表达式中foreach如何退出循环

（在效率上我们的普通循环可能比 lamada还快，合理选择，那个会用哪个）
方式一：可以使用anyMatch()方法，anyMatch()里接收一个返回值为boolean类型的表达式，只要返回true就会终止循环，这样可以将业务逻辑写在返回判断结果前。

方式二：可以使用filter()方法，思路是一样的，其中findAny表示只要找到满足的条件时停止

break在switch中的应用

Java中的switch语句
（别纠结default后要不要break，只要你规范的把default放到最后，写不写无所谓，毕竟往下没其他代码运行了，但是case的时候要加上break，除非你有特殊需求）

         语法：switch(表达式) {
                          case 目标值1：
                                 执行语句1
                          break;

                          case 目标值2:
                                执行语句2
                          break;

                          case 目标值n：
                               执行语句n
                          break;

                         default:
                              执行语句n+1  
                          break;
							}
							
switch(A),括号中A的取值只能是整型或者可以转换为整型的数值类型，
比如byte、short、int、char、还有枚举、String；
注意enum是JDK5引入，switch支持String是JDK7支持
需要强调的是：long类型是不能作用在switch语句上的。	

这块的注意事项：
①：break语句是可选的,如果省略程序会执行紧接于其后的语句，一直到遇到break或整个switch语句运行完。

        switch (2){
            case 1:
                System.out.println("星期一");
            case 2:
                System.out.println("星期二");
            case 3:
                System.out.println("星期三");
            default :
                System.out.println("输入的数字不正确...");
        }
  System.out.println("输出=======星期二、星期三、输入的数字不正确...==============");

②：default语句是可选的，当表达式的值与case表达式常量的值都不匹配时，就运行default子句。

        switch (7){
            case 1:
                System.out.println("星期一");
            case 2:
                System.out.println("星期二");
            case 3:
                System.out.println("星期三");
        }
 System.out.println("输出=======无输出==============");



        switch (5){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default :
                System.out.println("输入的数字不正确...");

        }

        System.out.println("输出=======输入的数字不正确...==============");

③：default与case顺序在有break时无所谓，没有的话程序会执行紧接于其后的语句直到遇到break语句。

        switch (5){
            default :
                System.out.println("输入的数字不正确...");
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
        }
        System.out.println("输出=======输入的数字不正确... 、星期一 ==============");


        switch (5){
            default :
                System.out.println("输入的数字不正确...");
                break;
            case 1:
                System.out.println("星期一");

            case 2:
                System.out.println("星期二");

            case 3:
                System.out.println("星期三");
        }
        System.out.println("输出=======输入的数字不正确...==============");

switch 中 break和return的区别

break只会退出当前switch语句,会继续执行下面的代码
return 直接跳出当前方法，不会执行下面的代码
即：break只是退出当前switch块，不影响switch语句之后其他代码的执行。而return结束整个方法，无论switch块之后是否有其他代码需要执行。

至于选择break还是return根据你的业务需求来定

    public static   String getName(int i) {
        switch(i) {
            case 1:return "小明";  //正确代码
            case 2:return "小红";  //正确代码
            case 3:return "小强";  //正确代码
            default: return null; //正确代码
        }
    }

Java中switch和if语句的区别

1、相同点

都是用来处理多分支条件的结构是用来处理多分支条件的结构。

2、不同点

（1）switch只做等值判断；

（2）if没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况。

java中的循环

java中的循环有四种

死循环

        while (true) {
        }
      

        for (; ; ) {
        }

循环也由四部分组成

1.初始部分：循环判断的变量

2.循环条件：布尔表达式

3.循环操作：循环执行的代码

4.迭代部分：更新循环变量

循环之间的区别：

for循环和其他两个循环的区别：

for循环（标准写法）执行结束后，初始化条件就不能用了。而其他两个循环可以。

实际开发中：能用for就用for，否则考虑使用while，do…while

do…while循环和其他两个循环的区别：

do…while循环的循环体至少执行一次，而其他两个循环是先判断，然后决定是否执行。

while循环
while的特点：首次判断不满足，则一次都不会执行。先判断，再执行，适用于循环次数明确的情况

==do-while循环 ==

==for循环 ==