Thinking in Java，Foreach语法，标签

for循环常用于执行“计数”任务

public class TJpritice {
    public static void main(String[] args) {
        for(char c=0;c<128;c++){
            if(Character.isLowerCase(c)){
                System.out.println("value:"+(int)c+" character:"+c);
            }
        }
    }
}

Foreach语法

Java SE5引入了一种新的更加简洁的for语法用于数组和容器，即foreach语法，表示不必创建int变量去对由访问项构成的序列进行计数，foreach将自动产生每一项。
例如，假设有一个float数组，我们要选取该数组中的每一个元素：

import java.util.Random;
public class ForEachFloat {

    public static void main(String[] args) {
        Random random=new Random(47);
        float f[]=new float[10];
        for(int i=0;i<10;i++){
            f[i]=random.nextFloat();
        }
        for(float x:f){
            System.out.println(x);
        }
    }
}

这个数组是用旧时的for循环组装的，因为再组装时必须按索引访问它。在下面这行中可以看到foreach语法：

for（float x：f）{

这条语句定义了一个float类型的变量x，继而将每一个f的元素赋值给x。
任何返回一个数组的方法都可以使用foreach。例如，String类有一个方法toCharArray（），它返回一个char数组，因此可以很容易地像下面这样迭代在字符串里面的所有字符；

public class ForEachString {

    public static void main(String[] args) {
        for(char c:"sing dance rap basketball".toCharArray()){
            System.out.print(c+" ");
        }
    }
}

break和continue在for和while循环中的例子

public class BreakAndContinue {

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            if(i==74){
                break;
            }
            if(i%9!=0){
                continue;
            }
            System.out.print(i+" ");
        }
        int i=0;
        System.out.println("");
        while(true){
            i++;
            int j=i*27;
            if(j==1269){
                break;
            }
            if(i%10!=0){
                continue;
            }
            System.out.print(i+" ");
        }
    }
}

在这个for循环中，i的值永远不会达到100，因为一旦i到达74，break语句就会中断循环，通常，只有在不知道中断条件如何满足时，才需要这样使用break。只要i不能被9整除，continue语句就会执行过程返回到循环的最开头（这使i值递增）。如果能整除，则将值显示出来。
最后，可以看到一个“无穷while循环”的情况。然而，循环内部有一个break语句，可终止循环。除此之外，大家还会看到contine语句执行序列移回到循环的开头，而没有去完成continue语句之后的所有内容。
无穷循环的第二种形式是，for(; ; )

标签

尽管goto仍是Java中的一个保留字，但在语言中并未使用它；Java没有goto。然而Java也能完成一些类似于跳转的操作，这与break和continue这两个关键词有关。它们其实不是一个跳转，而是中断迭代语句的一种方法。之所以把他们纳入goto问题中一起讨论，是由于它们使用了相同的机制：标签。
标签是后面跟有冒号的标识符，就像下面这样：

label1：

在java中，标签起作用的唯一的地方刚好是在迭代语句之前。“刚好之前”的意思表面，在标签和迭代之间植入任何语句都不好。而在迭代之前设置标签的唯一理由是：我们希望在其中嵌套另一个迭代或者一个开关。这是由于break和continue关键词通常只中断当前循环，但若随着标签一起使用，它们就会中断循环，直到标签所在的地方：

label1:
outer-iteration{
	inner-iteration{
		//...
		break;//(1)
		//...
		continue;//(2)
		//...
		continue label1;//(3)
		//...
		break laberl1;//(4)
	}
}	

在(1)中，break中断内部迭代，回到外部迭代。在(2)中，continue使执行点回到内部迭代的起始处。在(3）中，continue label1同时中断内部迭代和外部迭代，直接转到label1处；随后它实际上使继续迭代过程，但却从外部迭代开始。在(4）中，break label1也会中断所有迭代，并回到label1处，但并不重新进入迭代。也就是说，它实际是完全终止了两个迭代。
标签的例子：

public class LabeledFor {

    public static void main(String[] args) {
        int i=0;
        outer:
        for(;true;){
            inner:
            for(;i<10;i++){
                System.out.println("i= "+i);
                if(i==2){
                    System.out.println("continue");
                    continue;
                }
                if(i==3){
                    System.out.println("break");
                    i++;
                    break;
                }
                if(i==7){
                    System.out.println("continue outer");
                    i++;
                    continue outer;
                }
                if(i==8){
                    System.out.println("break outer");
                    break outer;
                }
                for(int k=0;k<5;k++){
                    if(k==3){
                        System.out.println("coutinue inner");
                        continue inner;
                    }
                }
            }
        }
    }
}

结果如下：

i= 0
coutinue inner
i= 1
coutinue inner
i= 2
continue
i= 3
break
i= 4
coutinue inner
i= 5
coutinue inner
i= 6
coutinue inner
i= 7
continue outer
i= 8
break outer

注意，break会中断for循环，而且在抵达for循环的末尾之前，递增表达式不会执行。由于break跳过了递增表达式，所以在i= =3的情况下直接对i执行递增运算。i==7的情况下，continue outer语句会跳到循环顶部，而且也会跳过递增，所以这里也对i直接递增。如果没有break outer 语句，就没有办法从内部循环里跳出外部循环。这是由于break本身只能中断最内层的循环（continue同样也是如此）。
当然，如果想在中断循环中同时退出，简单地用一个return即可。
break以及continue在while循环中的用法：

public class LabeledWhile {

    public static void main(String[] args) {
        int i=0;
        outer:
        while (true) {
            System.out.println("Ourer while loop");
            while(true){
                i++;
                System.out.println("i= "+i);
                if(i==1){
                    System.out.println("continue");
                    continue;
                }
                if(i==3){
                    System.out.println("continue outer");
                    continue outer;
                }
                if(i==5){
                    System.out.println("break");
                    break;
                }
                if(i==7){
                    System.out.println("break outer");
                    break outer;
                }
            }
        }
    }
}

输出结果如下

Ourer while loop
i= 1
continue
i= 2
i= 3
continue outer
Ourer while loop
i= 4
i= 5
break
Ourer while loop
i= 6
i= 7
break outer

同样的规则同样适用于while：

1. 一般的continue会退回最内层循环的开头（顶部），并继续执行。
2. 带标签的continue会到达标签的位置，并重新进入紧接在那个标签后面的循环
3. 一般的break会中断并跳出当前循环
4. 带标签的break会中断并跳出标签所指的循环
   **重点：**在Java里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中break或contine。

switch

public class Switch {

    public static void main(String[] args) {
        Random rand=new Random();
        for(int i=0;i<20;i++){
            int c=rand.nextInt(26)+'a';
            System.out.print((char)c+", "+c+":");
            switch(c){
                case 'a':
                case 'e':
                case 'i':
                case 'o':
                case 'u':System.out.println("vowel");
                        break;
                case 'y':
                case 'w':System.out.println("sometimes a vowel");
                default: System.out.println("consonant");
            }
        }
    }
}

结果

v, 118:consonant
s, 115:consonant
v, 118:consonant
m, 109:consonant
w, 119:sometimes a vowel
consonant
l, 108:consonant
a, 97:vowel
u, 117:vowel
f, 102:consonant
u, 117:vowel
g, 103:consonant
m, 109:consonant
k, 107:consonant
a, 97:vowel
a, 97:vowel
g, 103:consonant
p, 112:consonant
g, 103:consonant
d, 100:consonant
e, 101:vowel