自学内容网 自学内容网

板凳-----第五章 控制流

5.1 true 和 false

public class TrueFalse { 
public static void main(String[] args) { 
System.out.println( 1 == 1);
System.out.printtn(1 == 2);
}
}

5.2 if-else

public class IfElse {
  static int result = 0;
  static void test(int testval, int target) {
    if(testval > target)
      result = +1;
    else if(testval < target)           // [1]                                                                            
      result = -1;
    else
      result = 0; // Match                                                                                                
  }
  public static void main(String[] args) {
    test(10, 5);
    System.out.println(result);
    test(5, 10);
    System.out.println(result);
    test(5, 5);
    System.out.println(result);
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:IfElse
Starting a Gradle Daemon (subsequent builds will be faster)

Task :control:IfElse
1
-1
0

5.3迭代语句

public class WhileTest {
  static boolean condition() {
    boolean result = Math.random() < 0.99;
    System.out.print(result + ", ");
    return result;
  }
  public static void main(String[] args) {
    while(condition())
      System.out.println("Inside 'while'");
    System.out.println("Exited 'while'");
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:WhileTest

Task :control:WhileTest
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
false, Exited ‘while’

BUILD SUCCESSFUL in 2s
4 actionable tasks: 1 executed, 3 up-to-date
condition()方法使用了 Math库里的静态方法random()。该方法会生成一个范围为0~1 (包括0,但不包括1 ) double 值。返回的结果是一个布尔值. 通过比较操作符<产生。while条件表达式的意思是“ 复执行循环里的主体语句 直到condition() 方法返回false”

5.3.1 do-while

5.3.2 for

public class ListCharacters {
  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);
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ListCharacters

Task :control:ListCharacters
value: 97 character: a
value: 98 character: b
value: 99 character: c
value: 100 character: d
value: 101 character: e
value: 102 character: f
value: 103 character: g
value: 104 character: h
value: 105 character: i
value: 106 character: j
value: 107 character: k
value: 108 character: l
value: 109 character: m
value: 110 character: n
value: 111 character: o
value: 112 character: p
value: 113 character: q
value: 114 character: r
value: 115 character: s
value: 116 character: t
value: 117 character: u
value: 118 character: v
value: 119 character: w
value: 120 character: x
value: 121 character: y
value: 122 character: z

BUILD SUCCESSFUL in 1s
4 actionable tasks: 1 executed, 3 up-to-date

5.3.3逗号操作符

public class CommaOperator {
  public static void main(String[] args) {
    for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
      System.out.println("i = " + i + " j = " + j);
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:CommaOperator

Task :control:CommaOperator
i = 1 j = 11
i = 2 j = 4
i = 3 j = 6
i = 4 j = 8

BUILD SUCCESSFUL in 1s
4 actionable tasks: 1 executed, 3 up-to-date

5.4 for-in 语法

for-in语句会自动为你生成每一项元素 这样你就不需要创建int变量来对这个元素构成的序列进行计数。

import java.util.*;

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

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInFloat

Task :control:ForInFloat
0.72711575
0.39982635
0.5309454
0.0534122
0.16020656
0.57799757
0.18847865
0.4170137
0.51660204
0.73734957

BUILD SUCCESSFUL in 1s

任何返回了数组的方法都可以使用for-in0

public class ForInString {
  public static void main(String[] args) {
    for(char c : "An African Swallow".toCharArray())
      System.out.print(c + " ");
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInString
Starting a Gradle Daemon (subsequent builds will be faster)

Task :control:ForInString
A n A f r i c a n S w a l l o w

for(int i = 0;i < 100 ; i++)
你可以在import这一行看到static import语法 .对于这些语句 for-in语法不起作用 因为你需要先创建一个int数组。为了简化这些任务 onJava.Range包里创建了一个range() 方法 它会自动生成合适的数组。


import static onjava.Range.*;

public class ForInInt {
  public static void main(String[] args) {
    for(int i : range(10)) // 0..9
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(5, 10)) // 5..9
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(5, 20, 3)) // 5..20 step 3
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(20, 5, -3)) // Count down
      System.out.print(i + " ");
    System.out.println();
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInInt

Task :control:ForInInt
0 1 2 3 4 5 6 7 8 9
5 6 7 8 9
5 8 11 14 17
20 17 14 11 8
range()方法已经被定载(overloaded).重载表示方法名相同但具有不同的参数列表。range()方法的第一种重载形式是从0开始产生值 直到范围的上限 但不包括这个上限。第二种形式是从第一个参数值幵始产生值 直到比第二个参数值小为止。第三种形式有一个步进值 它每次增加的步幅为该值。在第四种形式中可以倒计时。range()其实就是一个简化版的生成器

5.5 return

return关键字有两种用途 它可以指定一个方法的返回值(如果不存在就返回void ), 还会导致当前的方法退出 并且返回这个值。

public class TestWithReturn {
  static int test(int testval, int target) {
    if(testval > target)
      return +1;
    if(testval < target)
      return -1;
    return 0; // Match
  }
  public static void main(String[] args) {
    System.out.println(test(10, 5));
    System.out.println(test(5, 10));
    System.out.println(test(5, 5));
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:TestWithReturn

Task :control:TestWithReturn
1
-1
0

如果在一个返回了 void的方法中没有return语句 那么该方法的结尾处会有一个隐含的return,所以方法里并不一定会有一个return 。 是如果你的方法声明了它将返回一个非void的值 那就必须确保每一条代码路径都会返回一个值。

5.6 break continue

import static onjava.Range.*;

public class BreakAndContinue {
  public static void main(String[] args) {
    for(int i = 0; i < 100; i++) {        // [1]
      if(i == 74) break; // Out of for loop
      if(i % 9 != 0) continue; // Next iteration
      System.out.print(i + " ");
    }
    System.out.println();
    // Using for-in:
    for(int i : range(100)) {             // [2]
      if(i == 74) break; // Out of for loop
      if(i % 9 != 0) continue; // Next iteration
      System.out.print(i + " ");
    }
    System.out.println();
    int i = 0;
    // An "infinite loop":
    while(true) {                         // [3]
      i++;
      int j = i * 27;
      if(j == 1269) break; // Out of loop
      if(i % 10 != 0) continue; // Top of loop
      System.out.print(i + " ");
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:BreakAndContinue

Task :control:BreakAndContinue
0 9 18 27 36 45 54 63 72
0 9 18 27 36 45 54 63 72
10 20 30 40
BUILD SUCCESSFUL in 1s
通常只有在不知道中断条件何时发生时 才会这样使用break。只要i不能被9整除, continue语句就会返回到循环的开头再继续执行 因此这会让i值增加 。如果能够整除值就被打印出来。

5.7臭名昭者的goto

goto是在源码级别上进行的跳转 这给它带来了坏名声。
真正的问题并不在于goto本身 而在于滥用goto.
label1:
在Java 放置标签的唯一地方是正好在迭代语句之前。“正 好”的意思就是,不要在标签和迭代之间播入任何语句。在迭代之前使用标签的唯一原因是 你要在这个迭代里再嵌套一个迭代或一个switch 。这是因为break continue 常只会中断当前循环 但和标签一起用时 它们可以中断这个嵌套的循环 直接跳转到标签所在的位置。

label1: 
outer-iteration { 
inner-iteration { 
// ... 
break;     //[1]
// ... 
continue;  //[2]
// ....
continue label1; // [3]
// ...
break label1   //[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: // Can't have statements here
    for(; true ;) { // infinite loop
      inner: // Can't have statements here
      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++; // Otherwise i never
               // gets incremented.
          break;
        }
        if(i == 7) {
          System.out.println("continue outer");
          i++; // Otherwise i never
               // gets incremented.
          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("continue inner");
            continue inner;
          }
        }
      }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:LabeledFor

Task :control:LabeledFor
i = 0
continue inner
i = 1
continue inner
i = 2
continue
i = 3
break
i = 4
continue inner
i = 5
continue inner
i = 6
continue inner
i = 7
continue outer
i = 8
break outer

BUILD SUCCESSFUL in 1s
注意break中断了 for循环,而 for循环在执行到末尾之前 它的递增表达式不会执行。因为break导致递增表达式被跳过 所以我们在i ==7的分支也是这样 continue outer语句会跳到外部循环顶部. 并且跳过内部循环的递增表达式执行 因此我们在这里也进行了直接递增。如果没有break outer语句 我们就没有办法从内部循环直接跳出外部循环。这是因break本身只能中断最内层的循环, continue也是一样 。如果要在中断循环的同时退出方法 直接用return就可以了。

  1. 普通的continue会跳到最内层循环的起始处 并继续执行。
    2 带标签的continue会跳到对应标签的位置 并重新进入这个标签后面的循环。
    3 普通的bieak “ 出循环的底部” 也就是跳出当前循环。
    4 带标签的break会跳出标签所指的循环。
    带标签的break continue是较少使用的试验性功能 在此前的编程语言中几乎没有先例。
    一定要记住 Java里使用标签的唯一理由就是你用到了嵌套循环 而且你需要使break continue来跳出多层的嵌套。

5.8 switch

import java.util.*;

public class VowelsAndConsonants {
  public static void main(String[] args) {
    Random rand = new Random(47);
    for(int i = 0; i < 100; 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 vowel");
                  break;
        default:  System.out.println("consonant");
      }
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:VowelsAndConsonants

Task :control:VowelsAndConsonants
y, 121: Sometimes vowel
n, 110: consonant
z, 122: consonant
b, 98: consonant
r, 114: consonant
n, 110: consonant
y, 121: Sometimes vowel
g, 103: consonant
c, 99: consonant
f, 102: consonant
o, 111: vowel
w, 119: Sometimes vowel
z, 122: consonant
n, 110: consonant
t, 116: consonant
c, 99: consonant
q, 113: consonant
r, 114: consonant
g, 103: consonant
s, 115: consonant
e, 101: vowel
g, 103: consonant
z, 122: consonant
m, 109: consonant
m, 109: consonant
j, 106: consonant
m, 109: consonant
r, 114: consonant
o, 111: vowel
e, 101: vowel
s, 115: consonant
u, 117: vowel
e, 101: vowel
c, 99: consonant
u, 117: vowel
o, 111: vowel
n, 110: consonant
e, 101: vowel
o, 111: vowel
e, 101: vowel
d, 100: consonant
l, 108: consonant
s, 115: consonant
m, 109: consonant
w, 119: Sometimes vowel
h, 104: consonant
l, 108: consonant
g, 103: consonant
e, 101: vowel
a, 97: vowel
h, 104: consonant
k, 107: consonant
c, 99: consonant
x, 120: consonant
r, 114: consonant
e, 101: vowel
q, 113: consonant
u, 117: vowel
c, 99: consonant
b, 98: consonant
b, 98: consonant
k, 107: consonant
i, 105: vowel
n, 110: consonant
a, 97: vowel
m, 109: consonant
e, 101: vowel
s, 115: consonant
b, 98: consonant
t, 116: consonant
w, 119: Sometimes vowel
h, 104: consonant
k, 107: consonant
j, 106: consonant
u, 117: vowel
r, 114: consonant
u, 117: vowel
k, 107: consonant
z, 122: consonant
p, 112: consonant
g, 103: consonant
w, 119: Sometimes vowel
s, 115: consonant
q, 113: consonant
p, 112: consonant
z, 122: consonant
d, 100: consonant
y, 121: Sometimes vowel
c, 99: consonant
y, 121: Sometimes vowel
r, 114: consonant
f, 102: consonant
j, 106: consonant
q, 113: consonant
a, 97: vowel
h, 104: consonant
x, 120: consonant
x, 120: consonant
h, 104: consonant
v, 118: consonant

BUILD SUCCESSFUL in 1s
Random.nextlnt(26)会产生一个0~25范围内的值 所以你只需要加上一个偏移量就能生成小写字母a。 case语句中 使用单引号包围的字符也能生成用于比较的整数值。
int c = rand.nextlnt(26) + ‘a’
Random.nextlnt()产生了一个0~25范围内的随机int 然后和a的值相加。这表示a会自动转换为int,以执行加法操作。

5.9字符串作为选择器

public class StringSwitch {
  public static void main(String[] args) {
    String color = "red";
    // Old way: using if-then
    if("red".equals(color)) {
      System.out.println("RED");
    } else if("green".equals(color)) {
      System.out.println("GREEN");
    } else if("blue".equals(color)) {
      System.out.println("BLUE");
    } else if("yellow".equals(color)) {
      System.out.println("YELLOW");
    } else {
      System.out.println("Unknown");
    }
    // New way: Strings in switch
    switch(color) {
      case "red":
        System.out.println("RED");
        break;
      case "green":
        System.out.println("GREEN");
        break;
      case "blue":
        System.out.println("BLUE");
        break;
      case "yellow":
        System.out.println("YELLOW");
        break;
      default:
        System.out.println("Unknown");
        break;
    }
  }
}

(base) wannian07@wannian07-PC:~/Desktop/java/example/control$ java StringSwitch
RED
RED


import onjava.*;

public class RandomBounds {
  public static void main(String[] args) {
    new TimedAbort(3);
    switch(args.length == 0 ? "" : args[0]) {
      case "lower":
        while(Math.random() != 0.0)
          ; // Keep trying
        System.out.println("Produced 0.0!");
        break;
      case "upper":
        while(Math.random() != 1.0)
          ; // Keep trying
        System.out.println("Produced 1.0!");
        break;
      default:
        System.out.println("Usage:");
        System.out.println("\tRandomBounds lower");
        System.out.println("\tRandomBounds upper");
        System.exit(1);
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:RandomBounds

Task :control:RandomBounds
TimedAbort 3.0


原文地址:https://blog.csdn.net/fengye207161/article/details/140531832

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!